prebid.js 8.0.0 → 8.2.0

package/modules/bridBidAdapter.js

@@ -0,0 +1,223 @@
+import {createTrackPixelHtml, _each, deepAccess, getDefinedParams, parseGPTSingleSizeArrayToRtbSize} from '../src/utils.js';
+import {VIDEO} from '../src/mediaTypes.js';
+import {registerBidder} from '../src/adapters/bidderFactory.js';
+import {getRefererInfo} from '../src/refererDetection.js';
+
+const SOURCE = 'pbjs';
+const BIDDER_CODE = 'brid';
+const ENDPOINT_URL = 'https://pbs.prebrid.tv/openrtb2/auction';
+const GVLID = 934;
+const TIME_TO_LIVE = 300;
+const VIDEO_PARAMS = [
+  'api', 'linearity', 'maxduration', 'mimes', 'minduration', 'placement',
+  'playbackmethod', 'protocols', 'startdelay'
+];
+
+export const spec = {
+
+  code: BIDDER_CODE,
+  gvlid: GVLID,
+  supportedMediaTypes: [VIDEO],
+
+  /**
+   * Determines whether or not the given bid request is valid.
+   *
+   * @param {object} bid The bid to validate.
+   * @return boolean True if this is a valid bid, and false otherwise.
+   */
+  isBidRequestValid: function(bid) {
+    return !!(bid && bid.params && bid.params.placementId);
+  },
+
+  /**
+   * Make a server request from the list of BidRequests.
+   *
+   * @param {BidRequest[]} bidRequests A non-empty list of bid requests which should be sent to the Server.
+   * @param {BidderRequest} bidderRequest bidder request object.
+   * @return ServerRequest Info describing the request to the server.
+   */
+  buildRequests: function(bidRequests, bidderRequest) {
+    const requests = [];
+
+    _each(bidRequests, function(bid) {
+      const placementId = bid.params.placementId;
+      const bidId = bid.bidId;
+      let sizes = bid.sizes;
+      if (sizes && !Array.isArray(sizes[0])) sizes = [sizes];
+
+      const site = getSiteObj();
+
+      const postBody = {
+        sdk: {
+          source: SOURCE,
+          version: '$prebid.version$'
+        },
+        id: bidderRequest.bidderRequestId,
+        site,
+        imp: []
+      };
+
+      const imp = {
+        ext: {
+          prebid: {
+            storedrequest: {'id': placementId}
+          }
+        }
+      };
+
+      const video = deepAccess(bid, 'mediaTypes.video');
+      if (video) {
+        imp.video = getDefinedParams(video, VIDEO_PARAMS);
+        if (video.playerSize) {
+          imp.video = Object.assign(
+            imp.video, parseGPTSingleSizeArrayToRtbSize(video.playerSize[0]) || {}
+          );
+        } else if (video.w && video.h) {
+          imp.video.w = video.w;
+          imp.video.h = video.h;
+        };
+      };
+
+      postBody.imp.push(imp);
+
+      const gdprConsent = bidderRequest && bidderRequest.gdprConsent;
+      const uspConsent = bidderRequest && bidderRequest.uspConsent;
+
+      if (gdprConsent || uspConsent) {
+        postBody.regs = { ext: {} };
+
+        if (uspConsent) {
+          postBody.regs.ext.us_privacy = uspConsent;
+        };
+
+        if (gdprConsent) {
+          if (typeof gdprConsent.gdprApplies !== 'undefined') {
+            postBody.regs.ext.gdpr = gdprConsent.gdprApplies ? 1 : 0;
+          };
+
+          if (typeof gdprConsent.consentString !== 'undefined') {
+            postBody.user = {
+              ext: { consent: gdprConsent.consentString }
+            };
+          };
+        };
+      };
+
+      if (bidRequests[0].schain) {
+        postBody.schain = bidRequests[0].schain;
+      }
+
+      const params = bid.params;
+
+      requests.push({
+        method: 'POST',
+        url: ENDPOINT_URL,
+        data: JSON.stringify(postBody),
+        options: {
+          withCredentials: true
+        },
+        bidId,
+        params
+      });
+    });
+
+    return requests;
+  },
+
+  /**
+   * Unpack the response from the server into a list of bids.
+   *
+   * @param {*} serverResponse A successful response from the server.
+   * @return {Bid[]} An array of bids which were nested inside the server.
+   */
+  interpretResponse: function(serverResponse, bidRequest) {
+    const response = serverResponse.body;
+    const bidResponses = [];
+
+    _each(response.seatbid, (resp) => {
+      _each(resp.bid, (bid) => {
+        const requestId = bidRequest.bidId;
+        const params = bidRequest.params;
+
+        const {ad, adUrl, vastUrl, vastXml} = getAd(bid);
+
+        const bidResponse = {
+          requestId,
+          params,
+          cpm: bid.price,
+          width: bid.w,
+          height: bid.h,
+          creativeId: bid.adid,
+          currency: response.cur,
+          netRevenue: false,
+          ttl: TIME_TO_LIVE,
+          meta: {
+            advertiserDomains: bid.adomain || []
+          }
+        };
+
+        if (vastUrl || vastXml) {
+          bidResponse.mediaType = VIDEO;
+          if (vastUrl) bidResponse.vastUrl = vastUrl;
+          if (vastXml) bidResponse.vastXml = vastXml;
+        } else {
+          bidResponse.ad = ad;
+          bidResponse.adUrl = adUrl;
+        };
+
+        bidResponses.push(bidResponse);
+      });
+    });
+
+    return bidResponses;
+  },
+
+}
+
+/**
+ * Helper function to get ad
+ *
+ * @param {object} bid The bid.
+ * @return {object} ad object.
+ */
+function getAd(bid) {
+  let ad, adUrl, vastXml, vastUrl;
+
+  switch (deepAccess(bid, 'ext.prebid.type')) {
+    case VIDEO:
+      if (bid.adm.substr(0, 4) === 'http') {
+        vastUrl = bid.adm;
+      } else {
+        vastXml = bid.adm;
+      };
+      break;
+    default:
+      if (bid.adm && bid.nurl) {
+        ad = bid.adm;
+        ad += createTrackPixelHtml(decodeURIComponent(bid.nurl));
+      } else if (bid.adm) {
+        ad = bid.adm;
+      } else if (bid.nurl) {
+        adUrl = bid.nurl;
+      };
+  }
+
+  return {ad, adUrl, vastXml, vastUrl};
+}
+
+/**
+ * Helper function to get site object
+ *
+ * @return {object} siteObj.
+ */
+function getSiteObj() {
+  const refInfo = (getRefererInfo && getRefererInfo()) || {};
+
+  return {
+    page: refInfo.page,
+    ref: refInfo.ref,
+    domain: refInfo.domain
+  };
+}
+
+registerBidder(spec);

package/modules/categoryTranslation.js

@@ -12,7 +12,7 @@
  */
 
 import {config} from '../src/config.js';
-import {hook, setupBeforeHookFnOnce} from '../src/hook.js';
+import {hook, setupBeforeHookFnOnce, ready} from '../src/hook.js';
 import {ajax} from '../src/ajax.js';
 import {logError, timestamp} from '../src/utils.js';
 import {addBidResponse} from '../src/auction.js';
@@ -32,7 +32,8 @@ export const registerAdserver = hook('async', function(adServer) {
     initTranslation(url, DEFAULT_IAB_TO_FW_MAPPING_KEY);
   }
 }, 'registerAdserver');
-registerAdserver();
+
+ready.then(() => registerAdserver());
 
 export const getAdserverCategoryHook = timedBidResponseHook('categoryTranslation', function getAdserverCategoryHook(fn, adUnitCode, bid, reject) {
   if (!bid) {

package/modules/colossussspBidAdapter.js

@@ -116,6 +116,15 @@ export const spec = {
         request.gdpr_consent = bidderRequest.gdprConsent.consentString || 'ALL';
         request.gdpr_require = bidderRequest.gdprConsent.gdprApplies ? 1 : 0;
       }
+
+      // Add GPP consent
+      if (bidderRequest.gppConsent) {
+        request.gpp = bidderRequest.gppConsent.gppString;
+        request.gpp_sid = bidderRequest.gppConsent.applicableSections;
+      } else if (bidderRequest.ortb2?.regs?.gpp) {
+        request.gpp = bidderRequest.ortb2.regs.gpp;
+        request.gpp_sid = bidderRequest.ortb2.regs.gpp_sid;
+      }
     }
 
     for (let i = 0; i < validBidRequests.length; i++) {

package/modules/conceptxBidAdapter.js

@@ -45,10 +45,13 @@ export const spec = {
   },
 
   interpretResponse: function (serverResponse, bidRequest) {
-    const bidResponsesFromServer = serverResponse.body.bidResponses;
-    const firstDummy = bidResponsesFromServer[0]
-    const firstSeat = firstDummy.ads[0]
     const bidResponses = [];
+    const bidResponsesFromServer = serverResponse.body.bidResponses;
+    if (Array.isArray(bidResponsesFromServer) && bidResponsesFromServer.length === 0) {
+      return bidResponses
+    }
+    const firstBid = bidResponsesFromServer[0]
+    const firstSeat = firstBid.ads[0]
     const bidResponse = {
       requestId: firstSeat.requestId,
       cpm: firstSeat.cpm,

package/modules/consentManagement.js

@@ -12,6 +12,7 @@ import {timedAuctionHook} from '../src/utils/perfMetrics.js';
 import {registerOrtbProcessor, REQUEST} from '../src/pbjsORTB.js';
 import {enrichFPD} from '../src/fpd/enrichment.js';
 import {getGlobal} from '../src/prebidGlobal.js';
+import {cmpClient} from '../libraries/cmp/cmpClient.js';
 
 const DEFAULT_CMP = 'iab';
 const DEFAULT_CONSENT_TIMEOUT = 10000;
@@ -48,36 +49,6 @@ function lookupStaticConsentData({onSuccess, onError}) {
  * @param {function(string, ...{}?)} cmpError acts as an error callback while interacting with CMP; pass along an error message (string) and any extra error arguments (purely for logging)
  */
 function lookupIabConsent({onSuccess, onError, onEvent}) {
-  function findCMP() {
-    let f = window;
-    let cmpFrame;
-    let cmpFunction;
-    while (true) {
-      try {
-        if (typeof f.__tcfapi === 'function') {
-          cmpFunction = f.__tcfapi;
-          cmpFrame = f;
-          break;
-        }
-      } catch (e) { }
-
-      // need separate try/catch blocks due to the exception errors thrown when trying to check for a frame that doesn't exist in 3rd party env
-      try {
-        if (f.frames['__tcfapiLocator']) {
-          cmpFrame = f;
-          break;
-        }
-      } catch (e) { }
-
-      if (f === window.top) break;
-      f = f.parent;
-    }
-    return {
-      cmpFrame,
-      cmpFunction
-    };
-  }
-
   function cmpResponseCallback(tcfData, success) {
     logInfo('Received a response from CMP', tcfData);
     if (success) {
@@ -90,70 +61,25 @@ function lookupIabConsent({onSuccess, onError, onEvent}) {
     }
   }
 
-  const cmpCallbacks = {};
-  const { cmpFrame, cmpFunction } = findCMP();
+  const cmp = cmpClient({
+    apiName: '__tcfapi',
+    apiVersion: CMP_VERSION,
+    apiArgs: ['command', 'version', 'callback', 'parameter'],
+  });
 
-  if (!cmpFrame) {
+  if (!cmp) {
     return onError('TCF2 CMP not found.');
   }
-  // to collect the consent information from the user, we perform two calls to the CMP in parallel:
-  // first to collect the user's consent choices represented in an encoded string (via getConsentData)
-  // second to collect the user's full unparsed consent information (via getVendorConsents)
-
-  // the following code also determines where the CMP is located and uses the proper workflow to communicate with it:
-  // check to see if CMP is found on the same window level as prebid and call it directly if so
-  // check to see if prebid is in a safeframe (with CMP support)
-  // else assume prebid may be inside an iframe and use the IAB CMP locator code to see if CMP's located in a higher parent window. this works in cross domain iframes
-  // if the CMP is not found, the iframe function will call the cmpError exit callback to abort the rest of the CMP workflow
-
-  if (typeof cmpFunction === 'function') {
+  if (cmp.isDirect) {
     logInfo('Detected CMP API is directly accessible, calling it now...');
-    cmpFunction('addEventListener', CMP_VERSION, cmpResponseCallback);
   } else {
     logInfo('Detected CMP is outside the current iframe where Prebid.js is located, calling it now...');
-    callCmpWhileInIframe('addEventListener', cmpFrame, cmpResponseCallback);
   }
 
-  function callCmpWhileInIframe(commandName, cmpFrame, moduleCallback) {
-    const apiName = '__tcfapi';
-
-    const callName = `${apiName}Call`;
-
-    /* Setup up a __cmp function to do the postMessage and stash the callback.
-    This function behaves (from the caller's perspective identicially to the in-frame __cmp call */
-    window[apiName] = function (cmd, cmpVersion, callback, arg) {
-      const callId = Math.random() + '';
-      const msg = {
-        [callName]: {
-          command: cmd,
-          version: cmpVersion,
-          parameter: arg,
-          callId: callId
-        }
-      };
-
-      cmpCallbacks[callId] = callback;
-      cmpFrame.postMessage(msg, '*');
-    }
-
-    /** when we get the return message, call the stashed callback */
-    window.addEventListener('message', readPostMessageResponse, false);
-
-    // call CMP
-    window[apiName](commandName, CMP_VERSION, moduleCallback);
-
-    function readPostMessageResponse(event) {
-      const cmpDataPkgName = `${apiName}Return`;
-      const json = (typeof event.data === 'string' && includes(event.data, cmpDataPkgName)) ? JSON.parse(event.data) : event.data;
-      if (json[cmpDataPkgName] && json[cmpDataPkgName].callId) {
-        const payload = json[cmpDataPkgName];
-        // TODO - clean up this logic (move listeners?); we have duplicate messages responses because 2 eventlisteners are active from the 2 cmp requests running in parallel
-        if (cmpCallbacks.hasOwnProperty(payload.callId)) {
-          cmpCallbacks[payload.callId](payload.returnValue, payload.success);
-        }
-      }
-    }
-  }
+  cmp({
+    command: 'addEventListener',
+    callback: cmpResponseCallback
+  })
 }
 
 /**

package/modules/consentManagementGpp.js

@@ -7,10 +7,12 @@
 import {deepSetValue, isNumber, isPlainObject, isStr, logError, logInfo, logWarn} from '../src/utils.js';
 import {config} from '../src/config.js';
 import {gppDataHandler} from '../src/adapterManager.js';
-import {includes} from '../src/polyfill.js';
 import {timedAuctionHook} from '../src/utils/perfMetrics.js';
 import { enrichFPD } from '../src/fpd/enrichment.js';
 import {getGlobal} from '../src/prebidGlobal.js';
+import {cmpClient} from '../libraries/cmp/cmpClient.js';
+import {GreedyPromise} from '../src/utils/promise.js';
+import {buildActivityParams} from '../src/activities/params.js';
 
 const DEFAULT_CMP = 'iab';
 const DEFAULT_CONSENT_TIMEOUT = 10000;
@@ -18,7 +20,7 @@ const CMP_VERSION = 1;
 
 export let userCMP;
 export let consentTimeout;
-export let staticConsentData;
+let staticConsentData;
 
 let consentData;
 let addedConsentHook = false;
@@ -29,28 +31,16 @@ const cmpCallMap = {
   'static': lookupStaticConsentData
 };
 
-/**
- * This function checks the state of the IAB gppData's applicableSection field (to ensure it's populated and has a valid value).
- * section === 0 represents a CMP's default value when CMP is loading, it shoud not be used a real user's section.
- *
- * TODO --- The initial version of the GPP CMP API spec used this naming convention, but it was later changed as an update to the spec.
- * CMPs should adjust their logic to use the new format (applicableSecctions), but that may not be the case with the initial release.
- * Added support just in case for this transition period, can likely be removed at a later date...
- * @param gppData represents the IAB gppData object
- * @returns true|false
- */
-function checkApplicableSectionIsReady(gppData) {
-  return gppData && Array.isArray(gppData.applicableSection) && gppData.applicableSection.length > 0 && gppData.applicableSection[0] !== 0;
-}
-
 /**
  * This function checks the state of the IAB gppData's applicableSections field (to ensure it's populated and has a valid value).
  * section === 0 represents a CMP's default value when CMP is loading, it shoud not be used a real user's section.
  * @param gppData represents the IAB gppData object
- * @returns true|false
+ * @returns {Array}
  */
-function checkApplicableSectionsIsReady(gppData) {
-  return gppData && Array.isArray(gppData.applicableSections) && gppData.applicableSections.length > 0 && gppData.applicableSections[0] !== 0;
+function applicableSections(gppData) {
+  return gppData && Array.isArray(gppData.applicableSections) && gppData.applicableSections.length > 0 && gppData.applicableSections[0] !== 0
+    ? gppData.applicableSections
+    : [];
 }
 
 /**
@@ -68,107 +58,36 @@ function lookupStaticConsentData({onSuccess, onError}) {
  * @param {function({})} onSuccess acts as a success callback when CMP returns a value; pass along consentObjectfrom CMP
  * @param {function(string, ...{}?)} cmpError acts as an error callback while interacting with CMP; pass along an error message (string) and any extra error arguments (purely for logging)
  */
-function lookupIabConsent({onSuccess, onError}) {
-  const cmpApiName = '__gpp';
-  const cmpCallbacks = {};
-  let registeredPostMessageResponseListener = false;
-
-  function findCMP() {
-    let f = window;
-    let cmpFrame;
-    let cmpDirectAccess = false;
-    while (true) {
-      try {
-        if (typeof f[cmpApiName] === 'function') {
-          cmpFrame = f;
-          cmpDirectAccess = true;
-          break;
-        }
-      } catch (e) {}
-
-      // need separate try/catch blocks due to the exception errors thrown when trying to check for a frame that doesn't exist in 3rd party env
-      try {
-        if (f.frames['__gppLocator']) {
-          cmpFrame = f;
-          break;
-        }
-      } catch (e) {}
-
-      if (f === window.top) break;
-      f = f.parent;
-    }
-
-    return {
-      cmpFrame,
-      cmpDirectAccess
-    };
-  }
-
-  const {cmpFrame, cmpDirectAccess} = findCMP();
-
-  if (!cmpFrame) {
+export function lookupIabConsent({onSuccess, onError}, mkClient = cmpClient) {
+  const cmp = mkClient({
+    apiName: '__gpp',
+    apiVersion: CMP_VERSION,
+  });
+  if (!cmp) {
     return onError('GPP CMP not found.');
   }
 
-  const invokeCMP = (cmpDirectAccess) ? invokeCMPDirect : invokeCMPFrame;
-
-  function invokeCMPDirect({command, callback, parameter, version = CMP_VERSION}, resultCb) {
-    if (typeof resultCb === 'function') {
-      resultCb(cmpFrame[cmpApiName](command, callback, parameter, version));
-    } else {
-      cmpFrame[cmpApiName](command, callback, parameter, version);
-    }
-  }
-
-  function invokeCMPFrame({command, callback, parameter, version = CMP_VERSION}, resultCb) {
-    const callName = `${cmpApiName}Call`;
-    if (!registeredPostMessageResponseListener) {
-      // when we get the return message, call the stashed callback;
-      window.addEventListener('message', readPostMessageResponse, false);
-      registeredPostMessageResponseListener = true;
-    }
-
-    // call CMP via postMessage
-    const callId = Math.random().toString();
-    const msg = {
-      [callName]: {
-        command: command,
-        parameter,
-        version,
-        callId: callId
-      }
-    };
-
-    // TODO? - add logic to check if random was already used in the same session, and roll another if so?
-    cmpCallbacks[callId] = (typeof callback === 'function') ? callback : resultCb;
-    cmpFrame.postMessage(msg, '*');
-
-    function readPostMessageResponse(event) {
-      const cmpDataPkgName = `${cmpApiName}Return`;
-      const json = (typeof event.data === 'string' && event.data.includes(cmpDataPkgName)) ? JSON.parse(event.data) : event.data;
-      if (json[cmpDataPkgName] && json[cmpDataPkgName].callId) {
-        const payload = json[cmpDataPkgName];
-
-        if (cmpCallbacks.hasOwnProperty(payload.callId)) {
-          cmpCallbacks[payload.callId](payload.returnValue);
-        }
-      }
-    }
-  }
-
-  const startupMsg = (cmpDirectAccess) ? 'Detected GPP CMP API is directly accessible, calling it now...'
+  const startupMsg = (cmp.isDirect) ? 'Detected GPP CMP API is directly accessible, calling it now...'
     : 'Detected GPP CMP is outside the current iframe where Prebid.js is located, calling it now...';
   logInfo(startupMsg);
 
-  invokeCMP({
+  cmp({
     command: 'addEventListener',
     callback: function (evt) {
       if (evt) {
-        logInfo(`Received a ${(cmpDirectAccess ? 'direct' : 'postmsg')} response from GPP CMP for event`, evt);
+        logInfo(`Received a ${(cmp.isDirect ? 'direct' : 'postmsg')} response from GPP CMP for event`, evt);
         if (evt.eventName === 'sectionChange' || evt.pingData.cmpStatus === 'loaded') {
-          invokeCMP({command: 'getGPPData'}, function (gppData) {
-            logInfo(`Received a ${cmpDirectAccess ? 'direct' : 'postmsg'} response from GPP CMP for getGPPData`, gppData);
-            processCmpData(gppData, {onSuccess, onError});
+          cmp({command: 'getGPPData'}).then((gppData) => {
+            logInfo(`Received a ${cmp.isDirect ? 'direct' : 'postmsg'} response from GPP CMP for getGPPData`, gppData);
+            return GreedyPromise.all(
+              (gppData?.pingData?.supportedAPIs || [])
+                .map((name) => cmp({command: 'getSection', parameter: name})
+                  .catch(() => { logError(`Could not retrieve section data for GPP section '${name}'`) })
+                  .then((res) => [name, res]))
+            ).then((sections) => {
+              const sectionData = Object.fromEntries(sections.filter(([_, val]) => val != null));
+              processCmpData({gppData, sectionData}, {onSuccess, onError});
+            })
           });
         } else if (evt.pingData.cmpStatus === 'error') {
           onError('CMP returned with a cmpStatus:error response.  Please check CMP setup.');
@@ -199,7 +118,7 @@ function loadConsentData(cb) {
     }
   }
 
-  if (!includes(Object.keys(cmpCallMap), userCMP)) {
+  if (!cmpCallMap.hasOwnProperty(userCMP)) {
     done(null, false, `GPP CMP framework (${userCMP}) is not a supported framework.  Aborting consentManagement module and resuming auction.`);
     return;
   }
@@ -219,7 +138,7 @@ function loadConsentData(cb) {
       }
       processCmpData(consentData, {
         onSuccess: continueToAuction,
-        onError: () => continueToAuction(storeConsentData(undefined))
+        onError: () => continueToAuction(storeConsentData())
       })
     }
     if (consentTimeout === 0) {
@@ -281,11 +200,10 @@ export const requestBidsHook = timedAuctionHook('gpp', function requestBidsHook(
  * If it's bad, we call `onError`
  * If it's good, then we store the value and call `onSuccess`
  */
-function processCmpData(consentObject, {onSuccess, onError}) {
+function processCmpData(consentData, {onSuccess, onError}) {
   function checkData() {
-    const gppString = consentObject && consentObject.gppString;
-    const gppSection = (checkApplicableSectionsIsReady(consentObject)) ? consentObject.applicableSections
-      : (checkApplicableSectionIsReady(consentObject)) ? consentObject.applicableSection : [];
+    const gppString = consentData?.gppData?.gppString;
+    const gppSection = consentData?.gppData?.applicableSections;
 
     return !!(
       (!Array.isArray(gppSection)) ||
@@ -294,25 +212,25 @@ function processCmpData(consentObject, {onSuccess, onError}) {
   }
 
   if (checkData()) {
-    onError(`CMP returned unexpected value during lookup process.`, consentObject);
+    onError(`CMP returned unexpected value during lookup process.`, consentData);
   } else {
-    onSuccess(storeConsentData(consentObject));
+    onSuccess(storeConsentData(consentData));
   }
 }
 
 /**
  * Stores CMP data locally in module to make information available in adaptermanager.js for later in the auction
- * @param {object} cmpConsentObject required; an object representing user's consent choices (can be undefined in certain use-cases for this function only)
+ * @param {{}} gppData the result of calling a CMP's `getGPPData` (or equivalent)
+ * @param {{}} sectionData map from GPP section name to the result of calling a CMP's `getSection` (or equivalent)
  */
-function storeConsentData(cmpConsentObject) {
+export function storeConsentData({gppData, sectionData} = {}) {
   consentData = {
-    gppString: (cmpConsentObject) ? cmpConsentObject.gppString : undefined,
-
-    fullGppData: (cmpConsentObject) || undefined,
+    gppString: (gppData) ? gppData.gppString : undefined,
+    gppData: (gppData) || undefined,
   };
-  consentData.applicableSections = (checkApplicableSectionsIsReady(cmpConsentObject)) ? cmpConsentObject.applicableSections
-    : (checkApplicableSectionIsReady(cmpConsentObject)) ? cmpConsentObject.applicableSection : [];
+  consentData.applicableSections = applicableSections(gppData);
   consentData.apiVersion = CMP_VERSION;
+  consentData.sectionData = sectionData;
   return consentData;
 }
 
@@ -353,7 +271,7 @@ export function setConsentConfig(config) {
 
   if (userCMP === 'static') {
     if (isPlainObject(config.consentData)) {
-      staticConsentData = config.consentData;
+      staticConsentData = {gppData: config.consentData, sectionData: config.sectionData};
       consentTimeout = 0;
     } else {
       logError(`consentManagement.gpp config with cmpApi: 'static' did not specify consentData. No consents will be available to adapters.`);
@@ -364,6 +282,9 @@ export function setConsentConfig(config) {
 
   if (!addedConsentHook) {
     getGlobal().requestBids.before(requestBidsHook, 50);
+    buildActivityParams.before((next, params) => {
+      return next(Object.assign({gppConsent: gppDataHandler.getConsentData()}, params));
+    });
   }
   addedConsentHook = true;
   gppDataHandler.enable();