prebid.js 8.6.0 → 8.8.0

package/modules/automatadAnalyticsAdapter.js

@@ -0,0 +1,325 @@
+import {
+  logError,
+  logInfo,
+  logMessage
+} from '../src/utils.js';
+
+import CONSTANTS from '../src/constants.json';
+import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
+import adapterManager from '../src/adapterManager.js';
+import { config } from '../src/config.js'
+
+/** Prebid Event Handlers */
+
+const ADAPTER_CODE = 'automatadAnalytics'
+const trialCountMilsMapping = [1500, 3000, 5000, 10000];
+
+var isLoggingEnabled; var queuePointer = 0; var retryCount = 0; var timer = null; var __atmtdAnalyticsQueue = [];
+
+const prettyLog = (level, text, isGroup = false, cb = () => {}) => {
+  if (self.isLoggingEnabled === undefined) {
+    if (window.localStorage.getItem('__aggLoggingEnabled')) {
+      self.isLoggingEnabled = true
+    } else {
+      const queryParams = new URLSearchParams(new URL(window.location.href).search)
+      self.isLoggingEnabled = queryParams.has('aggLoggingEnabled')
+    }
+  }
+
+  if (self.isLoggingEnabled) {
+    if (isGroup) {
+      logInfo(`ATD Analytics Adapter: ${level.toUpperCase()}: ${text} --- Group Start ---`)
+      try {
+        cb();
+      } catch (error) {
+        logError(`ATD Analytics Adapter: ERROR: ${'Error during cb function in prettyLog'}`)
+      }
+      logInfo(`ATD Analytics Adapter: ${level.toUpperCase()}: ${text} --- Group End ---`)
+    } else {
+      logInfo(`ATD Analytics Adapter: ${level.toUpperCase()}: ${text}`)
+    }
+  }
+}
+
+const processEvents = () => {
+  if (self.retryCount === trialCountMilsMapping.length) {
+    self.prettyLog('error', `Aggregator still hasn't loaded. Processing que stopped`, trialCountMilsMapping, self.retryCount)
+    return;
+  }
+
+  self.prettyLog('status', `Que has been inactive for a while. Adapter starting to process que now... Trial Count = ${self.retryCount + 1}`)
+
+  let shouldTryAgain = false
+
+  while (self.queuePointer < self.__atmtdAnalyticsQueue.length) {
+    const eventType = self.__atmtdAnalyticsQueue[self.queuePointer][0]
+    const args = self.__atmtdAnalyticsQueue[self.queuePointer][1]
+
+    try {
+      switch (eventType) {
+        case CONSTANTS.EVENTS.AUCTION_INIT:
+          if (window.atmtdAnalytics && window.atmtdAnalytics.auctionInitHandler) {
+            window.atmtdAnalytics.auctionInitHandler(args);
+          } else {
+            shouldTryAgain = true
+          }
+          break;
+        case CONSTANTS.EVENTS.BID_REQUESTED:
+          if (window.atmtdAnalytics && window.atmtdAnalytics.bidRequestedHandler) {
+            window.atmtdAnalytics.bidRequestedHandler(args);
+          }
+          break;
+        case CONSTANTS.EVENTS.BID_RESPONSE:
+          if (window.atmtdAnalytics && window.atmtdAnalytics.bidResponseHandler) {
+            window.atmtdAnalytics.bidResponseHandler(args);
+          }
+          break;
+        case CONSTANTS.EVENTS.BID_REJECTED:
+          if (window.atmtdAnalytics && window.atmtdAnalytics.bidRejectedHandler) {
+            window.atmtdAnalytics.bidRejectedHandler(args);
+          }
+          break;
+        case CONSTANTS.EVENTS.BIDDER_DONE:
+          if (window.atmtdAnalytics && window.atmtdAnalytics.bidderDoneHandler) {
+            window.atmtdAnalytics.bidderDoneHandler(args);
+          }
+          break;
+        case CONSTANTS.EVENTS.BID_WON:
+          if (window.atmtdAnalytics && window.atmtdAnalytics.bidWonHandler) {
+            window.atmtdAnalytics.bidWonHandler(args);
+          }
+          break;
+        case CONSTANTS.EVENTS.NO_BID:
+          if (window.atmtdAnalytics && window.atmtdAnalytics.noBidHandler) {
+            window.atmtdAnalytics.noBidHandler(args);
+          }
+          break;
+        case CONSTANTS.EVENTS.BID_TIMEOUT:
+          if (window.atmtdAnalytics && window.atmtdAnalytics.bidderTimeoutHandler) {
+            window.atmtdAnalytics.bidderTimeoutHandler(args);
+          }
+          break;
+        case CONSTANTS.EVENTS.AUCTION_DEBUG:
+          if (window.atmtdAnalytics && window.atmtdAnalytics.auctionDebugHandler) {
+            window.atmtdAnalytics.auctionDebugHandler(args);
+          }
+          break;
+        case 'slotRenderEnded':
+          if (window.atmtdAnalytics && window.atmtdAnalytics.slotRenderEndedGPTHandler) {
+            window.atmtdAnalytics.slotRenderEndedGPTHandler(args);
+          } else {
+            shouldTryAgain = true
+          }
+          break;
+        case 'impressionViewable':
+          if (window.atmtdAnalytics && window.atmtdAnalytics.impressionViewableHandler) {
+            window.atmtdAnalytics.impressionViewableHandler(args);
+          } else {
+            shouldTryAgain = true
+          }
+          break;
+      }
+
+      if (shouldTryAgain) break;
+    } catch (error) {
+      self.prettyLog('error', `Unhandled Error while processing ${eventType} of ${self.queuePointer}th index in the que. Will not be retrying this raw event ...`, true, () => {
+        logError(`The error is `, error)
+      })
+    }
+
+    self.queuePointer = self.queuePointer + 1
+  }
+
+  if (shouldTryAgain) {
+    if (trialCountMilsMapping[self.retryCount]) self.prettyLog('warn', `Adapter failed to process event as aggregator has not loaded. Retrying in ${trialCountMilsMapping[self.retryCount]}ms ...`);
+    setTimeout(self.processEvents, trialCountMilsMapping[self.retryCount])
+    self.retryCount = self.retryCount + 1
+  }
+}
+
+const addGPTHandlers = () => {
+  const googletag = window.googletag || {}
+  googletag.cmd = googletag.cmd || []
+  googletag.cmd.push(() => {
+    googletag.pubads().addEventListener('slotRenderEnded', (event) => {
+      if (window.atmtdAnalytics && window.atmtdAnalytics.slotRenderEndedGPTHandler) {
+        if (window.__atmtdAggregatorFirstAuctionInitialized === true) {
+          window.atmtdAnalytics.slotRenderEndedGPTHandler(event)
+          return;
+        }
+      }
+      self.__atmtdAnalyticsQueue.push(['slotRenderEnded', event])
+      self.prettyLog(`warn`, `Aggregator not initialised at auctionInit, exiting slotRenderEnded handler and pushing to que instead`)
+    })
+
+    googletag.pubads().addEventListener('impressionViewable', (event) => {
+      if (window.atmtdAnalytics && window.atmtdAnalytics.impressionViewableHandler) {
+        if (window.__atmtdAggregatorFirstAuctionInitialized === true) {
+          window.atmtdAnalytics.impressionViewableHandler(event)
+          return;
+        }
+      }
+      self.__atmtdAnalyticsQueue.push(['impressionViewable', event])
+      self.prettyLog(`warn`, `Aggregator not initialised at auctionInit, exiting impressionViewable handler and pushing to que instead`)
+    })
+  })
+}
+
+const initializeQueue = () => {
+  self.__atmtdAnalyticsQueue.push = (args) => {
+    Array.prototype.push.apply(self.__atmtdAnalyticsQueue, [args]);
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+
+    if (args[0] === CONSTANTS.EVENTS.AUCTION_INIT) {
+      const timeout = parseInt(config.getConfig('bidderTimeout')) + 1500
+      timer = setTimeout(() => {
+        self.processEvents()
+      }, timeout);
+    } else {
+      timer = setTimeout(() => {
+        self.processEvents()
+      }, 1500);
+    }
+  };
+}
+
+// ANALYTICS ADAPTER
+
+let baseAdapter = adapter({analyticsType: 'bundle'});
+let atmtdAdapter = Object.assign({}, baseAdapter, {
+
+  disableAnalytics() {
+    baseAdapter.disableAnalytics.apply(this, arguments);
+  },
+
+  track({eventType, args}) {
+    switch (eventType) {
+      case CONSTANTS.EVENTS.AUCTION_INIT:
+        if (window.atmtdAnalytics && window.atmtdAnalytics.auctionInitHandler) {
+          self.prettyLog('status', 'Aggregator loaded, initialising auction through handlers');
+          window.atmtdAnalytics.auctionInitHandler(args);
+        } else {
+          self.prettyLog('warn', 'Aggregator not loaded, initialising auction through que ...');
+          self.__atmtdAnalyticsQueue.push([eventType, args])
+        }
+        break;
+      case CONSTANTS.EVENTS.BID_REQUESTED:
+        if (window.atmtdAnalytics && window.atmtdAnalytics.bidRequestedHandler) {
+          window.atmtdAnalytics.bidRequestedHandler(args);
+        } else {
+          self.prettyLog('warn', `Aggregator not loaded, pushing ${eventType} to que instead ...`);
+          self.__atmtdAnalyticsQueue.push([eventType, args])
+        }
+        break;
+      case CONSTANTS.EVENTS.BID_REJECTED:
+        if (window.atmtdAnalytics && window.atmtdAnalytics.bidRejectedHandler) {
+          window.atmtdAnalytics.bidRejectedHandler(args);
+        } else {
+          self.prettyLog('warn', `Aggregator not loaded, pushing ${eventType} to que instead ...`);
+          self.__atmtdAnalyticsQueue.push([eventType, args])
+        }
+        break;
+      case CONSTANTS.EVENTS.BID_RESPONSE:
+        if (window.atmtdAnalytics && window.atmtdAnalytics.bidResponseHandler) {
+          window.atmtdAnalytics.bidResponseHandler(args);
+        } else {
+          self.prettyLog('warn', `Aggregator not loaded, pushing ${eventType} to que instead ...`);
+          self.__atmtdAnalyticsQueue.push([eventType, args])
+        }
+        break;
+      case CONSTANTS.EVENTS.BIDDER_DONE:
+        if (window.atmtdAnalytics && window.atmtdAnalytics.bidderDoneHandler) {
+          window.atmtdAnalytics.bidderDoneHandler(args);
+        } else {
+          self.prettyLog('warn', `Aggregator not loaded, pushing ${eventType} to que instead ...`);
+          self.__atmtdAnalyticsQueue.push([eventType, args])
+        }
+        break;
+      case CONSTANTS.EVENTS.BID_WON:
+        if (window.atmtdAnalytics && window.atmtdAnalytics.bidWonHandler) {
+          window.atmtdAnalytics.bidWonHandler(args);
+        } else {
+          self.prettyLog('warn', `Aggregator not loaded, pushing ${eventType} to que instead ...`);
+          self.__atmtdAnalyticsQueue.push([eventType, args])
+        }
+        break;
+      case CONSTANTS.EVENTS.NO_BID:
+        if (window.atmtdAnalytics && window.atmtdAnalytics.noBidHandler) {
+          window.atmtdAnalytics.noBidHandler(args);
+        } else {
+          self.prettyLog('warn', `Aggregator not loaded, pushing ${eventType} to que instead ...`);
+          self.__atmtdAnalyticsQueue.push([eventType, args])
+        }
+        break;
+      case CONSTANTS.EVENTS.AUCTION_DEBUG:
+        if (window.atmtdAnalytics && window.atmtdAnalytics.auctionDebugHandler) {
+          window.atmtdAnalytics.auctionDebugHandler(args);
+        } else {
+          self.prettyLog('warn', `Aggregator not loaded, pushing ${eventType} to que instead ...`);
+          self.__atmtdAnalyticsQueue.push([eventType, args])
+        }
+        break;
+      case CONSTANTS.EVENTS.BID_TIMEOUT:
+        if (window.atmtdAnalytics && window.atmtdAnalytics.bidderTimeoutHandler) {
+          window.atmtdAnalytics.bidderTimeoutHandler(args);
+        } else {
+          self.prettyLog('warn', `Aggregator not loaded, pushing ${eventType} to que instead ...`);
+          self.__atmtdAnalyticsQueue.push([eventType, args])
+        }
+        break;
+    }
+  }
+});
+
+atmtdAdapter.originEnableAnalytics = atmtdAdapter.enableAnalytics
+
+atmtdAdapter.enableAnalytics = function (configuration) {
+  if ((configuration === undefined && typeof configuration !== 'object') || configuration.options === undefined) {
+    logError('A valid configuration must be passed to the Atmtd Analytics Adapter.');
+    return;
+  }
+
+  const conf = configuration.options
+
+  if (conf === undefined || typeof conf !== 'object' || conf.siteID === undefined || conf.publisherID === undefined) {
+    logError('A valid publisher ID and siteID must be passed to the Atmtd Analytics Adapter.');
+    return;
+  }
+
+  self.initializeQueue()
+  self.addGPTHandlers()
+
+  window.__atmtdSDKConfig = {
+    publisherID: conf.publisherID,
+    siteID: conf.siteID,
+    collectDebugMessages: conf.logDebug ? conf.logDebug : false
+  }
+
+  logMessage(`Automatad Analytics Adapter enabled with sdk config`, window.__atmtdSDKConfig)
+
+  // eslint-disable-next-line
+  atmtdAdapter.originEnableAnalytics(configuration)
+};
+
+/// /////////// ADAPTER REGISTRATION //////////////
+
+adapterManager.registerAnalyticsAdapter({
+  adapter: atmtdAdapter,
+  code: ADAPTER_CODE
+});
+
+export var self = {
+  __atmtdAnalyticsQueue,
+  processEvents,
+  initializeQueue,
+  addGPTHandlers,
+  prettyLog,
+  queuePointer,
+  retryCount,
+  isLoggingEnabled
+}
+
+export default atmtdAdapter;

package/modules/automatadAnalyticsAdapter.md

@@ -0,0 +1,23 @@
+
+# Overview
+
+Module Name: Automatad Analytics Adapter
+Module Type: Analytics Adapter
+Maintainer: tech@automatad.com
+
+# Description
+
+Analytics adapter for automatad.com. Contact tech@automatad.com for information.
+
+# Test Parameters
+
+```
+{
+  provider: 'automatadAnalytics',
+  options: {
+    publisherID: 'N8vZLx',
+    siteID: 'PXfvBq'
+  }
+}
+
+```

package/modules/bidViewability.js

@@ -67,6 +67,8 @@ export let logWinningBidNotFound = (slot) => {
 
 export let impressionViewableHandler = (globalModuleConfig, slot, event) => {
   let respectiveBid = getMatchingWinningBidForGPTSlot(globalModuleConfig, slot);
+  let respectiveDeferredAdUnit = getGlobal().adUnits.find(adUnit => adUnit.deferBilling && respectiveBid.adUnitCode === adUnit.code);
+
   if (respectiveBid === null) {
     logWinningBidNotFound(slot);
   } else {
@@ -74,6 +76,11 @@ export let impressionViewableHandler = (globalModuleConfig, slot, event) => {
     fireViewabilityPixels(globalModuleConfig, respectiveBid);
     // trigger respective bidder's onBidViewable handler
     adapterManager.callBidViewableBidder(respectiveBid.adapterCode || respectiveBid.bidder, respectiveBid);
+
+    if (respectiveDeferredAdUnit) {
+      adapterManager.callBidBillableBidder(respectiveBid);
+    }
+
     // emit the BID_VIEWABLE event with bid details, this event can be consumed by bidders and analytics pixels
     events.emit(CONSTANTS.EVENTS.BID_VIEWABLE, respectiveBid);
   }

package/modules/bidViewability.md

@@ -2,19 +2,20 @@
 
 Module Name: bidViewability
 
-Purpose: Track when a bid is viewable
+Purpose: Track when a bid is viewable (and also ready for billing)
 
 Maintainer: harshad.mane@pubmatic.com
 
 # Description
-- This module, when included, will trigger a BID_VIEWABLE event which can be consumed by Analytics adapters, bidders will need to implement `onBidViewable` method to capture this event
-- Bidderes can check if this module is part of the final build and whether it is enabled or not by accessing ```pbjs.getConfig('bidViewability')```
+- This module, when included, will trigger a BID_VIEWABLE event which can be consumed by Analytics adapters, bidders will need to implement the `onBidViewable` method to capture this event
+- Bidders can check if this module is part of the final build and whether it is enabled or not by accessing ```pbjs.getConfig('bidViewability')```
 - GPT API is used to find when a bid is viewable, https://developers.google.com/publisher-tag/reference#googletag.events.impressionviewableevent . This event is fired when an impression becomes viewable, according to the Active View criteria.
 Refer: https://support.google.com/admanager/answer/4524488
-- The module does not work with adserver other than GAM with GPT integration
+- This module does not work with any adserver's other than GAM with GPT integration
 - Logic used to find a matching pbjs-bid for a GPT slot is ``` (slot.getAdUnitPath() === bid.adUnitCode || slot.getSlotElementId() === bid.adUnitCode) ``` this logic can be changed by using param ```customMatchFunction```
-- When a rendered PBJS bid is viewable the module will trigger BID_VIEWABLE event, which can be consumed by bidders and analytics adapters
-- For the viewable bid if ```bid.vurls type array``` param is and module config ``` firePixels: true ``` is set then the URLs mentioned in bid.vurls will be executed. Please note that GDPR and USP related parameters will be added to the given URLs
+- When a rendered PBJS bid is viewable the module will trigger a BID_VIEWABLE event, which can be consumed by bidders and analytics adapters
+- If the viewable bid contains a ```vurls``` param containing URL's and the Bid Viewability module is configured with ``` firePixels: true ``` then the URLs mentioned in bid.vurls will be called. Please note that GDPR and USP related parameters will be added to the given URLs
+- This module is also compatible with Prebid core's billing deferral logic, this means that bids linked to an ad unit marked with `deferBilling: true` will trigger a bid adapter's `onBidBillable` function (if present) indicating an ad slot was viewed and also billing ready (if it were deferred).
 
 # Params
 - enabled [required] [type: boolean, default: false], when set to true, the module will emit BID_VIEWABLE when applicable
@@ -44,6 +45,6 @@ Refer: https://support.google.com/admanager/answer/4524488
 ```
 
 # Please Note:
-- Doesn't seems to work with Instream Video, https://docs.prebid.org/dev-docs/examples/instream-banner-mix.html as GPT's impressionViewable event is not triggered for instream-video-creative
-- Works with Banner, Outsteam, Native creatives
+- This module doesn't seem to work with Instream Video, https://docs.prebid.org/dev-docs/examples/instream-banner-mix.html as GPT's impressionViewable event is not triggered for instream-video-creative
+- Works with Banner, Outsteam and Native creatives
 

package/modules/brandmetricsRtdProvider.js

@@ -21,13 +21,14 @@ let billableEventsInitialized = false
 
 function init (config, userConsent) {
   const hasConsent = checkConsent(userConsent)
+  const initialize = hasConsent !== false
 
-  if (hasConsent) {
+  if (initialize) {
     const moduleConfig = getMergedConfig(config)
     initializeBrandmetrics(moduleConfig.params.scriptId)
     initializeBillableEvents()
   }
-  return hasConsent
+  return initialize
 }
 
 /**
@@ -36,33 +37,35 @@ function init (config, userConsent) {
  * @returns {boolean}
  */
 function checkConsent (userConsent) {
-  let consent = false
-
-  if (userConsent && userConsent.gdpr && userConsent.gdpr.gdprApplies) {
-    const gdpr = userConsent.gdpr
-
-    if (gdpr.vendorData) {
-      const vendor = gdpr.vendorData.vendor
-      const purpose = gdpr.vendorData.purpose
-
-      let vendorConsent = false
-      if (vendor.consents) {
-        vendorConsent = vendor.consents[GVL_ID]
+  let consent
+
+  if (userConsent) {
+    if (userConsent.gdpr && userConsent.gdpr.gdprApplies) {
+      const gdpr = userConsent.gdpr
+
+      if (gdpr.vendorData) {
+        const vendor = gdpr.vendorData.vendor
+        const purpose = gdpr.vendorData.purpose
+
+        let vendorConsent = false
+        if (vendor.consents) {
+          vendorConsent = vendor.consents[GVL_ID]
+        }
+
+        if (vendor.legitimateInterests) {
+          vendorConsent = vendorConsent || vendor.legitimateInterests[GVL_ID]
+        }
+
+        const purposes = TCF_PURPOSES.map(id => {
+          return (purpose.consents && purpose.consents[id]) || (purpose.legitimateInterests && purpose.legitimateInterests[id])
+        })
+        const purposesValid = purposes.filter(p => p === true).length === TCF_PURPOSES.length
+        consent = vendorConsent && purposesValid
       }
-
-      if (vendor.legitimateInterests) {
-        vendorConsent = vendorConsent || vendor.legitimateInterests[GVL_ID]
-      }
-
-      const purposes = TCF_PURPOSES.map(id => {
-        return (purpose.consents && purpose.consents[id]) || (purpose.legitimateInterests && purpose.legitimateInterests[id])
-      })
-      const purposesValid = purposes.filter(p => p === true).length === TCF_PURPOSES.length
-      consent = vendorConsent && purposesValid
+    } else if (userConsent.usp) {
+      const usp = userConsent.usp
+      consent = usp[1] !== 'N' && usp[2] !== 'Y'
     }
-  } else if (userConsent.usp) {
-    const usp = userConsent.usp
-    consent = usp[1] !== 'N' && usp[2] !== 'Y'
   }
 
   return consent

package/modules/connatixBidAdapter.js

@@ -0,0 +1,185 @@
+import {
+  registerBidder
+} from '../src/adapters/bidderFactory.js';
+
+import {
+  deepAccess,
+  isFn,
+  logError,
+  isArray,
+  formatQS
+} from '../src/utils.js';
+
+import {
+  BANNER,
+} from '../src/mediaTypes.js';
+
+const BIDDER_CODE = 'connatix';
+const AD_URL = 'https://capi.connatix.com/rtb/hba';
+const DEFAULT_MAX_TTL = '3600';
+const DEFAULT_CURRENCY = 'USD';
+
+/*
+ * Get the bid floor value from the bid object, either using the getFloor function or by accessing the 'params.bidfloor' property.
+ * If the bid floor cannot be determined, return 0 as a fallback value.
+ */
+export function getBidFloor(bid) {
+  if (!isFn(bid.getFloor)) {
+    return deepAccess(bid, 'params.bidfloor', 0);
+  }
+
+  try {
+    const bidFloor = bid.getFloor({
+      currency: DEFAULT_CURRENCY,
+      mediaType: '*',
+      size: '*',
+    });
+    return bidFloor.floor;
+  } catch (err) {
+    logError(err);
+    return 0;
+  }
+}
+
+export const spec = {
+  code: BIDDER_CODE,
+  gvlid: 143,
+  supportedMediaTypes: [BANNER],
+
+  /*
+   * Validate the bid request.
+   * If the request is valid, Connatix is trying to obtain at least one bid.
+   * Otherwise, the request to the Connatix server is not made
+   */
+  isBidRequestValid: (bid = {}) => {
+    const bidId = deepAccess(bid, 'bidId');
+    const mediaTypes = deepAccess(bid, 'mediaTypes', {});
+    const params = deepAccess(bid, 'params', {});
+    const bidder = deepAccess(bid, 'bidder');
+
+    const banner = deepAccess(mediaTypes, BANNER, {});
+
+    const hasBidId = Boolean(bidId);
+    const isValidBidder = (bidder === BIDDER_CODE);
+    const isValidSize = (Boolean(banner.sizes) && isArray(mediaTypes[BANNER].sizes) && mediaTypes[BANNER].sizes.length > 0);
+    const hasSizes = mediaTypes[BANNER] ? isValidSize : false;
+    const hasRequiredBidParams = Boolean(params.placementId);
+
+    const isValid = isValidBidder && hasBidId && hasSizes && hasRequiredBidParams;
+    if (!isValid) {
+      logError(`Invalid bid request: isValidBidder: ${isValidBidder} hasBidId: ${hasBidId}, hasSizes: ${hasSizes}, hasRequiredBidParams: ${hasRequiredBidParams}`);
+    }
+    return isValid;
+  },
+
+  /*
+   * Build the request payload by processing valid bid requests and extracting the necessary information.
+   * Determine the host and page from the bidderRequest's refferUrl, and include ccpa and gdpr consents.
+   * Return an object containing the request method, url, and the constructed payload.
+   */
+  buildRequests: (validBidRequests = [], bidderRequest = {}) => {
+    const bidRequests = validBidRequests.map(bid => {
+      const {
+        bidId,
+        mediaTypes,
+        params,
+        sizes,
+      } = bid;
+      return {
+        bidId,
+        mediaTypes,
+        sizes,
+        placementId: params.placementId,
+        floor: getBidFloor(bid),
+      };
+    });
+
+    const requestPayload = {
+      ortb2: bidderRequest.ortb2,
+      gdprConsent: bidderRequest.gdprConsent,
+      uspConsent: bidderRequest.uspConsent,
+      refererInfo: bidderRequest.refererInfo,
+      bidRequests,
+    };
+
+    return {
+      method: 'POST',
+      url: AD_URL,
+      data: requestPayload
+    };
+  },
+
+  /*
+   * Interpret the server response and create an array of bid responses by extracting and formatting
+   * relevant information such as requestId, cpm, ttl, width, height, creativeId, referrer and ad
+   * Returns an array of bid responses by extracting and formatting the server response
+   */
+  interpretResponse: (serverResponse) => {
+    const responseBody = serverResponse.body;
+    const bids = responseBody.Bids;
+    const playerId = responseBody.PlayerId;
+    const customerId = responseBody.CustomerId;
+
+    if (!isArray(bids) || !playerId || !customerId) {
+      return [];
+    }
+
+    return bids.map(bidResponse => ({
+      requestId: bidResponse.RequestId,
+      cpm: bidResponse.Cpm,
+      ttl: bidResponse.Ttl || DEFAULT_MAX_TTL,
+      currency: 'USD',
+      mediaType: BANNER,
+      netRevenue: true,
+      width: bidResponse.Width,
+      height: bidResponse.Height,
+      creativeId: bidResponse.CreativeId,
+      referrer: bidResponse.Referrer,
+      ad: bidResponse.Ad,
+    }));
+  },
+
+  /*
+   * Determine the user sync type (either 'iframe' or 'image') based on syncOptions.
+   * Construct the sync URL by appending required query parameters such as gdpr, ccpa, and coppa consents.
+   * Return an array containing an object with the sync type and the constructed URL.
+   */
+  getUserSyncs: (syncOptions, serverResponses, gdprConsent, uspConsent, gppConsent) => {
+    if (!syncOptions.iframeEnabled) {
+      return [];
+    }
+
+    if (!serverResponses || !serverResponses.length) {
+      return [];
+    }
+
+    const params = {};
+
+    if (gdprConsent) {
+      if (typeof gdprConsent.gdprApplies === 'boolean') {
+        params['gdpr'] = Number(gdprConsent.gdprApplies);
+      } else {
+        params['gdpr'] = 0;
+      }
+
+      if (typeof gdprConsent.consentString === 'string') {
+        params['gdpr_consent'] = encodeURIComponent(gdprConsent.consentString);
+      }
+    }
+
+    if (typeof uspConsent === 'string') {
+      params['us_privacy'] = encodeURIComponent(uspConsent);
+    }
+
+    const syncUrl = serverResponses[0].body.UserSyncEndpoint;
+    const queryParams = Object.keys(params).length > 0 ? formatQS(params) : '';
+
+    const url = queryParams ? `${syncUrl}?${queryParams}` : syncUrl;
+    return [{
+      type: 'iframe',
+      url
+    }];
+  }
+};
+
+registerBidder(spec);