@hyve-sdk/js 1.1.2 → 1.3.1-canary.0

package/dist/index.js

@@ -21,9 +21,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   HyveClient: () => HyveClient,
+  Logger: () => Logger,
+  NativeBridge: () => NativeBridge,
+  NativeMessageType: () => NativeMessageType,
   generateUUID: () => generateUUID,
   handleVerifyMessage: () => handleVerifyMessage,
   isDomainAllowed: () => isDomainAllowed,
+  logger: () => logger,
   parseUrlParams: () => parseUrlParams,
   validateSignature: () => validateSignature,
   verifyAuthentication: () => verifyAuthentication,
@@ -32,8 +36,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 {
@@ -42,7 +170,8 @@ function parseUrlParams(searchParams) {
     gameStartTab: params.get("game_start_tab") || "",
     hyveToken: params.get("hyve-token") || "",
     platform: params.get("platform") || "",
-    hyveAccess: params.get("hyve-access") || ""
+    hyveAccess: params.get("hyve-access") || "",
+    gameId: params.get("game-id") || ""
   };
 }
 function validateSignature(signature, message) {
@@ -50,7 +179,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;
   }
 }
@@ -77,7 +206,7 @@ function handleVerifyMessage(signature, message) {
     }
     return userAddress;
   } catch (error) {
-    console.error("Error verifying message:", error);
+    logger.error("Error verifying message:", error);
     return false;
   }
 }
@@ -85,7 +214,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
       );
@@ -93,30 +222,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;
   }
 }
@@ -162,11 +291,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;
@@ -184,6 +310,216 @@ 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/core/client.ts
 var HyveClient = class {
   telemetryConfig;
@@ -191,6 +527,7 @@ var HyveClient = class {
   sessionId;
   userId = null;
   jwtToken = null;
+  gameId = null;
   /**
    * Creates a new HyveClient instance
    * @param config Optional telemetry configuration
@@ -207,9 +544,9 @@ 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");
+    logger.info("Client initialized with sessionId:", this.sessionId);
+    logger.info("API Base URL:", this.apiBaseUrl);
+    logger.info("Environment:", this.telemetryConfig.isDev ? "dev" : "prod");
   }
   /**
    * Authenticates a user from URL parameters
@@ -221,7 +558,23 @@ 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;
+        logger.info("Game ID extracted from game-id parameter:", this.gameId);
+      }
+      if (this.jwtToken) {
+        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({
         hyveToken: params.hyveToken,
@@ -230,76 +583,83 @@ 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;
     }
   }
   /**
-   * Sends a telemetry event
+   * Sends a user-level telemetry event using JWT authentication
+   * Requires JWT token, authenticated user, and game ID from URL parameters
    * @param eventLocation Location where the event occurred
    * @param eventCategory Main category of the event
    * @param eventAction Primary action taken
    * @param eventSubCategory Optional sub-category
    * @param eventSubAction Optional sub-action
-   * @param eventDetails Optional event details
-   * @param additionalData Optional additional data
+   * @param eventDetails Optional event details (object or JSON string)
+   * @param customData Optional custom data (object or JSON string)
+   * @param platformId Optional platform identifier
    * @returns Promise resolving to boolean indicating success
    */
-  async sendTelemetry(eventLocation, eventCategory, eventAction, eventSubCategory, eventSubAction, eventDetails, additionalData) {
-    if (!this.telemetryConfig.apiKey) {
-      console.error("[Hyve Telemetry] API key not configured");
+  async sendTelemetry(eventLocation, eventCategory, eventAction, eventSubCategory, eventSubAction, eventDetails, customData, platformId) {
+    if (!this.jwtToken) {
+      logger.error("JWT token required. Call authenticateFromUrl first.");
       return false;
     }
-    if (!this.userId) {
-      console.warn("[Hyve Telemetry] No user ID - sending anonymous telemetry");
+    if (!this.gameId) {
+      logger.error("Game ID required. Ensure game-id URL parameter is set.");
+      return false;
     }
     try {
-      let finalEventDetails = null;
-      if (additionalData && Object.keys(additionalData).length > 0) {
-        finalEventDetails = JSON.stringify(additionalData);
-      } else if (eventDetails) {
-        finalEventDetails = eventDetails;
-      }
+      const toJsonString = (data) => {
+        if (!data) return null;
+        return typeof data === "string" ? data : JSON.stringify(data);
+      };
       const telemetryEvent = {
+        game_id: this.gameId,
         session_id: this.sessionId,
-        hyve_user_id: this.userId || "anonymous",
+        platform_id: platformId || null,
         event_location: eventLocation,
         event_category: eventCategory,
         event_action: eventAction,
         event_sub_category: eventSubCategory || null,
         event_sub_action: eventSubAction || null,
-        event_details: finalEventDetails
+        event_details: toJsonString(eventDetails),
+        custom_data: toJsonString(customData)
       };
-      console.log("[Hyve Telemetry] Sending event:", telemetryEvent);
-      const telemetryUrl = `${this.apiBaseUrl}/api/v1/partners/analytics/events`;
+      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",
-          "X-API-KEY": this.telemetryConfig.apiKey
+          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;
     }
   }
@@ -311,15 +671,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
         }
       });
@@ -329,7 +692,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;
     }
   }
@@ -362,8 +725,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
@@ -386,6 +749,13 @@ var HyveClient = class {
   getJwtToken() {
     return this.jwtToken;
   }
+  /**
+   * Gets the current game ID
+   * @returns Current game ID or null if not available
+   */
+  getGameId() {
+    return this.gameId;
+  }
   /**
    * Gets the API base URL
    * @returns API base URL
@@ -413,7 +783,8 @@ var HyveClient = class {
   logout() {
     this.userId = null;
     this.jwtToken = null;
-    console.log("[Hyve SDK] User logged out");
+    this.gameId = null;
+    logger.info("User logged out");
   }
   /**
    * Resets the client state
@@ -421,15 +792,19 @@ 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);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HyveClient,
+  Logger,
+  NativeBridge,
+  NativeMessageType,
   generateUUID,
   handleVerifyMessage,
   isDomainAllowed,
+  logger,
   parseUrlParams,
   validateSignature,
   verifyAuthentication,