prebid.js 7.52.0 → 7.54.0

package/modules/eskimiBidAdapter.md

@@ -6,29 +6,48 @@ Maintainer: tech@eskimi.com
 
 # Description
 
-An adapter to get a bid from Eskimi DSP.
+Module that connects to Eskimi demand sources to fetch bids using OpenRTB standard.
+Banner and video formats are supported.
 
 # Test Parameters
 ```javascript
     var adUnits = [{
-       code: 'div-gpt-ad-1460505748561-0',
-       mediaTypes: {
-           banner: {
-               sizes: [[300, 250], [300, 600]]
-           }
-       },
-       
-       bids: [{
-           bidder: 'eskimi',
-           params: {
-               placementId: 612
-           }
-       }]
-
-   }];
+        code: '/19968336/prebid_banner_example_1',
+        mediaTypes: {
+            banner: {
+                sizes: [[ 300, 250 ]],
+                ... // battr
+            }
+        },
+        bids: [{
+            bidder: 'eskimi',
+            params: {
+                placementId: 612,
+                ... // bcat, badv, bapp
+            }
+        }]
+    }, {
+        code: '/19968336/prebid_video_example_1',
+        mediaTypes: {
+            video: {
+                context: 'outstream',
+                mimes: ['video/mp4'],
+                api: [1, 2, 4, 6],
+                ... // Aditional ORTB video params (including battr)
+            }
+        },
+        bids: [{
+            bidder: 'eskimi',
+            params: {
+                placementId: 612,
+                ... // bcat, badv, bapp
+            }
+        }]
+    }];
 ```
 
 Where:
 
 * placementId - Placement ID of the ad unit (required)
+* bcat, badv, bapp, battr - ORTB blocking parameters as specified by OpenRTB 2.5
 

package/modules/euidIdSystem.js

@@ -0,0 +1,121 @@
+/**
+ * This module adds EUID ID support to the User ID module. It shares significant functionality with the UID2 module.
+ * The {@link module:modules/userId} module is required.
+ * @module modules/euidIdSystem
+ * @requires module:modules/userId
+ */
+
+import { logInfo, logWarn, deepAccess } from '../src/utils.js';
+import {submodule} from '../src/hook.js';
+import {getStorageManager} from '../src/storageManager.js';
+import {MODULE_TYPE_UID} from '../src/activities/modules.js';
+
+// RE below lint exception: UID2 and EUID are separate modules, but the protocol is the same and shared code makes sense here.
+// eslint-disable-next-line prebid/validate-imports
+import { Uid2GetId, Uid2CodeVersion } from './uid2IdSystem_shared.js';
+
+const MODULE_NAME = 'euid';
+const MODULE_REVISION = Uid2CodeVersion;
+const PREBID_VERSION = '$prebid.version$';
+const EUID_CLIENT_ID = `PrebidJS-${PREBID_VERSION}-EUIDModule-${MODULE_REVISION}`;
+const GVLID_TTD = 21; // The Trade Desk
+const LOG_PRE_FIX = 'EUID: ';
+const ADVERTISING_COOKIE = '__euid_advertising_token';
+
+// eslint-disable-next-line no-unused-vars
+const EUID_TEST_URL = 'https://integ.euid.eu';
+const EUID_PROD_URL = 'https://prod.euid.eu';
+const EUID_BASE_URL = EUID_PROD_URL;
+
+function createLogger(logger, prefix) {
+  return function (...strings) {
+    logger(prefix + ' ', ...strings);
+  }
+}
+const _logInfo = createLogger(logInfo, LOG_PRE_FIX);
+const _logWarn = createLogger(logWarn, LOG_PRE_FIX);
+
+export const storage = getStorageManager({moduleType: MODULE_TYPE_UID, moduleName: MODULE_NAME});
+
+function hasWriteToDeviceConsent(consentData) {
+  const gdprApplies = consentData?.gdprApplies === true;
+  const localStorageConsent = deepAccess(consentData, `vendorData.purpose.consents.1`)
+  const prebidVendorConsent = deepAccess(consentData, `vendorData.vendor.consents.${GVLID_TTD.toString()}`)
+  if (gdprApplies && (!localStorageConsent || !prebidVendorConsent)) {
+    return false;
+  }
+  return true;
+}
+
+/** @type {Submodule} */
+export const euidIdSubmodule = {
+  /**
+   * used to link submodule with config
+   * @type {string}
+   */
+  name: MODULE_NAME,
+
+  /**
+   * Vendor id of The Trade Desk
+   * @type {Number}
+   */
+  gvlid: GVLID_TTD,
+  /**
+   * decode the stored id value for passing to bid requests
+   * @function
+   * @param {string} value
+   * @returns {{euid:{ id: string } }} or undefined if value doesn't exists
+   */
+  decode(value) {
+    const result = decodeImpl(value);
+    _logInfo('EUID decode returned', result);
+    return result;
+  },
+
+  /**
+   * performs action to obtain id and return a value.
+   * @function
+   * @param {SubmoduleConfig} [configparams]
+   * @param {ConsentData|undefined} consentData
+   * @returns {euidId}
+   */
+  getId(config, consentData) {
+    if (consentData?.gdprApplies !== true) {
+      logWarn('EUID is intended for use within the EU. The module will not run when GDPR does not apply.');
+      return;
+    }
+    if (!hasWriteToDeviceConsent(consentData)) {
+      // The module cannot operate without this permission.
+      _logWarn(`Unable to use EUID module due to insufficient consent. The EUID module requires storage permission.`)
+      return;
+    }
+
+    const mappedConfig = {
+      apiBaseUrl: config?.params?.euidApiBase ?? EUID_BASE_URL,
+      paramToken: config?.params?.euidToken,
+      serverCookieName: config?.params?.euidCookie,
+      storage: config?.params?.storage ?? 'localStorage',
+      clientId: EUID_CLIENT_ID,
+      internalStorage: ADVERTISING_COOKIE
+    };
+
+    const result = Uid2GetId(mappedConfig, storage, _logInfo, _logWarn);
+    _logInfo(`EUID getId returned`, result);
+    return result;
+  },
+};
+
+function decodeImpl(value) {
+  if (typeof value === 'string') {
+    _logInfo('Found server-only token. Refresh is unavailable for this token.');
+    const result = { euid: { id: value } };
+    return result;
+  }
+  if (Date.now() < value.latestToken.identity_expires) {
+    return { euid: { id: value.latestToken.advertising_token } };
+  }
+  return null;
+}
+
+// Register submodule for userId
+submodule('userId', euidIdSubmodule);

package/modules/euidIdSystem.md

@@ -0,0 +1,131 @@
+## EUID User ID Submodule
+
+EUID requires initial tokens to be generated server-side. The EUID module handles storing, providing, and optionally refreshing them. The module can operate in one of two different modes: *Client Refresh* mode or *Server Only* mode.
+
+*Server Only* mode was originally referred to as *legacy mode*, but it is a popular mode for new integrations where publishers prefer to handle token refresh server-side.
+
+## Client Refresh mode
+
+This is the recommended mode for most scenarios. In this mode, the full response body from the EUID Token Generate or Token Refresh endpoint must be provided to the module. As long as the refresh token remains valid, the module will refresh the advertising token as needed.
+
+To configure the module to use this mode, you must **either**:
+1. Set `params.euidCookie` to the name of the cookie which contains the response body as a JSON string, **or**
+2. Set `params.euidToken` to the response body as a JavaScript object.
+
+### Client refresh cookie example
+
+In this example, the cookie is called `euid_pub_cookie`.
+
+Cookie:
+```
+euid_pub_cookie={"advertising_token":"...advertising token...","refresh_token":"...refresh token...","identity_expires":1684741472161,"refresh_from":1684741425653,"refresh_expires":1684784643668,"refresh_response_key":"...response key..."}
+```
+
+Configuration:
+```
+pbjs.setConfig({
+    userSync: {
+        userIds: [{
+            name: 'euid',
+            params: {
+                euidCookie: 'euid_pub_cookie'
+            }
+        }]
+    }
+});
+```
+
+### Client refresh euidToken example
+
+Configuration:
+```
+pbjs.setConfig({
+    userSync: {
+        userIds: [{
+            name: 'euid',
+            params: {
+                euidToken: {
+                    'advertising_token': '...advertising token...',
+                    'refresh_token': '...refresh token...',
+                    // etc. - see the Sample Token below for contents of this object
+                }
+            }
+        }]
+    }
+});
+```
+
+## Server-Only Mode
+
+In this mode, only the advertising token is provided to the module. The module will not be able to refresh the token. The publisher is responsible for implementing some other way to refresh the token.
+
+To configure the module to use this mode, you must **either**:
+1. Set a cookie named `__euid_advertising_token` to the advertising token, **or**
+2. Set `value` to an ID block containing the advertising token.
+
+### Server only cookie example
+
+Cookie:
+```
+__euid_advertising_token=...advertising token...
+```
+
+Configuration:
+```
+pbjs.setConfig({
+    userSync: {
+        userIds: [{
+            name: 'euid'
+        }]
+    }
+});
+```
+
+### Server only value example
+
+Configuration:
+```
+pbjs.setConfig({
+    userSync: {
+        userIds: [{
+            name: 'euid'
+            value: {
+                'euid': {
+                    'id': '...advertising token...'
+                }
+            }
+        }]
+    }
+});
+```
+
+## Storage
+
+The module stores a number of internal values. By default, all values are stored in HTML5 local storage. You can switch to cookie storage by setting `params.storage` to `cookie`. The cookie size can be significant and this is not recommended, but is provided as an option if local storage is not an option.
+
+## Sample token
+
+`{`<br />&nbsp;&nbsp;`"advertising_token": "...",`<br />&nbsp;&nbsp;`"refresh_token": "...",`<br />&nbsp;&nbsp;`"identity_expires": 1633643601000,`<br />&nbsp;&nbsp;`"refresh_from": 1633643001000,`<br />&nbsp;&nbsp;`"refresh_expires": 1636322000000,`<br />&nbsp;&nbsp;`"refresh_response_key": "wR5t6HKMfJ2r4J7fEGX9Gw=="`<br />`}`
+
+### Notes
+
+If you are trying to limit the size of cookies, provide the token in configuration and use the default option of local storage.
+
+If you provide an expired identity and the module has a valid identity which was refreshed from the identity you provide, it will use the refreshed identity. The module stores the original token used for refreshing the token, and it will use the refreshed tokens as long as the original token matches the one supplied.
+
+If a new token is supplied which does not match the original token used to generate any refreshed tokens, all stored tokens will be discarded and the new token used instead (refreshed if necessary).
+
+You can set `params.euidApiBase` to `"https://integ.euid.eu"` during integration testing. Be aware that you must use the same environment (production or integration) here as you use for generating tokens.
+
+## Parameter Descriptions for the `usersync` Configuration Section
+
+The below parameters apply only to the EUID User ID Module integration.
+
+| Param under userSync.userIds[] | Scope | Type | Description | Example |
+| --- | --- | --- | --- | --- |
+| name | Required | String | ID value for the EUID module - `"euid"` | `"euid"` |
+| value | Optional, Server only | Object | An object containing the value for the advertising token. | See the example above. |
+| params.euidToken | Optional, Client refresh | Object | The initial EUID token. This should be `body` element of the decrypted response from a call to the `/token/generate` or `/token/refresh` endpoint. | See the sample token above. |
+| params.euidCookie | Optional, Client refresh | String | The name of a cookie which holds the initial EUID token, set by the server. The cookie should contain JSON in the same format as the euidToken param. **If euidToken is supplied, this param is ignored.** | See the sample token above. |
+| params.euidApiBase | Optional, Client refresh | String | Overrides the default EUID API endpoint. | `"https://prod.euid.eu"` _(default)_|
+| params.storage | Optional, Client refresh | String | Specify whether to use `cookie` or `localStorage` for module-internal storage. It is recommended to not provide this and allow the module to use the default. | `localStorage` _(default)_ |

package/modules/freepassIdSystem.js

@@ -0,0 +1,61 @@
+import { submodule } from '../src/hook.js';
+import {generateUUID, logMessage} from '../src/utils.js';
+
+const MODULE_NAME = 'freepassId';
+
+export const freepassIdSubmodule = {
+  name: MODULE_NAME,
+  decode: function (value, config) {
+    logMessage('Decoding FreePass ID: ', value);
+
+    return { [MODULE_NAME]: value };
+  },
+
+  getId: function (config, consent, cachedIdObject) {
+    logMessage('Getting FreePass ID using config: ' + JSON.stringify(config));
+
+    const freepassData = config.params !== undefined ? (config.params.freepassData || {}) : {}
+    let idObject = {userId: generateUUID()};
+
+    if (freepassData.commonId !== undefined) {
+      idObject.commonId = config.params.freepassData.commonId;
+    }
+
+    if (freepassData.userIp !== undefined) {
+      idObject.userIp = config.params.freepassData.userIp;
+    }
+
+    return {id: idObject};
+  },
+
+  extendId: function (config, consent, cachedIdObject) {
+    let freepassData = config.params.freepassData;
+    let hasFreepassData = freepassData !== undefined;
+    if (!hasFreepassData) {
+      logMessage('No Freepass Data. CachedIdObject will not be extended: ' + JSON.stringify(cachedIdObject));
+      return {
+        id: cachedIdObject
+      };
+    }
+
+    if (freepassData.commonId === cachedIdObject.commonId && freepassData.userIp === cachedIdObject.userIp) {
+      logMessage('FreePass ID is already up-to-date: ' + JSON.stringify(cachedIdObject));
+      return {
+        id: cachedIdObject
+      };
+    }
+
+    logMessage('Extending FreePass ID object: ' + JSON.stringify(cachedIdObject));
+    logMessage('Extending FreePass ID using config: ' + JSON.stringify(config));
+
+    return {
+      id: {
+        commonId: freepassData.commonId,
+        userIp: freepassData.userIp,
+        userId: cachedIdObject.userId,
+      },
+    };
+  }
+};
+
+submodule('userId', freepassIdSubmodule);

package/modules/freepassIdSystem.md

@@ -0,0 +1,47 @@
+## FreePass User ID Submodule
+
+[FreePass](https://freepass-login.com/introduction.html) is a common authentication service operated by Freebit Co., Ltd. Users with a FreePass account do not need to create a new account to use partner services. 
+
+# General Information
+
+Please contact FreePass before using this ID.
+
+```
+Module Name: FreePass Id System
+Module Type: User Id System
+Maintainer: freepass-headerbidding@craid-inc.com
+```
+
+## Building Prebid with FreePass ID Support
+
+First, make sure to add the FreePass ID submodule to your Prebid.js package with:
+
+```shell
+gulp build --modules=freepassIdSystem,userId
+```
+
+The following configuration parameters are available:
+
+```javascript
+pbjs.setConfig({
+    userSync: {
+        userIds: [{
+            name: 'freepassId',
+            params: {
+                freepassData: {
+                    commonId: 'fpcommonid123',
+                    userIp: '127.0.0.1'
+                }
+            }
+        }]
+    }
+});
+```
+
+| Param under userSync.userIds[] | Scope    | Type   | Description                                          | Example        |
+|--------------------------------|----------|--------|------------------------------------------------------|----------------|
+| name                           | Required | String | The name of this module                              | `"freepassId"` |
+| freepassData                   | Optional | Object | FreePass data                                        | `{}`           |
+| freepassData.commonId          | Optional | String | Common ID obtained from FreePass                     | `"abcd1234"`   |
+| freepassData.userIp            | Optional | String | User IP obtained in cooperation with partner service | `"127.0.0.1"`  |
+

package/modules/greenbidsAnalyticsAdapter.js

@@ -8,7 +8,7 @@ const analyticsType = 'endpoint';
 
 export const ANALYTICS_VERSION = '1.0.0';
 
-const ANALYTICS_SERVER = 'https://europe-west2-greenbids-357713.cloudfunctions.net/publisher-analytics-endpoint';
+const ANALYTICS_SERVER = 'https://a.greenbids.ai';
 
 const {
   EVENTS: {

package/modules/hypelabBidAdapter.js

@@ -0,0 +1,153 @@
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { BANNER } from '../src/mediaTypes.js';
+import { generateUUID } from '../src/utils.js';
+import { ajax } from '../src/ajax.js';
+
+export const BIDDER_CODE = 'hypelab';
+export const ENDPOINT_URL = 'https://api.hypelab.com';
+
+export const REQUEST_ROUTE = '/v1/prebid_requests';
+export const EVENT_ROUTE = '/v1/events';
+export const REPORTING_ROUTE = '';
+
+const PREBID_VERSION = '$prebid.version$';
+const PROVIDER_NAME = 'prebid';
+const PROVIDER_VERSION = '0.0.1';
+
+const url = (route) => ENDPOINT_URL + route;
+
+export function mediaSize(data) {
+  if (!data || !data.creative_set) return { width: 0, height: 0 };
+  const media = data.creative_set.video || data.creative_set.image || {};
+  return { width: media.width, height: media.height };
+}
+
+function isBidRequestValid(bidderRequest) {
+  return (
+    !!bidderRequest.params?.property_slug &&
+    !!bidderRequest.params?.placement_slug
+  );
+}
+
+function buildRequests(validBidRequests, bidderRequest) {
+  const result = validBidRequests.map((request) => {
+    const uids = (request.userIdAsEids || []).reduce((a, c) => {
+      const ids = c.uids.map((uid) => uid.id);
+      return [...a, ...ids];
+    }, []);
+
+    const uuid = uids[0] ? uids[0] : generateTemporaryUUID();
+
+    const payload = {
+      property_slug: request.params.property_slug,
+      placement_slug: request.params.placement_slug,
+      provider_version: PROVIDER_VERSION,
+      provider_name: PROVIDER_NAME,
+      referrer:
+        bidderRequest.refererInfo?.page || typeof window != 'undefined'
+          ? window.location.href
+          : '',
+      sdk_version: PREBID_VERSION,
+      sizes: request.sizes,
+      wids: [],
+      uuid,
+      bidRequestsCount: request.bidRequestsCount,
+      bidderRequestsCount: request.bidderRequestsCount,
+      bidderWinsCount: request.bidderWinsCount,
+      wp: {
+        ada: typeof window != 'undefined' && !!window.cardano,
+        bnb: typeof window != 'undefined' && !!window.BinanceChain,
+        eth: typeof window != 'undefined' && !!window.ethereum,
+        sol: typeof window != 'undefined' && !!window.solana,
+        tron: typeof window != 'undefined' && !!window.tron,
+      },
+    };
+
+    return {
+      method: 'POST',
+      url: url(REQUEST_ROUTE),
+      options: { contentType: 'application/json', withCredentials: false },
+      data: payload,
+      bidId: request.bidId,
+    };
+  });
+
+  return result;
+}
+
+function generateTemporaryUUID() {
+  return 'tmp_' + generateUUID();
+}
+
+function interpretResponse(serverResponse, bidRequest) {
+  const { data } = serverResponse.body;
+
+  if (!data.cpm || !data.html) return [];
+
+  const size = mediaSize(data);
+
+  const result = {
+    requestId: bidRequest.bidId,
+    cpm: data.cpm,
+    width: size.width,
+    height: size.height,
+    creativeId: data.creative_set_slug,
+    currency: data.currency,
+    netRevenue: true,
+    referrer: bidRequest.data.referrer,
+    ttl: data.ttl,
+    ad: data.html,
+    mediaType: serverResponse.body.data.media_type,
+    meta: {
+      advertiserDomains: data.advertiserDomains || [],
+    },
+  };
+
+  return [result];
+}
+
+export function report(eventType, data, route = REPORTING_ROUTE) {
+  if (!route) return;
+
+  const options = {
+    method: 'POST',
+    contentType: 'application/json',
+    withCredentials: true,
+  };
+
+  const request = { type: eventType, data };
+  ajax(url(route), null, request, options);
+}
+
+function onTimeout(timeoutData) {
+  this.report('timeout', timeoutData);
+}
+
+function onBidWon(bid) {
+  this.report('bidWon', bid);
+}
+
+function onSetTargeting(bid) {
+  this.report('setTargeting', bid);
+}
+
+function onBidderError(errorData) {
+  this.report('bidderError', errorData);
+}
+
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: [BANNER],
+  aliases: ['hype'],
+  isBidRequestValid,
+  buildRequests,
+  interpretResponse,
+  onTimeout,
+  onBidWon,
+  onSetTargeting,
+  onBidderError,
+  report,
+  REPORTING_ROUTE: 'a',
+};
+
+registerBidder(spec);

package/modules/hypelabBidAdapter.md

@@ -0,0 +1,38 @@
+# Overview
+
+```
+Module Name: HypeLab Bid Adapter
+Module Type: Bidder Adapter
+Maintainer: sdk@hypelab.com
+```
+
+# Description
+
+Prebid.JS adapter that connects to HypeLab ad network for bids.
+*NOTE*: The HypeLab Adapter requires setup and approval before use. Please reach out to `partnerships@hypelab.com` for more details. To get started, replace the `property_slug` with your property_slug and the `placement_slug` with your placement slug to receive bids. The placement slug will depend on the required size and can be set via the HypeLab interface.
+
+# Test Parameters
+
+## Sample Banner Ad Unit
+
+```js
+var adUnits = [
+  {
+    code: 'banner-div',
+    mediaTypes: {
+      banner: {
+        sizes: [[728, 90]],
+      },
+    },
+    bids: [
+        {
+            bidder: 'hypelab',
+            params: {
+                property_slug: 'prebid',
+                placement_slug: 'test_placement'
+            }
+        }
+    ]
+  }
+]
+```

package/modules/id5IdSystem.js

@@ -60,11 +60,11 @@ export const id5IdSubmodule = {
    */
   decode(value, config) {
     let universalUid;
-    let linkType = 0;
+    let ext = {};
 
     if (value && typeof value.universal_uid === 'string') {
       universalUid = value.universal_uid;
-      linkType = value.link_type || linkType;
+      ext = value.ext || ext;
     } else {
       return undefined;
     }
@@ -72,9 +72,7 @@ export const id5IdSubmodule = {
     let responseObj = {
       id5id: {
         uid: universalUid,
-        ext: {
-          linkType: linkType
-        }
+        ext: ext
       }
     };
 

package/modules/ixBidAdapter.js

@@ -96,7 +96,7 @@ const VIDEO_PARAMS_ALLOW_LIST = [
   'skipafter', 'sequence', 'battr', 'maxextended', 'minbitrate',
   'maxbitrate', 'boxingallowed', 'playbackmethod', 'playbackend',
   'delivery', 'pos', 'companionad', 'api', 'companiontype', 'ext',
-  'playerSize', 'w', 'h'
+  'playerSize', 'w', 'h', 'plcmt'
 ];
 const LOCAL_STORAGE_KEY = 'ixdiag';
 export const LOCAL_STORAGE_FEATURE_TOGGLES_KEY = `${BIDDER_CODE}_features`;
@@ -216,6 +216,8 @@ function bidToVideoImp(bid) {
 
   const context = (videoParamRef && videoParamRef.context) || (videoAdUnitRef && videoAdUnitRef.context);
 
+  verifyVideoPlcmt(imp);
+
   // if placement not already defined, pick one based on `context`
   if (context && !imp.video.hasOwnProperty('placement')) {
     if (context === INSTREAM) {
@@ -249,6 +251,15 @@ function bidToVideoImp(bid) {
   return imp;
 }
 
+function verifyVideoPlcmt(imp) {
+  if (imp.video.hasOwnProperty('plcmt') && (!isInteger(imp.video.plcmt) || (imp.video.plcmt < 1 || imp.video.plcmt > 4))) {
+    logWarn(
+      `IX Bid Adapter: video.plcmt [${imp.video.plcmt}] must be an integer between 1-4 inclusive`
+    );
+    delete imp.video.plcmt;
+  }
+}
+
 /**
  * Transform valid bid request config object to native impression object that will be sent to ad server.
  *