prebid.js 7.48.0 → 7.50.0

package/modules/retailspotBidAdapter.js

@@ -0,0 +1,186 @@
+import {buildUrl, deepAccess, parseSizesInput} from '../src/utils.js';
+import {registerBidder} from '../src/adapters/bidderFactory.js';
+import {BANNER, VIDEO} from '../src/mediaTypes.js';
+
+const BIDDER_CODE = 'retailspot';
+const DEFAULT_SUBDOMAIN = 'ssp';
+const PREPROD_SUBDOMAIN = 'ssp-preprod';
+const HOST = 'retail-spot.io';
+const ENDPOINT = '/prebid';
+const DEV_URL = 'http://localhost:8090/prebid';
+
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: [BANNER, VIDEO],
+  aliases: ['rs'], // short code
+  /**
+   * Determines whether or not the given bid request is valid.
+   *
+   * @param {BidRequest} bid The bid params to validate.
+   * @return boolean True if this is a valid bid, and false otherwise.
+   */
+  isBidRequestValid: function (bid) {
+    const sizes = getSize(getSizeArray(bid));
+    const sizeValid = sizes.width > 0 && sizes.height > 0;
+
+    return deepAccess(bid, 'params.placement') && sizeValid;
+  },
+  /**
+   * Make a server request from the list of BidRequests.
+   *
+   * @param {bidRequests} - bidRequests.bids[] is an array of AdUnits and bids
+   * @return ServerRequest Info describing the request to the server.
+   */
+  buildRequests: function (bidRequests, bidderRequest) {
+    const payload = bidderRequest;
+    payload.rs_pbjs_version = '$prebid.version$';
+
+    const data = JSON.stringify(payload);
+    const options = {
+      withCredentials: true
+    };
+
+    const envParam = bidRequests[0].params.env;
+    var subDomain = DEFAULT_SUBDOMAIN;
+    if (envParam === 'preprod') {
+      subDomain = PREPROD_SUBDOMAIN;
+    }
+
+    let url = buildUrl({
+      protocol: 'https',
+      host: `${subDomain}.${HOST}`,
+      pathname: ENDPOINT
+    });
+
+    if (envParam === 'dev') {
+      url = DEV_URL;
+    }
+
+    return {
+      method: 'POST',
+      url,
+      data,
+      options
+    };
+  },
+  /**
+   * 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, request) {
+    const bidResponses = [];
+    var bidRequests = {};
+
+    try {
+      bidRequests = JSON.parse(request.data).bids;
+    } catch (err) {
+      // json error initial request can't be read
+    }
+
+    // For this adapter, serverResponse is a list
+    serverResponse.body.forEach(response => {
+      const bid = createBid(response, bidRequests);
+      if (bid) {
+        bidResponses.push(bid);
+      }
+    });
+
+    return bidResponses;
+  }
+}
+
+function getSizeArray(bid) {
+  let inputSize = bid.sizes || [];
+
+  if (bid.mediaTypes && bid.mediaTypes.banner) {
+    inputSize = bid.mediaTypes.banner.sizes || [];
+  }
+
+  // handle size in bid.params in formats: [w, h] and [[w,h]].
+  if (bid.params && Array.isArray(bid.params.size)) {
+    inputSize = bid.params.size;
+    if (!Array.isArray(inputSize[0])) {
+      inputSize = [inputSize]
+    }
+  }
+
+  return parseSizesInput(inputSize);
+}
+
+/* Get parsed size from request size */
+function getSize(sizesArray) {
+  const parsed = {};
+  // the main requested size is the first one
+  const size = sizesArray[0];
+
+  if (typeof size !== 'string') {
+    return parsed;
+  }
+
+  const parsedSize = size.toUpperCase().split('X');
+  const width = parseInt(parsedSize[0], 10);
+  if (width) {
+    parsed.width = width;
+  }
+
+  const height = parseInt(parsedSize[1], 10);
+  if (height) {
+    parsed.height = height;
+  }
+
+  return parsed;
+}
+
+/* Create bid from response */
+function createBid(response, bidRequests) {
+  if (!response || !response.mediaType ||
+    (response.mediaType === 'video' && !response.vastXml) ||
+    (response.mediaType === 'banner' && !response.ad)) {
+    return;
+  }
+
+  const request = bidRequests && bidRequests.length && bidRequests.find(itm => response.requestId === itm.bidId);
+  // In case we don't retreive the size from the adserver, use the given one.
+  if (request) {
+    if (!response.width || response.width === '0') {
+      response.width = request.width;
+    }
+
+    if (!response.height || response.height === '0') {
+      response.height = request.height;
+    }
+  }
+
+  const bid = {
+    bidderCode: BIDDER_CODE,
+    width: response.width,
+    height: response.height,
+    requestId: response.requestId,
+    ttl: response.ttl || 3600,
+    creativeId: response.creativeId,
+    cpm: response.cpm,
+    netRevenue: response.netRevenue,
+    currency: response.currency,
+    meta: response.meta || { advertiserDomains: ['retail-spot.io'] },
+    mediaType: response.mediaType
+  };
+
+  // retreive video response if present
+  if (response.mediaType === 'video') {
+    bid.vastXml = window.atob(response.vastXml);
+  } else {
+    bid.ad = response.ad;
+  }
+  if (response.adId) {
+    bid.adId = response.adId;
+  }
+  if (response.dealId) {
+    bid.dealId = response.dealId;
+  }
+
+  return bid;
+}
+
+registerBidder(spec);

package/modules/riseBidAdapter.js

@@ -292,6 +292,7 @@ function generateBidParameters(bid, bidderRequest) {
     bidderRequestId: getBidIdParameter('bidderRequestId', bid),
     loop: getBidIdParameter('bidderRequestsCount', bid),
     transactionId: getBidIdParameter('transactionId', bid),
+    coppa: 0
   };
 
   const pos = deepAccess(bid, `mediaTypes.${mediaType}.pos`);
@@ -364,6 +365,11 @@ function generateBidParameters(bid, bidderRequest) {
     if (protocols) {
       bidObject.protocols = protocols;
     }
+
+    const coppa = deepAccess(bid, 'ortb2.regs.coppa')
+    if (coppa) {
+      bidObject.coppa = 1;
+    }
   }
 
   return bidObject;

package/modules/rubiconBidAdapter.js

@@ -207,11 +207,15 @@ export const converter = ortbConverter({
     const bidResponse = buildBidResponse(bid, context);
     bidResponse.meta.mediaType = deepAccess(bid, 'ext.prebid.type');
     const {bidRequest} = context;
+
+    let [parseSizeWidth, parseSizeHeight] = bidRequest.mediaTypes.video?.context === 'outstream' ? parseSizes(bidRequest, VIDEO) : [undefined, undefined];
+
+    bidResponse.width = bid.w || parseSizeWidth || bidResponse.playerWidth;
+    bidResponse.height = bid.h || parseSizeHeight || bidResponse.playerHeight;
+
     if (bidResponse.mediaType === VIDEO && bidRequest.mediaTypes.video.context === 'outstream') {
       bidResponse.renderer = outstreamRenderer(bidResponse);
     }
-    bidResponse.width = bid.w || deepAccess(bidRequest, 'mediaTypes.video.w') || deepAccess(bidRequest, 'params.video.playerWidth');
-    bidResponse.height = bid.h || deepAccess(bidRequest, 'mediaTypes.video.h') || deepAccess(bidRequest, 'params.video.playerHeight');
 
     if (deepAccess(bid, 'ext.bidder.rp.advid')) {
       deepSetValue(bidResponse, 'meta.advertiserId', bid.ext.bidder.rp.advid);

package/modules/silverpushBidAdapter.js

@@ -0,0 +1,326 @@
+import { config } from '../src/config.js';
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import * as utils from '../src/utils.js';
+import { mergeDeep } from '../src/utils.js';
+import { BANNER, VIDEO } from '../src/mediaTypes.js';
+import { ortbConverter } from '../libraries/ortbConverter/converter.js';
+import { Renderer } from '../src/Renderer.js';
+import { ajax } from '../src/ajax.js';
+
+const BIDDER_CODE = 'silverpush';
+const bidderConfig = 'sp_pb_ortb';
+const bidderVersion = '1.0.0';
+const DEFAULT_CURRENCY = 'USD';
+
+export const REQUEST_URL = 'https://apac.chocolateplatform.com/bidder/?identifier=prebidchoc';
+export const SP_OUTSTREAM_PLAYER_URL = 'https://xaido.sgp1.cdn.digitaloceanspaces.com/prebid/spoutstream.min.js';
+
+const VIDEO_ORTB_PARAMS = [
+  'mimes',
+  'minduration',
+  'maxduration',
+  'placement',
+  'protocols',
+  'startdelay',
+  'skip',
+  'skipafter',
+  'minbitrate',
+  'maxbitrate',
+  'delivery',
+  'playbackmethod',
+  'api',
+  'linearity'
+];
+
+export const VIDEO_ORTB_REQUIRED = ['api', 'mimes', 'placement', 'protocols', 'minduration', 'maxduration', 'startdelay'];
+
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: [BANNER, VIDEO],
+  isBidRequestValid,
+  buildRequests,
+  interpretResponse,
+  onBidWon,
+  getRequest: function(endpoint) {
+    ajax(endpoint, null, undefined, {method: 'GET'});
+  },
+  getOS: function(ua) {
+    if (ua.indexOf('Windows') != -1) { return 'Windows'; } else if (ua.match(/(iPhone|iPod|iPad)/)) { return 'iOS'; } else if (ua.indexOf('Mac OS X') != -1) { return 'macOS'; } else if (ua.match(/Android/)) { return 'Android'; } else if (ua.indexOf('Linux') != -1) { return 'Linux'; } else { return 'Unknown'; }
+  }
+};
+
+registerBidder(spec);
+
+export const CONVERTER = ortbConverter({
+  context: {
+    netRevenue: true,
+    ttl: 300
+  },
+  imp(buildImp, bidRequest, context) {
+    let imp = buildImp(bidRequest, context);
+
+    if (bidRequest.mediaTypes[VIDEO]) {
+      imp = buildVideoImp(bidRequest, imp);
+    } else if (bidRequest.mediaTypes[BANNER]) {
+      imp = buildBannerImp(bidRequest, imp);
+    }
+
+    const bidFloor = getBidFloor(bidRequest);
+
+    utils.deepSetValue(imp, 'bidfloor', bidFloor);
+
+    if (bidRequest.params.deals && bidRequest.params.deals.length > 0) {
+      utils.deepSetValue(imp, 'pmp', { deals: bidRequest.params.deals });
+    }
+
+    return imp;
+  },
+  request(buildRequest, imps, bidderRequest, context) {
+    const req = buildRequest(imps, bidderRequest, context);
+    mergeDeep(req, {
+      at: 1,
+      ext: {
+        bc: `${bidderConfig}_${bidderVersion}`
+      }
+    })
+
+    let userAgent = navigator.userAgent;
+    utils.deepSetValue(req, 'device.os', spec.getOS(userAgent));
+    utils.deepSetValue(req, 'device.devicetype', _isMobile() ? 1 : _isConnectedTV() ? 3 : 2);
+
+    const bid = context.bidRequests[0];
+    if (bid.params.publisherId) {
+      utils.deepSetValue(req, 'site.publisher.id', bid.params.publisherId);
+    }
+
+    return req;
+  },
+
+  bidResponse(buildBidResponse, bid, context) {
+    let bidResponse = buildBidResponse(bid, context);
+
+    if (bid.ext) {
+      bidResponse.meta.networkId = bid.ext.dsp_id;
+      bidResponse.meta.advertiserId = bid.ext.buyer_id;
+      bidResponse.meta.brandId = bid.ext.brand_id;
+    }
+
+    if (context.ortbResponse.ext && context.ortbResponse.ext.paf) {
+      bidResponse.meta.paf = Object.assign({}, context.ortbResponse.ext.paf);
+      bidResponse.meta.paf.content_id = utils.deepAccess(bid, 'ext.paf.content_id');
+    }
+
+    bidResponse = buildVideoVastResponse(bidResponse)
+    bidResponse = buildVideoOutstreamResponse(bidResponse, context)
+
+    return bidResponse;
+  },
+  response(buildResponse, bidResponses, ortbResponse, context) {
+    const response = buildResponse(bidResponses, ortbResponse, context);
+
+    let fledgeAuctionConfigs = utils.deepAccess(ortbResponse, 'ext.fledge_auction_configs');
+    if (fledgeAuctionConfigs) {
+      fledgeAuctionConfigs = Object.entries(fledgeAuctionConfigs).map(([bidId, cfg]) => {
+        return Object.assign({
+          bidId,
+          auctionSignals: {}
+        }, cfg);
+      });
+      return {
+        bids: response.bids,
+        fledgeAuctionConfigs,
+      }
+    } else {
+      return response.bids
+    }
+  }
+});
+
+function isBidRequestValid(bidRequest) {
+  return (isPublisherIdValid(bidRequest) && (isValidBannerRequest(bidRequest) || isValidVideoRequest(bidRequest)));
+}
+
+function isPublisherIdValid(bidRequest) {
+  let pubId = utils.deepAccess(bidRequest, 'params.publisherId');
+  return (pubId != null && utils.isStr(pubId) && pubId != '');
+}
+
+function isValidBannerRequest(bidRequest) {
+  const bannerSizes = utils.deepAccess(bidRequest, `mediaTypes.${BANNER}.sizes`);
+
+  return utils.isArray(bannerSizes) && bannerSizes.length > 0 && bannerSizes.every(size => utils.isNumber(size[0]) && utils.isNumber(size[1]));
+}
+
+function isValidVideoRequest(bidRequest) {
+  const videoSizes = utils.deepAccess(bidRequest, `mediaTypes.${VIDEO}.playerSize`);
+  const PARAM_EXISTS = VIDEO_ORTB_REQUIRED.every(param => utils.deepAccess(bidRequest, `mediaTypes.${VIDEO}.${param}`) != null);
+
+  return PARAM_EXISTS && utils.isArray(videoSizes) && videoSizes.length > 0 && videoSizes.every(size => utils.isNumber(size[0]) && utils.isNumber(size[1]));
+}
+
+function buildRequests(validBids, bidderRequest) {
+  let videoBids = validBids.filter(bid => isVideoBid(bid));
+  let bannerBids = validBids.filter(bid => isBannerBid(bid));
+  let requests = [];
+
+  bannerBids.forEach(bid => {
+    requests.push(createRequest([bid], bidderRequest, BANNER));
+  });
+
+  videoBids.forEach(bid => {
+    requests.push(createRequest([bid], bidderRequest, VIDEO));
+  });
+
+  return requests;
+}
+
+function buildVideoImp(bidRequest, imp) {
+  if (bidRequest.mediaTypes[VIDEO]?.context === 'outstream') {
+    imp.video.placement = imp.video.placement || 4;
+  }
+
+  const videoMediaType = utils.deepAccess(bidRequest, `mediaTypes.${VIDEO}`);
+  const videoSizes = (videoMediaType && videoMediaType.playerSize) || [];
+
+  if (videoSizes && videoSizes.length > 0) {
+    utils.deepSetValue(imp, 'video.w', videoSizes[0][0]);
+    utils.deepSetValue(imp, 'video.h', videoSizes[0][1]);
+  }
+
+  const videoAdUnitParams = utils.deepAccess(bidRequest, `mediaTypes.${VIDEO}`, {});
+  const videoBidderParams = utils.deepAccess(bidRequest, `params.${VIDEO}`, {});
+
+  const videoParams = { ...videoAdUnitParams, ...videoBidderParams };
+
+  VIDEO_ORTB_PARAMS.forEach((param) => {
+    if (videoParams.hasOwnProperty(param)) {
+      utils.deepSetValue(imp, `video.${param}`, videoParams[param]);
+    }
+  });
+
+  return { ...imp };
+}
+
+function buildBannerImp(bidRequest, imp) {
+  const bannerSizes = utils.deepAccess(bidRequest, `mediaTypes.${BANNER}.sizes`, []);
+
+  if (bannerSizes && bannerSizes.length > 0) {
+    utils.deepSetValue(imp, 'banner.w', bannerSizes[0][0]);
+    utils.deepSetValue(imp, 'banner.h', bannerSizes[0][1]);
+  }
+
+  return {...imp};
+}
+
+function createRequest(bidRequests, bidderRequest, mediaType) {
+  return {
+    method: 'POST',
+    url: REQUEST_URL,
+    data: CONVERTER.toORTB({ bidRequests, bidderRequest, context: { mediaType } })
+  }
+}
+
+function buildVideoVastResponse(bidResponse) {
+  if (bidResponse.mediaType == VIDEO && bidResponse.vastXml) {
+    bidResponse.vastUrl = bidResponse.vastXml;
+  }
+
+  return { ...bidResponse }
+}
+
+function buildVideoOutstreamResponse(bidResponse, context) {
+  if (context.bidRequest.mediaTypes[VIDEO]?.context === 'outstream') {
+    bidResponse.rendererUrl = SP_OUTSTREAM_PLAYER_URL;
+    bidResponse.adUnitCode = context.bidRequest.adUnitCode;
+
+    bidResponse.renderer = Renderer.install({
+      id: bidResponse.requestId,
+      adUnitCode: context.bidRequest.adUnitCode,
+      url: bidResponse.rendererUrl
+    });
+
+    bidResponse.renderer.setRender(_renderer(bidResponse));
+
+    bidResponse.renderer.render(bidResponse);
+  }
+
+  return {...bidResponse};
+}
+
+function getBidFloor(bid) {
+  const currency = config.getConfig('currency.adServerCurrency') || DEFAULT_CURRENCY;
+
+  if (typeof bid.getFloor !== 'function') {
+    return utils.deepAccess(bid, 'params.bidFloor', 0.05);
+  }
+
+  const bidFloor = bid.getFloor({
+    currency: currency,
+    mediaType: '*',
+    size: '*',
+  });
+  return bidFloor.floor;
+}
+
+function _renderer(bid) {
+  bid.renderer.push(() => {
+    if (typeof window.SPOutStreamPlayer === 'function') {
+      const spoplayer = new window.SPOutStreamPlayer(bid);
+
+      spoplayer.on('ready', () => {
+        spoplayer.startAd();
+      });
+
+      try {
+        let vastUrlbt = 'data:text/xml;charset=utf-8;base64,' + btoa(bid.vastUrl.replace(/\\"/g, '"'));
+        spoplayer.load(vastUrlbt).then(function() {
+          window.spoplayer = spoplayer;
+        }).catch(function(reason) {
+          setTimeout(function() { throw reason; }, 0);
+        });
+      } catch (err) {
+        utils.logMessage(err);
+      }
+    } else {
+      utils.logMessage(`Silverpush outstream player is not defined`);
+    }
+  });
+}
+
+function isVideoBid(bid) {
+  return utils.deepAccess(bid, 'mediaTypes.video');
+}
+
+function isBannerBid(bid) {
+  return utils.deepAccess(bid, 'mediaTypes.banner') || !isVideoBid(bid);
+}
+
+function interpretResponse(resp, req) {
+  if (!resp.body) {
+    resp.body = { nbr: 0 };
+  }
+
+  return CONVERTER.fromORTB({ request: req.data, response: resp.body });
+}
+
+function onBidWon(bid) {
+  if (bid == null) { return; }
+  if (bid['burl'] == null) { return; }
+
+  let burlMac = bid['burl'];
+  burlMac = burlMac.replace('$' + '{AUCTION_PRICE}', bid['cpm']);
+  burlMac = burlMac.replace('$' + '{AUCTION_ID}', bid['auctionId']);
+  burlMac = burlMac.replace('$' + '{AUCTION_IMP_ID}', bid['requestId']);
+  burlMac = burlMac.replace('$' + '{AUCTION_AD_ID}', bid['adId']);
+  burlMac = burlMac.replace('$' + '{AUCTION_SEAT_ID}', bid['seatBidId']);
+
+  spec.getRequest(burlMac);
+}
+
+function _isMobile() {
+  return (/(ios|ipod|ipad|iphone|android)/i).test(navigator.userAgent);
+}
+
+function _isConnectedTV() {
+  return (/(smart[-]?tv|hbbtv|appletv|googletv|hdmi|netcast\.tv|viera|nettv|roku|\bdtv\b|sonydtv|inettvbrowser|\btv\b)/i).test(navigator.userAgent);
+}

package/modules/silverpushBidAdapter.md

@@ -0,0 +1,107 @@
+# Overview
+
+```
+Module Name: Silverpush OpenRTB Bidder Adapter
+Module Type: Bidder Adapter
+Maintainer: prebid@silverpush.co
+```
+
+# Description
+
+Prebid.JS adapter that connects to the Chocolate Ad Exchange.
+
+*NOTE*: The Silverpush Bidder Adapter requires setup and approval before use. Please reach out to prebid@silverpush.co representative for more details. 
+
+# Bid Parameters
+
+## Banner/Video
+
+{: .table .table-bordered .table-striped }
+|       Name     |    Scope    |                 Description                |    Example    |     Type     |
+| -------------- | ----------- | ------------------------------------------ | ------------- | ------------ |
+| `publisherId` | required | Publisher id provided by silverpush | "123456" | String |
+| `bidFloor` | optional | Minimum price in USD. bidFloor applies to a specific unit. For example, use the following value to set a $1.50 floor: 1.50. <br/> | 1.50 | Number |
+
+
+
+
+# mediaTypes Parameters
+
+## mediaTypes.banner
+
+The following banner parameters are supported here so publishers may fully declare their banner inventory:
+
+{: .table .table-bordered .table-striped }
+|    Name   |    Scope    |                      Description                                  |  Example  |    Type   |
+| --------- | ------------| ----------------------------------------------------------------- | --------- | --------- |
+| sizes | required | Avalaible sizes supported for banner ad unit | [ [300, 250], [300, 600] ] | [[Integer, Integer], [Integer, Integer]] | 
+
+## mediaTypes.video
+
+
+The following video parameters are supported here so publishers may fully declare their video inventory:
+
+{: .table .table-bordered .table-striped }
+|    Name   |    Scope    |                      Description                                  |  Example  |    Type   |
+| --------- | ------------| ----------------------------------------------------------------- | --------- | --------- |
+| context | required | instream or outstream |"outstream" | string | 
+| playerSize | required | Avalaible sizes supported for video ad unit. | [300, 250] | [Integer, Integer] | 
+| mimes | required | List of content MIME types supported by the player. | ["video/mp4"]| [String]|
+| protocols | required | Supported video bid response protocol values. | [2,3,5,6] | [integers]|
+| api | required | Supported API framework values. | [2] |  [integers] |
+| maxduration | required | Maximum video ad duration in seconds. | 30 | Integer |
+| minduration | required | Minimum video ad duration in seconds. | 6 | Integer |
+| startdelay | required | Indicates the start delay in seconds for pre-roll, mid-roll, or post-roll ad placements. | 0 | Integer |
+| placement | required | Placement type for the impression. | 1 | Integer |
+| minbitrate | optional | Minimum bit rate in Kbps. | 300 | Integer |
+| maxbitrate | optional | Maximum bit rate in Kbps. | 9600 | Integer |
+| playbackmethod | optional | Playback methods that may be in use. Only one method is typically used in practice. | [2]| [Integers] |
+| linearity | optional | OpenRTB2 linearity. in-strea,overlay... | 1 | Integer |
+| skip | optional | Indicates if the player will allow the video to be skipped, where 0 = no, 1 = yes . | 1 | Integer |
+| skipafter | optional | Number of seconds a video must play before skipping is enabled; only applicable if the ad is skippable. | 5 | Integer |
+| delivery | optional | OpenRTB2 delivery. Supported delivery methods (e.g., streaming, progressive). If none specified, assume all are supported.  | 1 | [Integer] |
+
+
+# Example
+```javascript
+  var adUnits = [{
+    code: 'div-1',
+    mediaTypes: {
+        banner: {
+            sizes: [ [300, 250], [300,600] ]
+        }
+    },
+    bids: [{
+      bidder: 'silverpush',
+      params: {
+          publisherId: "123456",
+          bidFloor: 1.2
+      }
+    }]
+  },{
+    code: 'video-1',
+    mediaTypes: {
+        video: {
+            api: [1, 2, 4, 6],
+            mimes: ['video/mp4'],
+            context: 'instream', // or 'outstream'
+            playerSize: [ 640, 480 ],
+            protocols: [4,5,6,7],
+            placement: 1,
+            minduration: 0,
+            maxduration: 60,
+            startdelay: 0
+        }
+    },
+    bids: [
+        {
+            bidder: 'silverpush',
+            params: {
+                publisherId: "123456",
+                bidfloor: 2.5
+            }
+        }
+    ]
+  }
+];
+```