@easyyad/bot-sdk 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 N'GUESSAN JEAN STEPHANE ELIEL (EasyAd)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,119 @@
-# Temporary Holding Version
+# @easyyad/bot-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Affichez des publicités EasyAd dans votre bot Telegram et touchez **50 %** de ce que l'annonceur paie.
+
+> **English** — Show EasyAd ads in your Telegram bot and earn **50%** of what advertisers pay.
+> `npm install @easyyad/bot-sdk`, create `new EasyAd({ apiKey })`, then call `easyad.serve({ userId, locale, send })`
+> after your bot has answered. Works with ESM (`import`) and CommonJS (`require`), Node 18+. TypeScript types included.
+> Full documentation: https://easyyad.com/docs
+
+```bash
+npm install @easyyad/bot-sdk
+```
+
+## En trois lignes
+
+```js
+import { EasyAd } from '@easyyad/bot-sdk';
+
+const easyad = new EasyAd({ apiKey: process.env.EASYAD_API_KEY });
+```
+
+Récupérez votre clé dans votre espace EasyAd, onglet **Bots** → votre bot → **Clé d'intégration**.
+Elle n'est affichée qu'une fois : nous n'en gardons qu'une empreinte, nous ne pouvons pas vous la
+redonner, seulement la remplacer.
+
+## Montrer une annonce
+
+```js
+bot.on('message', async (ctx) => {
+  await repondreNormalement(ctx);                 // votre bot fait d'abord son travail
+
+  const ad = await easyad.nextAd({
+    userId: ctx.from.id,
+    locale: ctx.from.language_code,
+  });
+
+  if (ad) {
+    await ctx.reply(ad.text, { parse_mode: 'HTML', reply_markup: ad.replyMarkup });
+    await easyad.markShown(ad.placementId);        // sans cette ligne, vous n'êtes pas payé
+  }
+});
+```
+
+`nextAd` renvoie `null` quand il n'y a rien à montrer, quand cet utilisateur a déjà vu son quota du
+jour, ou si EasyAd est momentanément injoignable. Dans les trois cas, votre bot continue comme si
+rien ne s'était passé : **une panne chez nous ne doit jamais casser votre bot.**
+
+### Le raccourci `serve()`
+
+```js
+await easyad.serve({
+  userId: ctx.from.id,
+  locale: ctx.from.language_code,
+  send: (ad) => ctx.reply(ad.text, { parse_mode: 'HTML', reply_markup: ad.replyMarkup }),
+});
+```
+
+Demande, envoie, confirme. Si votre `send` échoue, rien n'est confirmé — donc rien ne vous est
+compté, et l'annonceur n'est pas facturé.
+
+## Avec une image
+
+```js
+if (ad.imageUrl) {
+  await ctx.replyWithPhoto(ad.imageUrl, { caption: ad.text, parse_mode: 'HTML', reply_markup: ad.replyMarkup });
+} else {
+  await ctx.reply(ad.text, { parse_mode: 'HTML', reply_markup: ad.replyMarkup });
+}
+await easyad.markShown(ad.placementId);
+```
+
+## Vérifier l'intégration
+
+```js
+console.log(await easyad.health());
+// { ok: true, bot: { name: 'Mon bot', status: 'approved', serving: true }, limits: { … } }
+```
+
+Appelez-le au démarrage : vous saurez tout de suite si la clé est bonne et si votre bot est approuvé.
+
+## Ce que l'on reçoit de vous
+
+`userId` est **haché avant l'envoi** (SHA-256, tronqué à 32 caractères, salé avec votre clé). Nous ne
+voyons jamais l'identifiant Telegram de vos utilisateurs, et comme le sel est votre clé, deux
+partenaires ne peuvent pas recouper leurs audiences. Cette empreinte ne sert qu'à une chose : ne pas
+montrer trop d'annonces à la même personne.
+
+Vous pouvez choisir votre propre sel avec `userSalt` — gardez-le stable, sinon le plafond de
+fréquence repart de zéro à chaque changement.
+
+## Options
+
+| Option | Défaut | À quoi ça sert |
+|---|---|---|
+| `apiKey` | — | Votre clé secrète. Obligatoire. |
+| `baseUrl` | `https://api.easyyad.com/api/v1/sdk/bot` | Pour viser un environnement de test. |
+| `timeoutMs` | `4000` | Au-delà, on renonce : votre bot doit rester rapide. |
+| `throwOnError` | `false` | `true` pour gérer les erreurs vous-même. |
+| `userSalt` | la clé | Sel du hachage des identifiants. |
+| `logger` | — | `(level, message, extra) => void`, branchez votre journalisation. |
+
+## Fréquence
+
+Deux limites, réglables dans votre espace EasyAd :
+
+- **annonces par utilisateur et par jour** (3 par défaut) ;
+- **délai minimum entre deux annonces** pour la même personne (60 minutes par défaut).
+
+Elles existent pour protéger votre audience : une conversation privée saturée de publicité fait
+partir vos utilisateurs, et c'est votre revenu qui disparaît avec eux. Vous pouvez les resserrer
+autant que vous voulez.
+
+## Rémunération
+
+Vous êtes payé sur les annonces **confirmées**. Une annonce demandée mais jamais confirmée est
+abandonnée au bout de 30 minutes et ne compte pour personne. Les gains apparaissent dans votre
+portefeuille après la période de vérification, puis deviennent retirables.
+
+Documentation complète : <https://www.easyyad.com/docs/bots>

package/dist/index.cjs

@@ -0,0 +1,174 @@
+'use strict';
+/**
+ * SDK EasyAd pour les bots — JavaScript / TypeScript (Node 18+).
+ *
+ * Deux appels suffisent : demander une annonce, puis confirmer qu'elle a bien été envoyée.
+ * Rien dans ce SDK ne lève d'erreur par défaut : un réseau coupé ou un quota atteint renvoie
+ * simplement `null`, pour qu'une panne chez nous ne casse jamais votre bot.
+ */
+
+const DEFAULT_BASE = 'https://api.easyyad.com/api/v1/sdk/bot';
+
+class EasyAdError extends Error {
+  constructor(message, { status, code, retryAfterSeconds } = {}) {
+    super(message);
+    this.name = 'EasyAdError';
+    this.status = status ?? 0;
+    this.code = code ?? 'unknown';
+    this.retryAfterSeconds = retryAfterSeconds ?? null;
+  }
+}
+
+/** Identifiant d'utilisateur haché : nous n'avons jamais besoin de l'identifiant réel. */
+async function hashUserId(value, salt) {
+  const { createHash } = await import('node:crypto');
+  return createHash('sha256').update(`${salt}:${value}`).digest('hex').slice(0, 32);
+}
+
+class EasyAd {
+  /**
+   * @param {object} options
+   * @param {string} options.apiKey            Clé secrète du bot (ea_live_…).
+   * @param {string} [options.baseUrl]         Pour pointer vers un environnement de test.
+   * @param {number} [options.timeoutMs=4000]  Au-delà, on renonce : votre bot doit répondre vite.
+   * @param {boolean} [options.throwOnError=false] true pour gérer les erreurs vous-même.
+   * @param {string} [options.userSalt]        Sel du hachage des identifiants (défaut : la clé).
+   * @param {(level: string, message: string, extra?: object) => void} [options.logger]
+   */
+  constructor({ apiKey, baseUrl = DEFAULT_BASE, timeoutMs = 4000, throwOnError = false, userSalt, logger } = {}) {
+    if (!apiKey) throw new EasyAdError('Clé EasyAd manquante : passez { apiKey }.', { code: 'missing_api_key' });
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/+$/, '');
+    this.timeoutMs = timeoutMs;
+    this.throwOnError = throwOnError;
+    this.userSalt = userSalt || apiKey;
+    this.logger = logger || (() => {});
+  }
+
+  /**
+   * Demande une annonce pour l'utilisateur en face du bot.
+   *
+   * @param {object} params
+   * @param {string|number} params.userId   Identifiant chez vous ; il est haché avant l'envoi.
+   * @param {string} [params.locale]        « fr », « en-US »… pour un meilleur ciblage.
+   * @returns {Promise<null|{placementId: string, text: string, parseMode: string, replyMarkup: object, imageUrl: ?string, label: string, confirmWithinSeconds: number}>}
+   *   `null` quand il n'y a rien à montrer, que l'utilisateur a atteint son quota, ou en cas de problème réseau.
+   */
+  async nextAd({ userId, locale } = {}) {
+    if (userId === undefined || userId === null || userId === '') {
+      throw new EasyAdError('userId est requis : il sert à limiter la fréquence par utilisateur.', { code: 'missing_user_id' });
+    }
+
+    const userRef = await hashUserId(String(userId), this.userSalt);
+    const body = await this.#post('/ads/next', { user_ref: userRef, locale: locale ?? undefined });
+    if (!body || !body.ad) return null;
+
+    const ad = body.ad;
+    return {
+      placementId: ad.placement_id,
+      text: ad.text,
+      parseMode: ad.parse_mode || 'HTML',
+      replyMarkup: ad.reply_markup,
+      imageUrl: ad.image_url ?? null,
+      label: ad.label,
+      confirmWithinSeconds: ad.confirm_within_seconds ?? 1800,
+    };
+  }
+
+  /**
+   * Confirme l'envoi. **À appeler après** que l'annonce est partie : c'est cette confirmation qui
+   * déclenche votre rémunération. Sans elle, l'annonce n'est ni facturée ni payée.
+   *
+   * @returns {Promise<boolean>} true si la confirmation est enregistrée.
+   */
+  async markShown(placementId) {
+    if (!placementId) return false;
+    const body = await this.#post(`/ads/${encodeURIComponent(placementId)}/shown`, {});
+    return Boolean(body && body.status === 'published');
+  }
+
+  /** Vérifie la clé et renvoie les réglages du bot. Pratique au démarrage. */
+  async health() {
+    return this.#request('GET', '/health');
+  }
+
+  /**
+   * Raccourci le plus courant : demande une annonce, l'envoie avec votre fonction, confirme.
+   * `send` reçoit l'annonce et doit l'envoyer ; s'il lève une erreur, rien n'est confirmé.
+   *
+   * @param {object} params
+   * @param {string|number} params.userId
+   * @param {string} [params.locale]
+   * @param {(ad: object) => Promise<unknown>} params.send
+   * @returns {Promise<boolean>} true si une annonce a été envoyée et confirmée.
+   */
+  async serve({ userId, locale, send }) {
+    const ad = await this.nextAd({ userId, locale });
+    if (!ad) return false;
+
+    await send(ad);                      // une erreur ici remonte : pas de confirmation, pas de facturation
+    return this.markShown(ad.placementId);
+  }
+
+  async #post(path, payload) {
+    return this.#request('POST', path, payload);
+  }
+
+  async #request(method, path, payload) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+
+    try {
+      const response = await fetch(this.baseUrl + path, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          Accept: 'application/json',
+          ...(payload ? { 'Content-Type': 'application/json' } : {}),
+        },
+        body: payload ? JSON.stringify(payload) : undefined,
+        signal: controller.signal,
+      });
+
+      const text = await response.text();
+      let body = null;
+      try { body = text ? JSON.parse(text) : null; } catch { /* réponse non JSON */ }
+
+      if (!response.ok) {
+        const error = new EasyAdError(body?.message || `EasyAd a répondu ${response.status}.`, {
+          status: response.status,
+          code: body?.error || `http_${response.status}`,
+          retryAfterSeconds: body?.retry_after_seconds ?? null,
+        });
+        // Un quota atteint est une réponse normale, pas une panne : on n'alarme personne.
+        if (error.code === 'frequency_capped') {
+          this.logger('debug', 'EasyAd : quota de fréquence atteint pour cet utilisateur.', { code: error.code });
+          return null;
+        }
+        if (this.throwOnError) throw error;
+        this.logger('warn', `EasyAd : ${error.message}`, { code: error.code, status: error.status });
+        return null;
+      }
+
+      return body;
+    } catch (e) {
+      if (e instanceof EasyAdError) throw e;
+      const aborted = e?.name === 'AbortError';
+      const error = new EasyAdError(
+        aborted ? `EasyAd n'a pas répondu en ${this.timeoutMs} ms.` : `EasyAd est injoignable : ${e?.message || e}`,
+        { code: aborted ? 'timeout' : 'network_error' },
+      );
+      if (this.throwOnError) throw error;
+      this.logger('warn', error.message, { code: error.code });
+      return null;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+
+module.exports = EasyAd;
+module.exports.EasyAd = EasyAd;
+module.exports.EasyAdError = EasyAdError;
+module.exports.default = EasyAd;

package/index.d.ts

@@ -0,0 +1,47 @@
+// Types de @easyyad/bot-sdk
+
+export interface EasyAdOptions {
+  /** Clé secrète du bot (ea_live_…), dans votre espace EasyAd → Bots → Clé d'intégration. */
+  apiKey: string;
+  /** Pour un environnement de test. Défaut : https://api.easyyad.com/api/v1/sdk/bot */
+  baseUrl?: string;
+  /** Délai maximal d'un appel (défaut 4000 ms). */
+  timeoutMs?: number;
+  /** true pour recevoir les erreurs au lieu d'un simple `null`. */
+  throwOnError?: boolean;
+  /** Sel du hachage des identifiants utilisateurs (défaut : la clé). */
+  userSalt?: string;
+  logger?: (level: string, message: string, extra?: Record<string, unknown>) => void;
+}
+
+export interface EasyAdAd {
+  placementId: string;
+  text: string;
+  parseMode: 'HTML';
+  replyMarkup: { inline_keyboard: Array<Array<{ text: string; url: string; style?: string }>> };
+  imageUrl: string | null;
+  label: string;
+  confirmWithinSeconds: number;
+}
+
+export interface NextAdParams {
+  userId: string | number;
+  locale?: string;
+}
+
+export declare class EasyAdError extends Error {
+  status: number;
+  code: string;
+  retryAfterSeconds: number | null;
+  constructor(message: string, extra?: { status?: number; code?: string; retryAfterSeconds?: number | null });
+}
+
+export declare class EasyAd {
+  constructor(options: EasyAdOptions);
+  nextAd(params: NextAdParams): Promise<EasyAdAd | null>;
+  markShown(placementId: string): Promise<boolean>;
+  health(): Promise<Record<string, unknown> | null>;
+  serve(params: NextAdParams & { send: (ad: EasyAdAd) => Promise<unknown> }): Promise<boolean>;
+}
+
+export default EasyAd;

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@easyyad/bot-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Show EasyAd ads in your Telegram bot and earn 50% of what advertisers pay. / Affichez des publicités EasyAd dans votre bot Telegram et soyez rémunéré.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./src/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./src/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": ["src", "dist", "index.d.ts", "README.md", "LICENSE"],
+  "sideEffects": false,
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "build": "node scripts/build-cjs.mjs",
+    "test": "node scripts/build-cjs.mjs && node --test",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": ["telegram", "telegram-bot", "bot", "ads", "advertising", "monetization", "grammy", "telegraf", "easyad"],
+  "homepage": "https://easyyad.com/docs",
+  "bugs": { "email": "support@easyyad.com" },
+  "author": "EasyAd <support@easyyad.com> (https://easyyad.com)",
+  "license": "MIT",
+  "publishConfig": { "access": "public" }
+}

package/src/index.js

@@ -0,0 +1,169 @@
+/**
+ * SDK EasyAd pour les bots — JavaScript / TypeScript (Node 18+).
+ *
+ * Deux appels suffisent : demander une annonce, puis confirmer qu'elle a bien été envoyée.
+ * Rien dans ce SDK ne lève d'erreur par défaut : un réseau coupé ou un quota atteint renvoie
+ * simplement `null`, pour qu'une panne chez nous ne casse jamais votre bot.
+ */
+
+const DEFAULT_BASE = 'https://api.easyyad.com/api/v1/sdk/bot';
+
+export class EasyAdError extends Error {
+  constructor(message, { status, code, retryAfterSeconds } = {}) {
+    super(message);
+    this.name = 'EasyAdError';
+    this.status = status ?? 0;
+    this.code = code ?? 'unknown';
+    this.retryAfterSeconds = retryAfterSeconds ?? null;
+  }
+}
+
+/** Identifiant d'utilisateur haché : nous n'avons jamais besoin de l'identifiant réel. */
+async function hashUserId(value, salt) {
+  const { createHash } = await import('node:crypto');
+  return createHash('sha256').update(`${salt}:${value}`).digest('hex').slice(0, 32);
+}
+
+export class EasyAd {
+  /**
+   * @param {object} options
+   * @param {string} options.apiKey            Clé secrète du bot (ea_live_…).
+   * @param {string} [options.baseUrl]         Pour pointer vers un environnement de test.
+   * @param {number} [options.timeoutMs=4000]  Au-delà, on renonce : votre bot doit répondre vite.
+   * @param {boolean} [options.throwOnError=false] true pour gérer les erreurs vous-même.
+   * @param {string} [options.userSalt]        Sel du hachage des identifiants (défaut : la clé).
+   * @param {(level: string, message: string, extra?: object) => void} [options.logger]
+   */
+  constructor({ apiKey, baseUrl = DEFAULT_BASE, timeoutMs = 4000, throwOnError = false, userSalt, logger } = {}) {
+    if (!apiKey) throw new EasyAdError('Clé EasyAd manquante : passez { apiKey }.', { code: 'missing_api_key' });
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/+$/, '');
+    this.timeoutMs = timeoutMs;
+    this.throwOnError = throwOnError;
+    this.userSalt = userSalt || apiKey;
+    this.logger = logger || (() => {});
+  }
+
+  /**
+   * Demande une annonce pour l'utilisateur en face du bot.
+   *
+   * @param {object} params
+   * @param {string|number} params.userId   Identifiant chez vous ; il est haché avant l'envoi.
+   * @param {string} [params.locale]        « fr », « en-US »… pour un meilleur ciblage.
+   * @returns {Promise<null|{placementId: string, text: string, parseMode: string, replyMarkup: object, imageUrl: ?string, label: string, confirmWithinSeconds: number}>}
+   *   `null` quand il n'y a rien à montrer, que l'utilisateur a atteint son quota, ou en cas de problème réseau.
+   */
+  async nextAd({ userId, locale } = {}) {
+    if (userId === undefined || userId === null || userId === '') {
+      throw new EasyAdError('userId est requis : il sert à limiter la fréquence par utilisateur.', { code: 'missing_user_id' });
+    }
+
+    const userRef = await hashUserId(String(userId), this.userSalt);
+    const body = await this.#post('/ads/next', { user_ref: userRef, locale: locale ?? undefined });
+    if (!body || !body.ad) return null;
+
+    const ad = body.ad;
+    return {
+      placementId: ad.placement_id,
+      text: ad.text,
+      parseMode: ad.parse_mode || 'HTML',
+      replyMarkup: ad.reply_markup,
+      imageUrl: ad.image_url ?? null,
+      label: ad.label,
+      confirmWithinSeconds: ad.confirm_within_seconds ?? 1800,
+    };
+  }
+
+  /**
+   * Confirme l'envoi. **À appeler après** que l'annonce est partie : c'est cette confirmation qui
+   * déclenche votre rémunération. Sans elle, l'annonce n'est ni facturée ni payée.
+   *
+   * @returns {Promise<boolean>} true si la confirmation est enregistrée.
+   */
+  async markShown(placementId) {
+    if (!placementId) return false;
+    const body = await this.#post(`/ads/${encodeURIComponent(placementId)}/shown`, {});
+    return Boolean(body && body.status === 'published');
+  }
+
+  /** Vérifie la clé et renvoie les réglages du bot. Pratique au démarrage. */
+  async health() {
+    return this.#request('GET', '/health');
+  }
+
+  /**
+   * Raccourci le plus courant : demande une annonce, l'envoie avec votre fonction, confirme.
+   * `send` reçoit l'annonce et doit l'envoyer ; s'il lève une erreur, rien n'est confirmé.
+   *
+   * @param {object} params
+   * @param {string|number} params.userId
+   * @param {string} [params.locale]
+   * @param {(ad: object) => Promise<unknown>} params.send
+   * @returns {Promise<boolean>} true si une annonce a été envoyée et confirmée.
+   */
+  async serve({ userId, locale, send }) {
+    const ad = await this.nextAd({ userId, locale });
+    if (!ad) return false;
+
+    await send(ad);                      // une erreur ici remonte : pas de confirmation, pas de facturation
+    return this.markShown(ad.placementId);
+  }
+
+  async #post(path, payload) {
+    return this.#request('POST', path, payload);
+  }
+
+  async #request(method, path, payload) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+
+    try {
+      const response = await fetch(this.baseUrl + path, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          Accept: 'application/json',
+          ...(payload ? { 'Content-Type': 'application/json' } : {}),
+        },
+        body: payload ? JSON.stringify(payload) : undefined,
+        signal: controller.signal,
+      });
+
+      const text = await response.text();
+      let body = null;
+      try { body = text ? JSON.parse(text) : null; } catch { /* réponse non JSON */ }
+
+      if (!response.ok) {
+        const error = new EasyAdError(body?.message || `EasyAd a répondu ${response.status}.`, {
+          status: response.status,
+          code: body?.error || `http_${response.status}`,
+          retryAfterSeconds: body?.retry_after_seconds ?? null,
+        });
+        // Un quota atteint est une réponse normale, pas une panne : on n'alarme personne.
+        if (error.code === 'frequency_capped') {
+          this.logger('debug', 'EasyAd : quota de fréquence atteint pour cet utilisateur.', { code: error.code });
+          return null;
+        }
+        if (this.throwOnError) throw error;
+        this.logger('warn', `EasyAd : ${error.message}`, { code: error.code, status: error.status });
+        return null;
+      }
+
+      return body;
+    } catch (e) {
+      if (e instanceof EasyAdError) throw e;
+      const aborted = e?.name === 'AbortError';
+      const error = new EasyAdError(
+        aborted ? `EasyAd n'a pas répondu en ${this.timeoutMs} ms.` : `EasyAd est injoignable : ${e?.message || e}`,
+        { code: aborted ? 'timeout' : 'network_error' },
+      );
+      if (this.throwOnError) throw error;
+      this.logger('warn', error.message, { code: error.code });
+      return null;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+export default EasyAd;