@hyve-sdk/js 1.2.2 → 1.3.1-canary.1

package/dist/index.js

@@ -20,10 +20,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AdsService: () => AdsService,
   HyveClient: () => HyveClient,
+  Logger: () => Logger,
+  NativeBridge: () => NativeBridge,
+  NativeMessageType: () => NativeMessageType,
   generateUUID: () => generateUUID,
   handleVerifyMessage: () => handleVerifyMessage,
   isDomainAllowed: () => isDomainAllowed,
+  logger: () => logger,
   parseUrlParams: () => parseUrlParams,
   validateSignature: () => validateSignature,
   verifyAuthentication: () => verifyAuthentication,
@@ -32,8 +37,132 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/utils/index.ts
-var import_ethers = require("ethers");
 var import_uuid = require("uuid");
+
+// src/utils/logger.ts
+var Logger = class _Logger {
+  config;
+  constructor() {
+    this.config = this.initializeConfig();
+  }
+  /**
+   * Initialize logger configuration based on NODE_ENV
+   */
+  initializeConfig() {
+    const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+    let enabled = false;
+    let levels = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]);
+    if (isNode) {
+      const nodeEnv = process.env.NODE_ENV;
+      enabled = nodeEnv !== "production";
+      const logLevelEnv = process.env.HYVE_SDK_LOG_LEVEL;
+      if (logLevelEnv) {
+        const configuredLevels = logLevelEnv.split(",").map((l) => l.trim());
+        levels = new Set(configuredLevels);
+      }
+    } else if (typeof window !== "undefined") {
+      try {
+        enabled = process.env.NODE_ENV !== "production";
+      } catch (e) {
+        enabled = true;
+      }
+      try {
+        const localStorageLogLevel = localStorage.getItem("HYVE_SDK_LOG_LEVEL");
+        if (localStorageLogLevel) {
+          const configuredLevels = localStorageLogLevel.split(",").map((l) => l.trim());
+          levels = new Set(configuredLevels);
+        }
+      } catch (e) {
+      }
+    }
+    return {
+      enabled,
+      prefix: "[Hyve SDK]",
+      levels
+    };
+  }
+  /**
+   * Set which log levels to display
+   */
+  setLevels(levels) {
+    this.config.levels = new Set(levels);
+    if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+      try {
+        localStorage.setItem("HYVE_SDK_LOG_LEVEL", levels.join(","));
+      } catch (e) {
+      }
+    }
+  }
+  /**
+   * Check if logging is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Internal log method
+   */
+  log(level, ...args) {
+    if (!this.config.enabled || !this.config.levels.has(level)) {
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `${this.config.prefix} [${level.toUpperCase()}] [${timestamp}]`;
+    switch (level) {
+      case "debug":
+        console.debug(prefix, ...args);
+        break;
+      case "info":
+        console.info(prefix, ...args);
+        break;
+      case "warn":
+        console.warn(prefix, ...args);
+        break;
+      case "error":
+        console.error(prefix, ...args);
+        break;
+    }
+  }
+  /**
+   * Log a debug message
+   */
+  debug(...args) {
+    this.log("debug", ...args);
+  }
+  /**
+   * Log an info message
+   */
+  info(...args) {
+    this.log("info", ...args);
+  }
+  /**
+   * Log a warning message
+   */
+  warn(...args) {
+    this.log("warn", ...args);
+  }
+  /**
+   * Log an error message
+   */
+  error(...args) {
+    this.log("error", ...args);
+  }
+  /**
+   * Create a child logger with a specific prefix
+   */
+  child(prefix) {
+    const childLogger = new _Logger();
+    childLogger.config = {
+      ...this.config,
+      prefix: `${this.config.prefix} [${prefix}]`
+    };
+    return childLogger;
+  }
+};
+var logger = new Logger();
+
+// src/utils/auth.ts
+var import_ethers = require("ethers");
 function parseUrlParams(searchParams) {
   const params = typeof searchParams === "string" ? new URLSearchParams(searchParams) : searchParams;
   return {
@@ -51,7 +180,7 @@ function validateSignature(signature, message) {
     const recoveredAddress = import_ethers.ethers.verifyMessage(message, signature);
     return !!recoveredAddress;
   } catch (error) {
-    console.error("Signature validation error:", error);
+    logger.error("Signature validation error:", error);
     return false;
   }
 }
@@ -78,7 +207,7 @@ function handleVerifyMessage(signature, message) {
     }
     return userAddress;
   } catch (error) {
-    console.error("Error verifying message:", error);
+    logger.error("Error verifying message:", error);
     return false;
   }
 }
@@ -86,7 +215,7 @@ function verifyHyveToken(hyveToken, maxAgeSec = 600) {
   try {
     const parts = hyveToken.split(".");
     if (parts.length !== 4) {
-      console.error(
+      logger.error(
         "Invalid hyve-token format: expected 4 parts, got",
         parts.length
       );
@@ -94,30 +223,30 @@ function verifyHyveToken(hyveToken, maxAgeSec = 600) {
     }
     const [signature, address, randomBase64, timestampStr] = parts;
     if (!signature || !address || !randomBase64 || !timestampStr) {
-      console.error("Missing hyve-token components");
+      logger.error("Missing hyve-token components");
       return false;
     }
     const message = `${address}.${randomBase64}.${timestampStr}`;
     const recoveredAddress = import_ethers.ethers.verifyMessage(message, signature);
     if (recoveredAddress.toLowerCase() !== address.toLowerCase()) {
-      console.error("Hyve-token signature verification failed");
+      logger.error("Hyve-token signature verification failed");
       return false;
     }
     const timestamp = parseInt(timestampStr, 10);
     if (!Number.isFinite(timestamp)) {
-      console.error("Invalid hyve-token timestamp");
+      logger.error("Invalid hyve-token timestamp");
       return false;
     }
     const now = Math.floor(Date.now() / 1e3);
     if (now - timestamp > maxAgeSec) {
-      console.error(
+      logger.error(
         `Hyve-token expired (age: ${now - timestamp}s, max: ${maxAgeSec}s)`
       );
       return false;
     }
     return address;
   } catch (error) {
-    console.error("Hyve-token verification error:", error);
+    logger.error("Hyve-token verification error:", error);
     return false;
   }
 }
@@ -163,11 +292,8 @@ function verifyAuthentication(params, maxAgeSec = 600) {
     error: "No authentication tokens provided"
   };
 }
-function generateUUID() {
-  return (0, import_uuid.v4)();
-}
 function isDomainAllowed(allowedDomains, hostname) {
-  console.log("Hostname", hostname);
+  logger.debug("Checking hostname:", hostname);
   if (!allowedDomains) return true;
   const targetHostname = hostname || "";
   if (!targetHostname) return false;
@@ -185,6 +311,403 @@ function isDomainAllowed(allowedDomains, hostname) {
   });
 }
 
+// src/utils/native-bridge.ts
+var NativeMessageType = /* @__PURE__ */ ((NativeMessageType2) => {
+  NativeMessageType2["CHECK_IAP_AVAILABILITY"] = "CHECK_IAP_AVAILABILITY";
+  NativeMessageType2["REQUEST_NOTIFICATION_PERMISSION"] = "REQUEST_NOTIFICATION_PERMISSION";
+  NativeMessageType2["GET_PRODUCTS"] = "GET_PRODUCTS";
+  NativeMessageType2["PURCHASE"] = "PURCHASE";
+  NativeMessageType2["IAP_AVAILABILITY_RESULT"] = "IAP_AVAILABILITY_RESULT";
+  NativeMessageType2["PUSH_PERMISSION_GRANTED"] = "PUSH_PERMISSION_GRANTED";
+  NativeMessageType2["PUSH_PERMISSION_DENIED"] = "PUSH_PERMISSION_DENIED";
+  NativeMessageType2["PRODUCTS_RESULT"] = "PRODUCTS_RESULT";
+  NativeMessageType2["PURCHASE_COMPLETE"] = "PURCHASE_COMPLETE";
+  NativeMessageType2["PURCHASE_ERROR"] = "PURCHASE_ERROR";
+  return NativeMessageType2;
+})(NativeMessageType || {});
+var NativeBridge = class {
+  static handlers = /* @__PURE__ */ new Map();
+  static isInitialized = false;
+  /**
+   * Checks if the app is running inside a React Native WebView
+   */
+  static isNativeContext() {
+    return typeof window !== "undefined" && "ReactNativeWebView" in window;
+  }
+  /**
+   * Initializes the native bridge message listener
+   * Call this once when your app starts
+   */
+  static initialize() {
+    if (this.isInitialized) {
+      logger.debug("[NativeBridge] Already initialized");
+      return;
+    }
+    if (typeof window === "undefined") {
+      logger.warn("[NativeBridge] Window not available, skipping initialization");
+      return;
+    }
+    const boundHandler = this.handleNativeMessage.bind(this);
+    window.addEventListener("message", boundHandler);
+    document.addEventListener("message", boundHandler);
+    this.isInitialized = true;
+    logger.info("[NativeBridge] Initialized and listening for native messages");
+  }
+  /**
+   * Handles incoming messages from React Native
+   */
+  static handleNativeMessage(event) {
+    try {
+      let data;
+      if (typeof event.data === "string") {
+        try {
+          data = JSON.parse(event.data);
+          logger.debug("[NativeBridge] Parsed message string:", data);
+        } catch (parseError) {
+          logger.debug("[NativeBridge] Failed to parse message, not JSON:", event.data);
+          return;
+        }
+      } else if (typeof event.data === "object" && event.data !== null) {
+        data = event.data;
+        logger.debug("[NativeBridge] Received message object:", data);
+      } else {
+        logger.debug("[NativeBridge] Received invalid message type:", typeof event.data);
+        return;
+      }
+      if (!data || !data.type) {
+        logger.debug("[NativeBridge] Received message without type, ignoring");
+        return;
+      }
+      const handler = this.handlers.get(data.type);
+      if (handler) {
+        logger.info(`[NativeBridge] Handling message: ${data.type}`, data.payload);
+        handler(data.payload);
+      } else {
+        logger.warn(`[NativeBridge] No handler registered for: ${data.type}`);
+      }
+    } catch (error) {
+      logger.error("[NativeBridge] Error handling native message:", error);
+    }
+  }
+  /**
+   * Sends a message to React Native
+   * @param type Message type
+   * @param payload Optional payload data
+   */
+  static send(type, payload) {
+    if (!this.isNativeContext()) {
+      logger.debug(
+        `[NativeBridge] Not in native context, skipping message: ${type}`
+      );
+      return;
+    }
+    try {
+      const message = {
+        type,
+        payload,
+        timestamp: Date.now()
+      };
+      window.ReactNativeWebView.postMessage(JSON.stringify(message));
+      logger.debug(`[NativeBridge] Sent message to native: ${type}`, payload);
+    } catch (error) {
+      logger.error(`[NativeBridge] Error sending message to native:`, error);
+    }
+  }
+  /**
+   * Registers a handler for messages from React Native
+   * @param type Message type to listen for
+   * @param handler Function to call when message is received
+   */
+  static on(type, handler) {
+    this.handlers.set(type, handler);
+    logger.debug(`[NativeBridge] Registered handler for: ${type}`);
+  }
+  /**
+   * Unregisters a handler for a specific message type
+   * @param type Message type to stop listening for
+   */
+  static off(type) {
+    this.handlers.delete(type);
+    logger.debug(`[NativeBridge] Unregistered handler for: ${type}`);
+  }
+  /**
+   * Clears all registered handlers
+   */
+  static clearHandlers() {
+    this.handlers.clear();
+    logger.debug("[NativeBridge] Cleared all handlers");
+  }
+  /**
+   * Checks if In-App Purchases are available on the device
+   * The native app will respond with a message containing availability status
+   *
+   * @example
+   * // Listen for the response
+   * NativeBridge.on("IAP_AVAILABILITY_RESULT", (payload) => {
+   *   console.log("IAP available:", payload.available);
+   * });
+   *
+   * // Send the request
+   * NativeBridge.checkIAPAvailability();
+   */
+  static checkIAPAvailability() {
+    this.send("CHECK_IAP_AVAILABILITY" /* CHECK_IAP_AVAILABILITY */);
+  }
+  /**
+   * Requests notification permission from the native app
+   * The native app will respond with PUSH_PERMISSION_GRANTED or PUSH_PERMISSION_DENIED
+   *
+   * @example
+   * // Listen for the response
+   * NativeBridge.on("PUSH_PERMISSION_GRANTED", () => {
+   *   console.log("Permission granted");
+   * });
+   *
+   * NativeBridge.on("PUSH_PERMISSION_DENIED", () => {
+   *   console.log("Permission denied");
+   * });
+   *
+   * // Send the request
+   * NativeBridge.requestNotificationPermission();
+   */
+  static requestNotificationPermission() {
+    this.send("REQUEST_NOTIFICATION_PERMISSION" /* REQUEST_NOTIFICATION_PERMISSION */);
+  }
+  /**
+   * Requests available products for a specific game
+   * The native app will respond with PRODUCTS_RESULT containing product details
+   *
+   * @param gameId - The game ID to fetch products for
+   *
+   * @example
+   * // Listen for the response
+   * NativeBridge.on("PRODUCTS_RESULT", (payload) => {
+   *   console.log("Products:", payload.products);
+   * });
+   *
+   * // Send the request
+   * NativeBridge.getProducts(123);
+   */
+  static getProducts(gameId) {
+    this.send("GET_PRODUCTS" /* GET_PRODUCTS */, { gameId });
+  }
+  /**
+   * Initiates a purchase for a specific product
+   * The native app will respond with PURCHASE_COMPLETE or PURCHASE_ERROR
+   *
+   * @param productId - The product ID to purchase
+   * @param userId - The user ID making the purchase
+   *
+   * @example
+   * // Listen for responses
+   * NativeBridge.on("PURCHASE_COMPLETE", (payload) => {
+   *   console.log("Purchase successful:", payload.productId);
+   * });
+   *
+   * NativeBridge.on("PURCHASE_ERROR", (payload) => {
+   *   console.error("Purchase failed:", payload.error);
+   * });
+   *
+   * // Initiate purchase
+   * NativeBridge.purchase("product_123", "user_456");
+   */
+  static purchase(productId, userId) {
+    this.send("PURCHASE" /* PURCHASE */, { productId, userId });
+  }
+};
+
+// src/utils/index.ts
+function generateUUID() {
+  return (0, import_uuid.v4)();
+}
+
+// src/services/ads.ts
+var AdsService = class {
+  config = {
+    enabled: false,
+    sound: "on",
+    debug: false,
+    onBeforeAd: () => {
+    },
+    onAfterAd: () => {
+    },
+    onRewardEarned: () => {
+    }
+  };
+  initialized = false;
+  ready = false;
+  /**
+   * Configure the ads service
+   * Must set enabled: true to activate ads
+   */
+  configure(config) {
+    this.config = {
+      ...this.config,
+      ...config,
+      onBeforeAd: config.onBeforeAd || this.config.onBeforeAd,
+      onAfterAd: config.onAfterAd || this.config.onAfterAd,
+      onRewardEarned: config.onRewardEarned || this.config.onRewardEarned
+    };
+    if (this.config.debug) {
+      console.log("[AdsService] Configuration updated:", {
+        enabled: this.config.enabled,
+        sound: this.config.sound
+      });
+    }
+    if (this.config.enabled && !this.initialized) {
+      this.initialize();
+    }
+  }
+  /**
+   * Initialize the ads system
+   */
+  initialize() {
+    if (this.initialized) return;
+    if (!this.config.enabled) {
+      if (this.config.debug) {
+        console.log("[AdsService] Ads disabled, skipping initialization");
+      }
+      return;
+    }
+    if (!window.adConfig || !window.adBreak) {
+      console.warn("[AdsService] Google Ads SDK not found. Ads will not be available.");
+      return;
+    }
+    if (this.config.debug) {
+      console.log("[AdsService] Initializing ads system...");
+    }
+    const googleConfig = {
+      sound: this.config.sound,
+      preloadAdBreaks: "on",
+      onReady: () => {
+        this.ready = true;
+        if (this.config.debug) {
+          console.log("[AdsService] Ads ready");
+        }
+      }
+    };
+    window.adConfig(googleConfig);
+    this.initialized = true;
+  }
+  /**
+   * Show an ad
+   * Returns immediately if ads are disabled
+   */
+  async show(type) {
+    const requestedAt = Date.now();
+    if (!this.config.enabled) {
+      if (this.config.debug) {
+        console.log("[AdsService] Ads disabled, skipping ad request");
+      }
+      return {
+        success: false,
+        type,
+        error: new Error("Ads are disabled"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    if (!this.initialized) {
+      this.initialize();
+    }
+    if (!this.ready || !window.adBreak) {
+      return {
+        success: false,
+        type,
+        error: new Error("Ads not ready"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    return this.showAdBreak(type);
+  }
+  /**
+   * Show an ad break
+   */
+  async showAdBreak(type) {
+    const requestedAt = Date.now();
+    return new Promise((resolve) => {
+      const googleType = type === "rewarded" ? "reward" : type === "preroll" ? "start" : "next";
+      const adName = `${type}-ad-${Date.now()}`;
+      if (this.config.debug) {
+        console.log(`[AdsService] Showing ${type} ad`);
+      }
+      this.config.onBeforeAd(type);
+      const adBreakConfig = {
+        type: googleType,
+        name: adName,
+        beforeAd: () => {
+          if (this.config.debug) {
+            console.log("[AdsService] Ad started");
+          }
+        },
+        afterAd: () => {
+          if (this.config.debug) {
+            console.log("[AdsService] Ad finished");
+          }
+          this.config.onAfterAd(type);
+        },
+        adBreakDone: (info) => {
+          const completedAt = Date.now();
+          let success = false;
+          if (type === "rewarded") {
+            success = info?.breakStatus === "viewed";
+          } else {
+            success = info?.breakStatus !== "error";
+          }
+          const error = info?.breakStatus === "error" && info?.error ? new Error(info.error) : void 0;
+          if (this.config.debug) {
+            console.log("[AdsService] Ad break done:", {
+              success,
+              status: info?.breakStatus
+            });
+          }
+          const result = {
+            success,
+            type,
+            error,
+            requestedAt,
+            completedAt
+          };
+          resolve(result);
+        }
+      };
+      if (type === "rewarded") {
+        adBreakConfig.beforeReward = (showAdFn) => {
+          if (this.config.debug) {
+            console.log("[AdsService] beforeReward callback");
+          }
+          showAdFn();
+        };
+        adBreakConfig.adViewed = () => {
+          if (this.config.debug) {
+            console.log("[AdsService] Rewarded ad watched successfully");
+          }
+          this.config.onRewardEarned();
+        };
+        adBreakConfig.adDismissed = () => {
+          if (this.config.debug) {
+            console.log("[AdsService] Rewarded ad dismissed");
+          }
+        };
+      }
+      window.adBreak(adBreakConfig);
+    });
+  }
+  /**
+   * Check if ads are enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Check if ads are ready to show
+   */
+  isReady() {
+    return this.config.enabled && this.ready;
+  }
+};
+
 // src/core/client.ts
 var HyveClient = class {
   telemetryConfig;
@@ -193,9 +716,10 @@ var HyveClient = class {
   userId = null;
   jwtToken = null;
   gameId = null;
+  adsService;
   /**
    * Creates a new HyveClient instance
-   * @param config Optional telemetry configuration
+   * @param config Optional configuration including telemetry and ads
    */
   constructor(config) {
     this.telemetryConfig = {
@@ -209,9 +733,14 @@ var HyveClient = class {
       this.apiBaseUrl = this.telemetryConfig.isDev ? "https://product-api.dev.hyve.gg" : "https://product-api.prod.hyve.gg";
     }
     this.sessionId = generateUUID();
-    console.log("[Hyve SDK] Client initialized with sessionId:", this.sessionId);
-    console.log("[Hyve SDK] API Base URL:", this.apiBaseUrl);
-    console.log("[Hyve SDK] Environment:", this.telemetryConfig.isDev ? "dev" : "prod");
+    this.adsService = new AdsService();
+    if (config?.ads) {
+      this.adsService.configure(config.ads);
+    }
+    logger.info("Client initialized with sessionId:", this.sessionId);
+    logger.info("API Base URL:", this.apiBaseUrl);
+    logger.info("Environment:", this.telemetryConfig.isDev ? "dev" : "prod");
+    logger.info("Ads enabled:", this.adsService.isEnabled());
   }
   /**
    * Authenticates a user from URL parameters
@@ -223,14 +752,22 @@ var HyveClient = class {
       const params = urlParams ? parseUrlParams(urlParams) : parseUrlParams(window.location.search);
       if (params.hyveAccess) {
         this.jwtToken = params.hyveAccess;
-        console.log("[Hyve SDK] JWT token extracted from hyve-access parameter");
+        logger.info("JWT token extracted from hyve-access parameter");
       }
       if (params.gameId) {
         this.gameId = params.gameId;
-        console.log("[Hyve SDK] Game ID extracted from game-id parameter:", this.gameId);
+        logger.info("Game ID extracted from game-id parameter:", this.gameId);
       }
       if (this.jwtToken) {
-        console.log("[Hyve SDK] Authentication successful via JWT");
+        logger.info("Authentication successful via JWT");
+        return true;
+      }
+      if (params.gameId) {
+        this.gameId = params.gameId;
+        logger.info("Game ID extracted from game-id parameter:", this.gameId);
+      }
+      if (this.jwtToken) {
+        logger.info("Authentication successful via JWT");
         return true;
       }
       const authResult = verifyAuthentication({
@@ -240,16 +777,16 @@ var HyveClient = class {
       });
       if (authResult.isValid && authResult.address) {
         this.userId = authResult.address;
-        console.log("[Hyve SDK] Authentication successful:", authResult.address);
-        console.log("[Hyve SDK] Authentication method:", authResult.method);
+        logger.info("Authentication successful:", authResult.address);
+        logger.info("Authentication method:", authResult.method);
         return true;
       } else {
-        console.error("[Hyve SDK] Authentication failed:", authResult.error);
+        logger.error("Authentication failed:", authResult.error);
         this.userId = null;
         return false;
       }
     } catch (error) {
-      console.error("[Hyve SDK] Authentication error:", error);
+      logger.error("Authentication error:", error);
       this.userId = null;
       return false;
     }
@@ -269,11 +806,11 @@ var HyveClient = class {
    */
   async sendTelemetry(eventLocation, eventCategory, eventAction, eventSubCategory, eventSubAction, eventDetails, customData, platformId) {
     if (!this.jwtToken) {
-      console.error("[Hyve Telemetry] JWT token required. Call authenticateFromUrl first.");
+      logger.error("JWT token required. Call authenticateFromUrl first.");
       return false;
     }
     if (!this.gameId) {
-      console.error("[Hyve Telemetry] Game ID required. Ensure game-id URL parameter is set.");
+      logger.error("Game ID required. Ensure game-id URL parameter is set.");
       return false;
     }
     try {
@@ -293,26 +830,30 @@ var HyveClient = class {
         event_details: toJsonString(eventDetails),
         custom_data: toJsonString(customData)
       };
-      console.log("[Hyve Telemetry] Sending user-level event:", telemetryEvent);
+      logger.debug("Sending telemetry event:", telemetryEvent);
       const telemetryUrl = `${this.apiBaseUrl}/api/v1/telemetry/send`;
       const response = await fetch(telemetryUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "Authorization": `Bearer ${this.jwtToken}`
+          Authorization: `Bearer ${this.jwtToken}`
         },
         body: JSON.stringify(telemetryEvent)
       });
       if (response.ok) {
-        console.log("[Hyve Telemetry] Event sent successfully:", response.status);
+        logger.info("Telemetry event sent successfully:", response.status);
         return true;
       } else {
         const errorText = await response.text();
-        console.error("[Hyve Telemetry] Failed to send event:", response.status, errorText);
+        logger.error(
+          "Failed to send telemetry event:",
+          response.status,
+          errorText
+        );
         return false;
       }
     } catch (error) {
-      console.error("[Hyve Telemetry] Error sending event:", error);
+      logger.error("Error sending telemetry event:", error);
       return false;
     }
   }
@@ -324,15 +865,18 @@ var HyveClient = class {
    */
   async callApi(endpoint, options = {}) {
     if (!this.jwtToken) {
-      throw new Error("[Hyve SDK] No JWT token available. Call authenticateFromUrl first.");
+      throw new Error(
+        "No JWT token available. Call authenticateFromUrl first."
+      );
     }
     try {
       const url = `${this.apiBaseUrl}${endpoint.startsWith("/") ? endpoint : `/${endpoint}`}`;
+      logger.debug("Making API call to:", url);
       const response = await fetch(url, {
         ...options,
         headers: {
           "Content-Type": "application/json",
-          "Authorization": `Bearer ${this.jwtToken}`,
+          Authorization: `Bearer ${this.jwtToken}`,
           ...options.headers
         }
       });
@@ -342,7 +886,7 @@ var HyveClient = class {
       }
       return await response.json();
     } catch (error) {
-      console.error("[Hyve SDK] API call failed:", error);
+      logger.error("API call failed:", error);
       throw error;
     }
   }
@@ -375,8 +919,8 @@ var HyveClient = class {
     } else if (config.isDev !== void 0) {
       this.apiBaseUrl = config.isDev ? "https://product-api.dev.hyve.gg" : "https://product-api.prod.hyve.gg";
     }
-    console.log("[Hyve SDK] Config updated");
-    console.log("[Hyve SDK] API Base URL:", this.apiBaseUrl);
+    logger.info("Config updated");
+    logger.info("API Base URL:", this.apiBaseUrl);
   }
   /**
    * Gets the current user ID
@@ -434,7 +978,7 @@ var HyveClient = class {
     this.userId = null;
     this.jwtToken = null;
     this.gameId = null;
-    console.log("[Hyve SDK] User logged out");
+    logger.info("User logged out");
   }
   /**
    * Resets the client state
@@ -442,15 +986,50 @@ var HyveClient = class {
   reset() {
     this.logout();
     this.sessionId = generateUUID();
-    console.log("[Hyve SDK] Client reset with new sessionId:", this.sessionId);
+    logger.info("Client reset with new sessionId:", this.sessionId);
+  }
+  /**
+   * Configure ads service
+   * @param config Ads configuration
+   */
+  configureAds(config) {
+    this.adsService.configure(config);
+    logger.info("Ads configuration updated");
+  }
+  /**
+   * Show an ad
+   * @param type Type of ad to show ('rewarded', 'interstitial', or 'preroll')
+   * @returns Promise resolving to ad result
+   */
+  async showAd(type) {
+    return this.adsService.show(type);
+  }
+  /**
+   * Check if ads are enabled
+   * @returns Boolean indicating if ads are enabled
+   */
+  areAdsEnabled() {
+    return this.adsService.isEnabled();
+  }
+  /**
+   * Check if ads are ready to show
+   * @returns Boolean indicating if ads are ready
+   */
+  areAdsReady() {
+    return this.adsService.isReady();
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AdsService,
   HyveClient,
+  Logger,
+  NativeBridge,
+  NativeMessageType,
   generateUUID,
   handleVerifyMessage,
   isDomainAllowed,
+  logger,
   parseUrlParams,
   validateSignature,
   verifyAuthentication,