prebid.js 8.6.0 → 8.7.0

package/modules/adgenerationBidAdapter.js

@@ -28,7 +28,7 @@ export const spec = {
   buildRequests: function (validBidRequests, bidderRequest) {
     // convert Native ORTB definition to old-style prebid native definition
     validBidRequests = convertOrtbRequestToProprietaryNative(validBidRequests);
-    const ADGENE_PREBID_VERSION = '1.6.1';
+    const ADGENE_PREBID_VERSION = '1.6.2';
     let serverRequests = [];
     for (let i = 0, len = validBidRequests.length; i < len; i++) {
       const validReq = validBidRequests[i];
@@ -41,6 +41,7 @@ export const spec = {
       const imuid = deepAccess(validReq, 'userId.imuid');
       const gpid = deepAccess(validReq, 'ortb2Imp.ext.gpid');
       const sua = deepAccess(validReq, 'ortb2.device.sua');
+      const uid2 = deepAccess(validReq, 'userId.uid2.id');
       let data = ``;
       data = tryAppendQueryString(data, 'posall', 'SSPLOC');
       const id = getBidIdParameter('id', validReq.params);
@@ -58,8 +59,8 @@ export const spec = {
       data = tryAppendQueryString(data, 'adgext_id5_id', id5id);
       data = tryAppendQueryString(data, 'adgext_id5_id_link_type', id5LinkType);
       data = tryAppendQueryString(data, 'adgext_imuid', imuid);
-      data = tryAppendQueryString(data, 'adgext_uid2', validReq.userId ? validReq.userId.uid2 : null);
-      data = tryAppendQueryString(data, 'gpid', gpid || null);
+      data = tryAppendQueryString(data, 'adgext_uid2', uid2);
+      data = tryAppendQueryString(data, 'gpid', gpid);
       data = tryAppendQueryString(data, 'uach', sua ? JSON.stringify(sua) : null);
       data = tryAppendQueryString(data, 'schain', validReq.schain ? JSON.stringify(validReq.schain) : null);
 

package/modules/adsinteractiveBidAdapter.js

@@ -8,10 +8,12 @@ import { BANNER } from '../src/mediaTypes.js';
 const ADSINTERACTIVE_CODE = 'adsinteractive';
 const USER_SYNC_URL_IMAGE = 'https://sync.adsinteractive.com/img';
 const USER_SYNC_URL_IFRAME = 'https://sync.adsinteractive.com/sync';
+const GVLID = 1212;
 
 export const spec = {
   code: ADSINTERACTIVE_CODE,
   supportedMediaTypes: [BANNER],
+  gvlid: GVLID,
 
   isBidRequestValid: (bid) => {
     return (

package/modules/alkimiBidAdapter.js

@@ -1,5 +1,5 @@
 import {registerBidder} from '../src/adapters/bidderFactory.js';
-import {deepAccess, deepClone} from '../src/utils.js';
+import {deepAccess, deepClone, getDNT, generateUUID} from '../src/utils.js';
 import {ajax} from '../src/ajax.js';
 import {VIDEO} from '../src/mediaTypes.js';
 import {config} from '../src/config.js';
@@ -12,7 +12,7 @@ export const spec = {
   supportedMediaTypes: ['banner', 'video'],
 
   isBidRequestValid: function (bid) {
-    return !!(bid.params && bid.params.bidFloor && bid.params.token);
+    return !!(bid.params && bid.params.token);
   },
 
   buildRequests: function (validBidRequests, bidderRequest) {
@@ -28,12 +28,15 @@ export const spec = {
 
       bids.push({
         token: bidRequest.params.token,
-        pos: bidRequest.params.pos,
+        instl: bidRequest.params.instl,
+        exp: bidRequest.params.exp,
         bidFloor: getBidFloor(bidRequest, formatTypes),
         sizes: prepareSizes(deepAccess(bidRequest, 'mediaTypes.banner.sizes')),
         playerSizes: prepareSizes(deepAccess(bidRequest, 'mediaTypes.video.playerSize')),
         impMediaTypes: formatTypes,
-        adUnitCode: bidRequest.adUnitCode
+        adUnitCode: bidRequest.adUnitCode,
+        video: deepAccess(bidRequest, 'mediaTypes.video'),
+        banner: deepAccess(bidRequest, 'mediaTypes.banner')
       })
       bidIds.push(bidRequest.bidId)
     })
@@ -41,14 +44,23 @@ export const spec = {
     const alkimiConfig = config.getConfig('alkimi');
 
     let payload = {
-      // TODO: fix auctionId leak: https://github.com/prebid/Prebid.js/issues/9781
-      requestId: bidderRequest.auctionId,
+      requestId: generateUUID(),
       signRequest: {bids, randomUUID: alkimiConfig && alkimiConfig.randomUUID},
       bidIds,
       referer: bidderRequest.refererInfo.page,
       signature: alkimiConfig && alkimiConfig.signature,
       schain: validBidRequests[0].schain,
-      cpp: config.getConfig('coppa') ? 1 : 0
+      cpp: config.getConfig('coppa') ? 1 : 0,
+      device: {
+        dnt: getDNT() ? 1 : 0,
+        w: screen.width,
+        h: screen.height
+      },
+      ortb2: {
+        at: bidderRequest.ortb2?.at,
+        bcat: bidderRequest.ortb2?.bcat,
+        wseat: bidderRequest.ortb2?.wseat
+      }
     }
 
     if (bidderRequest && bidderRequest.gdprConsent) {

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

package/modules/connatixBidAdapter.md

@@ -0,0 +1,37 @@
+
+# Overview
+
+```
+Module Name: Connatix Bidder Adapter
+Module Type: Bidder Adapter
+Maintainer: prebid_integration@connatix.com
+```
+
+# Description
+Connects to Connatix demand source to fetch bids.  
+Please use ```connatix``` as the bidder code. 
+
+# Test Parameters
+```
+var adUnits = [
+	{
+		code: '1',
+		mediaTypes: {
+			banner: {
+				sizes: [[640, 480], [320, 180]],
+			},
+		},
+		bids: [
+			{
+				bidder: 'connatix',
+				params: {
+					placementId: 'e4984e88-9ff4-45a3-8b9d-33aabcad634e', // required
+					bidfloor: 2.5, // optional
+				},
+			},
+			// Add more bidders and their parameters as needed
+		],
+	},
+	// Define more ad units here if necessary
+];
+```

package/modules/criteoBidAdapter.js

@@ -315,14 +315,14 @@ export const spec = {
     const id = readFromAllStorages(BUNDLE_COOKIE_NAME);
     if (id) {
       deleteFromAllStorages(BUNDLE_COOKIE_NAME);
+      ajax('https://privacy.criteo.com/api/privacy/datadeletionrequest',
+        null,
+        JSON.stringify({ publisherUserId: id }),
+        {
+          contentType: 'application/json',
+          method: 'POST'
+        });
     }
-    ajax('https://privacy.criteo.com/api/privacy/datadeletionrequest',
-      null,
-      JSON.stringify({ publisherUserId: id }),
-      {
-        contentType: 'application/json',
-        method: 'POST'
-      });
   }
 };