prebid.js 7.51.0 → 7.53.0

package/modules/uid2IdSystem_shared.js

@@ -0,0 +1,232 @@
+/* eslint-disable no-console */
+export const Uid2CodeVersion = '1.1';
+
+function isValidIdentity(identity) {
+  return !!(typeof identity === 'object' && identity !== null && identity.advertising_token && identity.identity_expires && identity.refresh_from && identity.refresh_token && identity.refresh_expires);
+}
+
+// This is extracted from an in-progress API client. Once it's available via NPM, this class should be replaced with the NPM package.
+export class Uid2ApiClient {
+  constructor(opts, clientId, logInfo, logWarn) {
+    this._baseUrl = opts.baseUrl;
+    this._clientVersion = clientId;
+    this._logInfo = logInfo;
+    this._logWarn = logWarn;
+  }
+  createArrayBuffer(text) {
+    const arrayBuffer = new Uint8Array(text.length);
+    for (let i = 0; i < text.length; i++) {
+      arrayBuffer[i] = text.charCodeAt(i);
+    }
+    return arrayBuffer;
+  }
+  hasStatusResponse(response) {
+    return typeof (response) === 'object' && response && response.status;
+  }
+  isValidRefreshResponse(response) {
+    return this.hasStatusResponse(response) && (
+      response.status === 'optout' || response.status === 'expired_token' || (response.status === 'success' && response.body && isValidIdentity(response.body))
+    );
+  }
+  ResponseToRefreshResult(response) {
+    if (this.isValidRefreshResponse(response)) {
+      if (response.status === 'success') { return { status: response.status, identity: response.body }; }
+      return response;
+    } else { return `Response didn't contain a valid status`; }
+  }
+  callRefreshApi(refreshDetails) {
+    const url = this._baseUrl + '/v2/token/refresh';
+    const req = new XMLHttpRequest();
+    req.overrideMimeType('text/plain');
+    req.open('POST', url, true);
+    req.setRequestHeader('X-UID2-Client-Version', this._clientVersion);
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+    req.onreadystatechange = () => {
+      if (req.readyState !== req.DONE) { return; }
+      try {
+        if (!refreshDetails.refresh_response_key || req.status !== 200) {
+          this._logInfo('Error status OR no response decryption key available, assuming unencrypted JSON');
+          const response = JSON.parse(req.responseText);
+          const result = this.ResponseToRefreshResult(response);
+          if (typeof result === 'string') { rejectPromise(result); } else { resolvePromise(result); }
+        } else {
+          this._logInfo('Decrypting refresh API response');
+          const encodeResp = this.createArrayBuffer(atob(req.responseText));
+          window.crypto.subtle.importKey('raw', this.createArrayBuffer(atob(refreshDetails.refresh_response_key)), { name: 'AES-GCM' }, false, ['decrypt']).then((key) => {
+            this._logInfo('Imported decryption key')
+            // returns the symmetric key
+            window.crypto.subtle.decrypt({
+              name: 'AES-GCM',
+              iv: encodeResp.slice(0, 12),
+              tagLength: 128, // The tagLength you used to encrypt (if any)
+            }, key, encodeResp.slice(12)).then((decrypted) => {
+              const decryptedResponse = String.fromCharCode(...new Uint8Array(decrypted));
+              this._logInfo('Decrypted to:', decryptedResponse);
+              const response = JSON.parse(decryptedResponse);
+              const result = this.ResponseToRefreshResult(response);
+              if (typeof result === 'string') { rejectPromise(result); } else { resolvePromise(result); }
+            }, (reason) => this._logWarn(`Call to UID2 API failed`, reason));
+          }, (reason) => this._logWarn(`Call to UID2 API failed`, reason));
+        }
+      } catch (err) {
+        rejectPromise(err);
+      }
+    };
+    this._logInfo('Sending refresh request', refreshDetails);
+    req.send(refreshDetails.refresh_token);
+    return promise;
+  }
+}
+export class Uid2StorageManager {
+  constructor(storage, preferLocalStorage, storageName, logInfo) {
+    this._storage = storage;
+    this._preferLocalStorage = preferLocalStorage;
+    this._storageName = storageName;
+    this._logInfo = logInfo;
+  }
+  readCookie(cookieName) {
+    return this._storage.cookiesAreEnabled() ? this._storage.getCookie(cookieName) : null;
+  }
+  readLocalStorage(key) {
+    return this._storage.localStorageIsEnabled() ? this._storage.getDataFromLocalStorage(key) : null;
+  }
+  readModuleCookie() {
+    return this.parseIfContainsBraces(this.readCookie(this._storageName));
+  }
+  writeModuleCookie(value) {
+    this._storage.setCookie(this._storageName, JSON.stringify(value), Date.now() + 60 * 60 * 24 * 1000);
+  }
+  readModuleStorage() {
+    return this.parseIfContainsBraces(this.readLocalStorage(this._storageName));
+  }
+  writeModuleStorage(value) {
+    this._storage.setDataInLocalStorage(this._storageName, JSON.stringify(value));
+  }
+  readProvidedCookie(cookieName) {
+    return JSON.parse(this.readCookie(cookieName));
+  }
+  parseIfContainsBraces(value) {
+    return (value?.includes('{')) ? JSON.parse(value) : value;
+  }
+  storeValue(value) {
+    if (this._preferLocalStorage) {
+      this.writeModuleStorage(value);
+    } else {
+      this.writeModuleCookie(value);
+    }
+  }
+
+  getStoredValueWithFallback() {
+    const preferredStorageLabel = this._preferLocalStorage ? 'local storage' : 'cookie';
+    const preferredStorageGet = (this._preferLocalStorage ? this.readModuleStorage : this.readModuleCookie).bind(this);
+    const preferredStorageSet = (this._preferLocalStorage ? this.writeModuleStorage : this.writeModuleCookie).bind(this);
+    const fallbackStorageGet = (this._preferLocalStorage ? this.readModuleCookie : this.readModuleStorage).bind(this);
+
+    const storedValue = preferredStorageGet();
+
+    if (!storedValue) {
+      const fallbackValue = fallbackStorageGet();
+      if (fallbackValue) {
+        this._logInfo(`${preferredStorageLabel} was empty, but found a fallback value.`)
+        if (typeof fallbackValue === 'object') {
+          this._logInfo(`Copying the fallback value to ${preferredStorageLabel}.`);
+          preferredStorageSet(fallbackValue);
+        }
+        return fallbackValue;
+      }
+    } else if (typeof storedValue === 'string') {
+      const fallbackValue = fallbackStorageGet();
+      if (fallbackValue && typeof fallbackValue === 'object') {
+        this._logInfo(`${preferredStorageLabel} contained a basic token, but found a refreshable token fallback. Copying the fallback value to ${preferredStorageLabel}.`);
+        preferredStorageSet(fallbackValue);
+        return fallbackValue;
+      }
+    }
+    return storedValue;
+  }
+}
+
+function refreshTokenAndStore(baseUrl, token, clientId, storageManager, _logInfo, _logWarn) {
+  _logInfo('UID2 base url provided: ', baseUrl);
+  const client = new Uid2ApiClient({baseUrl}, clientId, _logInfo, _logWarn);
+  return client.callRefreshApi(token).then((response) => {
+    _logInfo('Refresh endpoint responded with:', response);
+    const tokens = {
+      originalToken: token,
+      latestToken: response.identity,
+    };
+    storageManager.storeValue(tokens);
+    return tokens;
+  });
+}
+
+export function Uid2GetId(config, prebidStorageManager, _logInfo, _logWarn) {
+  let suppliedToken = null;
+  const preferLocalStorage = (config.storage !== 'cookie');
+  const storageManager = new Uid2StorageManager(prebidStorageManager, preferLocalStorage, config.internalStorage, _logInfo);
+  _logInfo(`Module is using ${preferLocalStorage ? 'local storage' : 'cookies'} for internal storage.`);
+
+  if (config.paramToken) {
+    suppliedToken = config.paramToken;
+    _logInfo('Read token from params', suppliedToken);
+  } else if (config.serverCookieName) {
+    suppliedToken = storageManager.readProvidedCookie(config.serverCookieName);
+    _logInfo('Read token from server-supplied cookie', suppliedToken);
+  }
+  let storedTokens = storageManager.getStoredValueWithFallback();
+  _logInfo('Loaded module-stored tokens:', storedTokens);
+
+  if (storedTokens && typeof storedTokens === 'string') {
+    // Stored value is a plain token - if no token is supplied, just use the stored value.
+
+    if (!suppliedToken) {
+      _logInfo('Returning legacy cookie value.');
+      return { id: storedTokens };
+    }
+    // Otherwise, ignore the legacy value - it should get over-written later anyway.
+    _logInfo('Discarding superseded legacy cookie.');
+    storedTokens = null;
+  }
+
+  if (suppliedToken && storedTokens) {
+    if (storedTokens.originalToken?.advertising_token !== suppliedToken.advertising_token) {
+      _logInfo('Server supplied new token - ignoring stored value.', storedTokens.originalToken?.advertising_token, suppliedToken.advertising_token);
+      // Stored token wasn't originally sourced from the provided token - ignore the stored value. A new user has logged in?
+      storedTokens = null;
+    }
+  }
+  // At this point, any legacy values or superseded stored tokens have been nulled out.
+  const useSuppliedToken = !(storedTokens?.latestToken) || (suppliedToken && suppliedToken.identity_expires > storedTokens.latestToken.identity_expires);
+  const newestAvailableToken = useSuppliedToken ? suppliedToken : storedTokens.latestToken;
+  _logInfo('UID2 module selected latest token', useSuppliedToken, newestAvailableToken);
+  if (!newestAvailableToken || Date.now() > newestAvailableToken.refresh_expires) {
+    _logInfo('Newest available token is expired and not refreshable.');
+    return { id: null };
+  }
+  if (Date.now() > newestAvailableToken.identity_expires) {
+    const promise = refreshTokenAndStore(config.apiBaseUrl, newestAvailableToken, config.clientId, storageManager, _logInfo, _logWarn);
+    _logInfo('Token is expired but can be refreshed, attempting refresh.');
+    return { callback: (cb) => {
+      promise.then((result) => {
+        _logInfo('Refresh reponded, passing the updated token on.', result);
+        cb(result);
+      });
+    } };
+  }
+  // If should refresh (but don't need to), refresh in the background.
+  if (Date.now() > newestAvailableToken.refresh_from) {
+    _logInfo(`Refreshing token in background with low priority.`);
+    refreshTokenAndStore(config.apiBaseUrl, newestAvailableToken, config.clientId, storageManager, _logInfo, _logWarn);
+  }
+  const tokens = {
+    originalToken: suppliedToken ?? storedTokens?.originalToken,
+    latestToken: newestAvailableToken,
+  };
+  storageManager.storeValue(tokens);
+  return { id: tokens };
+}

package/modules/undertoneBidAdapter.js

@@ -124,6 +124,12 @@ export const spec = {
       reqUrl += `&ccpa=${bidderRequest.uspConsent}`;
     }
 
+    if (bidderRequest.gppConsent) {
+      const gppString = bidderRequest.gppConsent.gppString ?? '';
+      const ggpSid = bidderRequest.gppConsent.applicableSections ?? '';
+      reqUrl += `&gpp=${gppString}&gpp_sid=${ggpSid}`;
+    }
+
     validBidRequests.map(bidReq => {
       const bid = {
         bidRequestId: bidReq.bidId,
@@ -146,7 +152,9 @@ export const spec = {
           streamType: deepAccess(bidReq, 'mediaTypes.video.context') || null,
           playbackMethod: deepAccess(bidReq, 'params.video.playbackMethod') || null,
           maxDuration: deepAccess(bidReq, 'params.video.maxDuration') || null,
-          skippable: deepAccess(bidReq, 'params.video.skippable') || null
+          skippable: deepAccess(bidReq, 'params.video.skippable') || null,
+          placement: deepAccess(bidReq, 'mediaTypes.video.placement') || null,
+          plcmt: deepAccess(bidReq, 'mediaTypes.video.plcmt') || null
         };
       }
       payload['x-ut-hb-params'].push(bid);

package/modules/userId/eids.js

@@ -291,6 +291,14 @@ export const USER_IDS_CONFIG = {
     }
   },
 
+  'euid': {
+    source: 'euid.eu',
+    atype: 3,
+    getValue: function(data) {
+      return data.id;
+    }
+  },
+
   'deepintentId': {
     source: 'deepintent.com',
     atype: 3

package/modules/userId/index.js

@@ -110,6 +110,7 @@
  * @property {SubmoduleConfig} config
  * @property {(Object|undefined)} idObj - cache decoded id value (this is copied to every adUnit bid)
  * @property {(function|undefined)} callback - holds reference to submodule.getId() result if it returned a function. Will be set to undefined after callback executes
+ * @property {StorageManager} storageMgr
  */
 
 /**
@@ -133,7 +134,12 @@ import adapterManager, {gdprDataHandler} from '../../src/adapterManager.js';
 import CONSTANTS from '../../src/constants.json';
 import {hook, module, ready as hooksReady} from '../../src/hook.js';
 import {buildEidPermissions, createEidsArray, USER_IDS_CONFIG} from './eids.js';
-import {getCoreStorageManager, STORAGE_TYPE_COOKIES, STORAGE_TYPE_LOCALSTORAGE} from '../../src/storageManager.js';
+import {
+  getCoreStorageManager,
+  getStorageManager,
+  STORAGE_TYPE_COOKIES,
+  STORAGE_TYPE_LOCALSTORAGE
+} from '../../src/storageManager.js';
 import {
   cyrb53Hash,
   deepAccess,
@@ -159,6 +165,9 @@ import {newMetrics, timedAuctionHook, useMetrics} from '../../src/utils/perfMetr
 import {findRootDomain} from '../../src/fpd/rootDomain.js';
 import {GDPR_GVLIDS} from '../../src/consentHandler.js';
 import {MODULE_TYPE_UID} from '../../src/activities/modules.js';
+import {isActivityAllowed} from '../../src/activities/rules.js';
+import {ACTIVITY_ENRICH_EIDS} from '../../src/activities/activities.js';
+import {activityParams} from '../../src/activities/activityParams.js';
 
 const MODULE_NAME = 'User ID';
 const COOKIE = STORAGE_TYPE_COOKIES;
@@ -170,7 +179,10 @@ const CONSENT_DATA_COOKIE_STORAGE_CONFIG = {
   expires: 30 // 30 days expiration, which should match how often consent is refreshed by CMPs
 };
 export const PBJS_USER_ID_OPTOUT_NAME = '_pbjs_id_optout';
-export const coreStorage = getCoreStorageManager('userid');
+export const coreStorage = getCoreStorageManager('userId');
+export const dep = {
+  isAllowed: isActivityAllowed
+}
 
 /** @type {boolean} */
 let addedUserIdHook = false;
@@ -220,11 +232,12 @@ export function setSubmoduleRegistry(submodules) {
   submoduleRegistry = submodules;
 }
 
-function cookieSetter(submodule) {
+function cookieSetter(submodule, storageMgr) {
+  storageMgr = storageMgr || submodule.storageMgr;
   const domainOverride = (typeof submodule.submodule.domainOverride === 'function') ? submodule.submodule.domainOverride() : null;
   const name = submodule.config.storage.name;
   return function setCookie(suffix, value, expiration) {
-    coreStorage.setCookie(name + (suffix || ''), value, expiration, 'Lax', domainOverride);
+    storageMgr.setCookie(name + (suffix || ''), value, expiration, 'Lax', domainOverride);
   }
 }
 
@@ -237,6 +250,7 @@ export function setStoredValue(submodule, value) {
    * @type {SubmoduleStorage}
    */
   const storage = submodule.config.storage;
+  const mgr = submodule.storageMgr;
 
   try {
     const expiresStr = (new Date(Date.now() + (storage.expires * (60 * 60 * 24 * 1000)))).toUTCString();
@@ -248,10 +262,10 @@ export function setStoredValue(submodule, value) {
         setCookie('_last', new Date().toUTCString(), expiresStr);
       }
     } else if (storage.type === LOCAL_STORAGE) {
-      coreStorage.setDataInLocalStorage(`${storage.name}_exp`, expiresStr);
-      coreStorage.setDataInLocalStorage(storage.name, encodeURIComponent(valueStr));
+      mgr.setDataInLocalStorage(`${storage.name}_exp`, expiresStr);
+      mgr.setDataInLocalStorage(storage.name, encodeURIComponent(valueStr));
       if (typeof storage.refreshInSeconds === 'number') {
-        coreStorage.setDataInLocalStorage(`${storage.name}_last`, new Date().toUTCString());
+        mgr.setDataInLocalStorage(`${storage.name}_last`, new Date().toUTCString());
       }
     }
   } catch (error) {
@@ -263,7 +277,7 @@ export function deleteStoredValue(submodule) {
   let deleter, suffixes;
   switch (submodule.config?.storage?.type) {
     case COOKIE:
-      const setCookie = cookieSetter(submodule);
+      const setCookie = cookieSetter(submodule, coreStorage);
       const expiry = (new Date(Date.now() - 1000 * 60 * 60 * 24)).toUTCString();
       deleter = (suffix) => setCookie(suffix, '', expiry)
       suffixes = ['', '_last'];
@@ -292,25 +306,26 @@ function setPrebidServerEidPermissions(initializedSubmodules) {
 }
 
 /**
-/**
- * @param {SubmoduleStorage} storage
+ * @param {SubmoduleContainer} submodule
  * @param {String|undefined} key optional key of the value
  * @returns {string}
  */
-function getStoredValue(storage, key = undefined) {
+function getStoredValue(submodule, key = undefined) {
+  const mgr = submodule.storageMgr;
+  const storage = submodule.config.storage;
   const storedKey = key ? `${storage.name}_${key}` : storage.name;
   let storedValue;
   try {
     if (storage.type === COOKIE) {
-      storedValue = coreStorage.getCookie(storedKey);
+      storedValue = mgr.getCookie(storedKey);
     } else if (storage.type === LOCAL_STORAGE) {
-      const storedValueExp = coreStorage.getDataFromLocalStorage(`${storage.name}_exp`);
+      const storedValueExp = mgr.getDataFromLocalStorage(`${storage.name}_exp`);
       // empty string means no expiration set
       if (storedValueExp === '') {
-        storedValue = coreStorage.getDataFromLocalStorage(storedKey);
+        storedValue = mgr.getDataFromLocalStorage(storedKey);
       } else if (storedValueExp) {
         if ((new Date(storedValueExp)).getTime() - Date.now() > 0) {
-          storedValue = decodeURIComponent(coreStorage.getDataFromLocalStorage(storedKey));
+          storedValue = decodeURIComponent(mgr.getDataFromLocalStorage(storedKey));
         }
       }
     }
@@ -415,7 +430,7 @@ function processSubmoduleCallbacks(submodules, cb) {
       moduleDone();
     }
     try {
-      submodule.callback(callbackCompleted, getStoredValue.bind(null, submodule.config?.storage));
+      submodule.callback(callbackCompleted, getStoredValue.bind(null, submodule));
     } catch (e) {
       logError(`Error in userID module '${submodule.submodule.name}':`, e);
       moduleDone();
@@ -773,6 +788,8 @@ function getUserIdsAsync() {
  * This hook returns updated list of submodules which are allowed to do get user id based on TCF 2 enforcement rules configured
  */
 export const validateGdprEnforcement = hook('sync', function (submodules, consentData) {
+  // TODO: remove the `hasValidated` check in v8. Enforcement should be OFF by default.
+  // https://github.com/prebid/Prebid.js/issues/9766
   return { userIdModules: submodules, hasValidated: consentData && consentData.hasValidated };
 }, 'validateGdprEnforcement');
 
@@ -781,12 +798,12 @@ function populateSubmoduleId(submodule, consentData, storedConsentData, forceRef
   // 1. storage: retrieve user id data from cookie/html storage or with the submodule's getId method
   // 2. value: pass directly to bids
   if (submodule.config.storage) {
-    let storedId = getStoredValue(submodule.config.storage);
+    let storedId = getStoredValue(submodule);
     let response;
 
     let refreshNeeded = false;
     if (typeof submodule.config.storage.refreshInSeconds === 'number') {
-      const storedDate = new Date(getStoredValue(submodule.config.storage, 'last'));
+      const storedDate = new Date(getStoredValue(submodule, 'last'));
       refreshNeeded = storedDate && (Date.now() - storedDate.getTime() > submodule.config.storage.refreshInSeconds * 1000);
     }
 
@@ -849,17 +866,23 @@ function initSubmodules(dest, submodules, consentData, forceRefresh = false) {
   return uidMetrics().fork().measureTime('userId.init.modules', function () {
     if (!submodules.length) return []; // to simplify log messages from here on
 
-    // filter out submodules whose storage type is not enabled
-    // this needs to be done here (after consent data has loaded) so that enforcement may disable storage globally
-    const storageTypes = getActiveStorageTypes();
-    submodules = submodules.filter((submod) => !submod.config.storage || storageTypes.has(submod.config.storage.type));
+    /**
+     * filter out submodules that:
+     *
+     *  - cannot use the storage they've been set up with (storage not available / not allowed / disabled)
+     *  - are not allowed to perform the `enrichEids` activity
+     */
+    submodules = submodules.filter((submod) => {
+      return (!submod.config.storage || canUseStorage(submod)) &&
+        dep.isAllowed(ACTIVITY_ENRICH_EIDS, activityParams(MODULE_TYPE_UID, submod.config.name));
+    });
 
     if (!submodules.length) {
-      logWarn(`${MODULE_NAME} - no ID module is configured for one of the available storage types:`, Array.from(storageTypes));
+      logWarn(`${MODULE_NAME} - no ID module configured`);
       return [];
     }
 
-    // another consent check, this time each module is checked for consent with its own gvlid
+    // TODO: remove this check in v8 (https://github.com/prebid/Prebid.js/issues/9766)
     let { userIdModules, hasValidated } = validateGdprEnforcement(submodules, consentData);
     if (!hasValidated && !hasPurpose1Consent(consentData)) {
       logWarn(`${MODULE_NAME} - gdpr permission not valid for local storage or cookies, exit module`);
@@ -940,24 +963,28 @@ function getValidSubmoduleConfigs(configRegistry, submoduleRegistry) {
 
 const ALL_STORAGE_TYPES = new Set([LOCAL_STORAGE, COOKIE]);
 
-function getActiveStorageTypes() {
-  const storageTypes = [];
-  let disabled = false;
-  if (coreStorage.localStorageIsEnabled()) {
-    storageTypes.push(LOCAL_STORAGE);
-    if (coreStorage.getDataFromLocalStorage(PBJS_USER_ID_OPTOUT_NAME)) {
-      logInfo(`${MODULE_NAME} - opt-out localStorage found, storage disabled`);
-      disabled = true;
-    }
-  }
-  if (coreStorage.cookiesAreEnabled()) {
-    storageTypes.push(COOKIE);
-    if (coreStorage.getCookie(PBJS_USER_ID_OPTOUT_NAME)) {
-      logInfo(`${MODULE_NAME} - opt-out cookie found, storage disabled`);
-      disabled = true;
-    }
+function canUseStorage(submodule) {
+  switch (submodule.config?.storage?.type) {
+    case LOCAL_STORAGE:
+      if (submodule.storageMgr.localStorageIsEnabled()) {
+        if (coreStorage.getDataFromLocalStorage(PBJS_USER_ID_OPTOUT_NAME)) {
+          logInfo(`${MODULE_NAME} - opt-out localStorage found, storage disabled`);
+          return false
+        }
+        return true;
+      }
+      break;
+    case COOKIE:
+      if (submodule.storageMgr.cookiesAreEnabled()) {
+        if (coreStorage.getCookie(PBJS_USER_ID_OPTOUT_NAME)) {
+          logInfo(`${MODULE_NAME} - opt-out cookie found, storage disabled`);
+          return false;
+        }
+        return true
+      }
+      break;
   }
-  return new Set(disabled ? [] : storageTypes)
+  return false;
 }
 
 /**
@@ -985,6 +1012,7 @@ function updateSubmodules() {
       config: submoduleConfig,
       callback: undefined,
       idObj: undefined,
+      storageMgr: getStorageManager({moduleType: MODULE_TYPE_UID, moduleName: submoduleConfig.name}),
     } : null;
   }).filter(submodule => submodule !== null)
     .forEach((sm) => submodules.push(sm));

package/modules/userId/userId.md

@@ -126,7 +126,8 @@ pbjs.setConfig({
             }
         },{
             name: 'uid2'
-        }
+        }, {
+            name: 'euid'
         }, {
               name: 'admixerId',
               params: {

package/modules/viouslyBidAdapter.js

@@ -5,7 +5,7 @@ import { BANNER, VIDEO } from '../src/mediaTypes.js';
 import find from 'core-js-pure/features/array/find.js'; // eslint-disable-line prebid/validate-imports
 
 const BIDDER_CODE = 'viously';
-// const GVLID = 1028;
+const GVLID = 1028;
 const CURRENCY = 'EUR';
 const TTL = 60;
 const HTTP_METHOD = 'POST';
@@ -15,7 +15,7 @@ const REQUIRED_VIOUSLY_PARAMS = ['pid'];
 
 export const spec = {
   code: BIDDER_CODE,
-  // gvlid: GVLID,
+  gvlid: GVLID,
   supportedMediaTypes: [BANNER, VIDEO],
 
   /**