@hyve-sdk/js 1.5.0 → 2.1.0

package/dist/index.js

@@ -18,12 +18,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   AdsService: () => AdsService,
   BillingPlatform: () => BillingPlatform,
   BillingService: () => BillingService,
   CloudStorageAdapter: () => CloudStorageAdapter,
+  CrazyGamesService: () => CrazyGamesService,
   HyveClient: () => HyveClient,
   LocalStorageAdapter: () => LocalStorageAdapter,
   Logger: () => Logger,
@@ -31,15 +32,11 @@ __export(index_exports, {
   NativeMessageType: () => NativeMessageType,
   PlaygamaService: () => PlaygamaService,
   generateUUID: () => generateUUID,
-  handleVerifyMessage: () => handleVerifyMessage,
   isDomainAllowed: () => isDomainAllowed,
   logger: () => logger,
-  parseUrlParams: () => parseUrlParams,
-  validateSignature: () => validateSignature,
-  verifyAuthentication: () => verifyAuthentication,
-  verifyHyveToken: () => verifyHyveToken
+  parseUrlParams: () => parseUrlParams
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/utils/index.ts
 var import_uuid = require("uuid");
@@ -67,7 +64,7 @@ var Logger = class _Logger {
       }
     } else if (typeof window !== "undefined") {
       try {
-        enabled = process.env.NODE_ENV !== "production";
+        enabled = process?.env.NODE_ENV !== "production";
       } catch (e) {
         enabled = true;
       }
@@ -167,136 +164,15 @@ var Logger = class _Logger {
 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 {
-    signature: params.get("signature") || "",
-    message: params.get("message") || "",
     gameStartTab: params.get("game_start_tab") || "",
-    hyveToken: params.get("hyve-token") || "",
     platform: params.get("platform") || "",
     hyveAccess: params.get("hyve-access") || "",
     gameId: params.get("game-id") || ""
   };
 }
-function validateSignature(signature, message) {
-  try {
-    const recoveredAddress = import_ethers.ethers.verifyMessage(message, signature);
-    return !!recoveredAddress;
-  } catch (error) {
-    logger.error("Signature validation error:", error);
-    return false;
-  }
-}
-function handleVerifyMessage(signature, message) {
-  try {
-    const metadata = JSON.parse(decodeURI(message));
-    if (!metadata.expiration || metadata.expiration < Date.now()) {
-      return false;
-    }
-    const userAddress = metadata.userId || metadata.address;
-    if (!userAddress) {
-      return false;
-    }
-    const byteMessage = new TextEncoder().encode(message);
-    const addressThatSignedMessage = import_ethers.ethers.verifyMessage(
-      byteMessage,
-      signature
-    );
-    if (!addressThatSignedMessage) {
-      return false;
-    }
-    if (addressThatSignedMessage.toLowerCase() !== userAddress.toLowerCase()) {
-      return false;
-    }
-    return userAddress;
-  } catch (error) {
-    logger.error("Error verifying message:", error);
-    return false;
-  }
-}
-function verifyHyveToken(hyveToken, maxAgeSec = 600) {
-  try {
-    const parts = hyveToken.split(".");
-    if (parts.length !== 4) {
-      logger.error(
-        "Invalid hyve-token format: expected 4 parts, got",
-        parts.length
-      );
-      return false;
-    }
-    const [signature, address, randomBase64, timestampStr] = parts;
-    if (!signature || !address || !randomBase64 || !timestampStr) {
-      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()) {
-      logger.error("Hyve-token signature verification failed");
-      return false;
-    }
-    const timestamp = parseInt(timestampStr, 10);
-    if (!Number.isFinite(timestamp)) {
-      logger.error("Invalid hyve-token timestamp");
-      return false;
-    }
-    const now = Math.floor(Date.now() / 1e3);
-    if (now - timestamp > maxAgeSec) {
-      logger.error(
-        `Hyve-token expired (age: ${now - timestamp}s, max: ${maxAgeSec}s)`
-      );
-      return false;
-    }
-    return address;
-  } catch (error) {
-    logger.error("Hyve-token verification error:", error);
-    return false;
-  }
-}
-function verifyAuthentication(params, maxAgeSec = 600) {
-  if (params.hyveToken) {
-    const modernAddress = verifyHyveToken(params.hyveToken, maxAgeSec);
-    if (modernAddress) {
-      return {
-        isValid: true,
-        address: modernAddress,
-        method: "modern"
-      };
-    } else {
-      return {
-        isValid: false,
-        address: null,
-        method: "modern",
-        error: "Modern token verification failed"
-      };
-    }
-  }
-  if (params.signature && params.message) {
-    const legacyAddress = handleVerifyMessage(params.signature, params.message);
-    if (legacyAddress) {
-      return {
-        isValid: true,
-        address: legacyAddress,
-        method: "legacy"
-      };
-    } else {
-      return {
-        isValid: false,
-        address: null,
-        method: "legacy",
-        error: "Legacy token verification failed"
-      };
-    }
-  }
-  return {
-    isValid: false,
-    address: null,
-    method: "none",
-    error: "No authentication tokens provided"
-  };
-}
 function isDomainAllowed(allowedDomains, hostname) {
   logger.debug("Checking hostname:", hostname);
   if (!allowedDomains) return true;
@@ -337,9 +213,7 @@ var NativeBridge = class {
    * Checks if the app is running inside a React Native WebView
    */
   static isNativeContext() {
-    const isNative = typeof window !== "undefined" && "ReactNativeWebView" in window;
-    console.log(`[NativeBridge] isNativeContext check: ${isNative}`);
-    return isNative;
+    return typeof window !== "undefined" && "ReactNativeWebView" in window;
   }
   /**
    * Initializes the native bridge message listener
@@ -348,55 +222,37 @@ var NativeBridge = class {
   static initialize() {
     if (this.isInitialized) {
       logger.debug("[NativeBridge] Already initialized");
-      console.log("[NativeBridge] \u26A0 Already initialized, skipping");
       return;
     }
     if (typeof window === "undefined") {
       logger.warn("[NativeBridge] Window not available, skipping initialization");
-      console.warn("[NativeBridge] \u26A0 Window not available, skipping initialization");
       return;
     }
-    const isInIframe = window !== window.parent;
-    console.log("[NativeBridge] ========== INITIALIZING ==========");
-    console.log(`[NativeBridge] Running in iframe: ${isInIframe}`);
-    console.log("[NativeBridge] Setting up message listeners on window and document");
     const boundHandler = this.handleNativeMessage.bind(this);
     window.addEventListener("message", boundHandler);
     document.addEventListener("message", boundHandler);
-    if (isInIframe) {
-      console.log("[NativeBridge] Setting up parent window message listener for iframe context");
-    }
     this.isInitialized = true;
-    console.log("[NativeBridge] \u2713 Event listeners attached to window and document");
-    console.log("[NativeBridge] \u2713 Initialized and ready to receive messages");
     logger.info("[NativeBridge] Initialized and listening for native messages");
   }
   /**
    * Handles incoming messages from React Native
    */
   static handleNativeMessage(event) {
-    console.log("[NativeBridge] [HANDLER] handleNativeMessage called");
-    console.log("[NativeBridge] [HANDLER] Event source:", event.source === window ? "window" : "other");
-    console.log("[NativeBridge] [HANDLER] Event data:", event.data);
     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);
+        } catch {
+          logger.debug("[NativeBridge] Ignoring non-JSON message");
           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");
+      if (!data?.type) {
         return;
       }
       const nativeResponseTypes = [
@@ -408,22 +264,16 @@ var NativeBridge = class {
         "PURCHASE_ERROR" /* PURCHASE_ERROR */
       ];
       if (!nativeResponseTypes.includes(data.type)) {
-        logger.debug(`[NativeBridge] Ignoring non-native-response message: ${data.type}`);
         return;
       }
-      console.log("[NativeBridge] [HANDLER] Message type:", data.type);
       const handler = this.handlers.get(data.type);
       if (handler) {
-        console.log(`[NativeBridge] [HANDLER] \u2713 Found handler for: ${data.type}`);
-        logger.info(`[NativeBridge] Handling message: ${data.type}`, data.payload);
+        logger.debug(`[NativeBridge] Handling message: ${data.type}`);
         handler(data.payload);
-        console.log(`[NativeBridge] [HANDLER] \u2713 Handler completed for: ${data.type}`);
       } else {
-        console.warn(`[NativeBridge] [HANDLER] \u26A0 No handler registered for: ${data.type}`);
         logger.warn(`[NativeBridge] No handler registered for: ${data.type}`);
       }
     } catch (error) {
-      console.error("[NativeBridge] [HANDLER] \u274C Error handling native message:", error);
       logger.error("[NativeBridge] Error handling native message:", error);
     }
   }
@@ -433,27 +283,15 @@ var NativeBridge = class {
    * @param payload Optional payload data
    */
   static send(type, payload) {
-    console.log(`[NativeBridge] [SEND] Attempting to send message: ${type}`);
     if (!this.isNativeContext()) {
-      console.log(`[NativeBridge] [SEND] \u274C Not in native context, skipping message: ${type}`);
-      logger.debug(
-        `[NativeBridge] Not in native context, skipping message: ${type}`
-      );
+      logger.debug(`[NativeBridge] Not in native context, skipping message: ${type}`);
       return;
     }
-    console.log(`[NativeBridge] [SEND] \u2713 In native context, sending message`);
     try {
-      const message = {
-        type,
-        payload,
-        timestamp: Date.now()
-      };
-      console.log(`[NativeBridge] [SEND] Message object:`, message);
+      const message = { type, payload, timestamp: Date.now() };
       window.ReactNativeWebView.postMessage(JSON.stringify(message));
-      console.log(`[NativeBridge] [SEND] \u2713 Message sent to native: ${type}`);
       logger.debug(`[NativeBridge] Sent message to native: ${type}`, payload);
     } catch (error) {
-      console.error(`[NativeBridge] [SEND] \u274C\u274C Error sending message to native:`, error);
       logger.error(`[NativeBridge] Error sending message to native:`, error);
     }
   }
@@ -463,10 +301,7 @@ var NativeBridge = class {
    * @param handler Function to call when message is received
    */
   static on(type, handler) {
-    console.log(`[NativeBridge] [ON] Registering handler for: ${type}`);
     this.handlers.set(type, handler);
-    console.log(`[NativeBridge] [ON] \u2713 Handler registered. Total handlers:`, this.handlers.size);
-    console.log(`[NativeBridge] [ON] All registered types:`, Array.from(this.handlers.keys()));
     logger.debug(`[NativeBridge] Registered handler for: ${type}`);
   }
   /**
@@ -616,7 +451,6 @@ function generateUUID() {
 // src/services/ads.ts
 var AdsService = class {
   config = {
-    enabled: false,
     sound: "on",
     debug: false,
     onBeforeAd: () => {
@@ -626,87 +460,69 @@ var AdsService = class {
     onRewardEarned: () => {
     }
   };
-  initialized = false;
+  // Cached init promise — ensures adConfig() is only called once
+  initPromise = null;
   ready = false;
   /**
-   * Configure the ads service
-   * Must set enabled: true to activate ads
+   * Optionally configure the ads service.
+   * Not required — ads work without calling this.
    */
   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
+      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();
+      logger.debug("[AdsService] Configuration updated:", { sound: this.config.sound });
     }
   }
   /**
-   * Initialize the ads system
+   * Initialize the Google H5 Ads system.
+   * Returns a cached promise — safe to call multiple times.
    */
   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.initPromise) return this.initPromise;
+    this.initPromise = new Promise((resolve) => {
+      if (!window.adConfig || !window.adBreak) {
         if (this.config.debug) {
-          console.log("[AdsService] Ads ready");
+          logger.debug("[AdsService] Google Ads SDK not found \u2014 ads unavailable");
         }
+        resolve(false);
+        return;
       }
-    };
-    window.adConfig(googleConfig);
-    this.initialized = true;
+      if (this.config.debug) {
+        logger.debug("[AdsService] Initializing ads system...");
+      }
+      window.adConfig({
+        sound: this.config.sound,
+        preloadAdBreaks: "on",
+        onReady: () => {
+          this.ready = true;
+          if (this.config.debug) {
+            logger.debug("[AdsService] Ads ready");
+          }
+          resolve(true);
+        }
+      });
+      setTimeout(() => resolve(false), 5e3);
+    });
+    return this.initPromise;
   }
   /**
-   * Show an ad
-   * Returns immediately if ads are disabled
+   * Show an ad. Auto-initializes on the first call.
+   * Returns immediately with success: false if ads are disabled or unavailable.
    */
   async show(type) {
     const requestedAt = Date.now();
-    if (!this.config.enabled) {
-      if (this.config.debug) {
-        console.log("[AdsService] Ads disabled, skipping ad request");
-      }
+    const ready = await this.initialize();
+    if (!ready || !window.adBreak) {
       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"),
+        error: new Error("Ads not available"),
         requestedAt,
         completedAt: Date.now()
       };
@@ -714,7 +530,7 @@ var AdsService = class {
     return this.showAdBreak(type);
   }
   /**
-   * Show an ad break
+   * Show an ad break via the Google H5 API.
    */
   async showAdBreak(type) {
     const requestedAt = Date.now();
@@ -722,81 +538,48 @@ var AdsService = class {
       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`);
+        logger.debug(`[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 success = type === "rewarded" ? info?.breakStatus === "viewed" : 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
-            });
+            logger.debug("[AdsService] Ad break done:", { success, status: info?.breakStatus });
           }
-          const result = {
-            success,
-            type,
-            error,
-            requestedAt,
-            completedAt
-          };
-          resolve(result);
+          resolve({ success, type, error, requestedAt, completedAt });
         }
       };
       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");
-          }
-        };
+        adBreakConfig.beforeReward = (showAdFn) => showAdFn();
+        adBreakConfig.adViewed = () => this.config.onRewardEarned();
       }
       window.adBreak(adBreakConfig);
     });
   }
   /**
-   * Check if ads are enabled
+   * Returns the configured ad lifecycle callbacks.
+   * Used by platform-specific providers (e.g. Playgama) to fire the same hooks.
    */
-  isEnabled() {
-    return this.config.enabled;
+  getCallbacks() {
+    return {
+      onBeforeAd: this.config.onBeforeAd,
+      onAfterAd: this.config.onAfterAd,
+      onRewardEarned: this.config.onRewardEarned
+    };
   }
   /**
-   * Check if ads are ready to show
+   * Check if ads have successfully initialized and are ready to show.
    */
   isReady() {
-    return this.config.enabled && this.ready;
+    return this.ready;
   }
 };
 
@@ -843,16 +626,17 @@ var PlaygamaService = class {
       this.initialized = true;
       return true;
     } catch (error) {
-      console.warn("[PlaygamaService] Failed to initialize:", error);
+      logger.warn("[PlaygamaService] Failed to initialize:", error);
       return false;
     }
   }
   isInitialized() {
     return this.initialized;
   }
-  async showInterstitial() {
+  async showInterstitial(callbacks) {
     const requestedAt = Date.now();
-    if (!this.initialized || !window.bridge) {
+    const bridge = window.bridge;
+    if (!this.initialized || !bridge) {
       return {
         success: false,
         type: "interstitial",
@@ -861,13 +645,26 @@ var PlaygamaService = class {
         completedAt: Date.now()
       };
     }
+    if (!bridge.advertisement.isInterstitialSupported) {
+      return {
+        success: false,
+        type: "interstitial",
+        error: new Error("Interstitial ads not supported on this platform"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
     return new Promise((resolve) => {
       const handler = (state) => {
-        if (state === "closed") {
-          window.bridge.advertisement.off("interstitial_state_changed", handler);
+        if (state === "opened") {
+          callbacks?.onBeforeAd?.();
+        } else if (state === "closed") {
+          bridge.advertisement.off(bridge.EVENT_NAME.INTERSTITIAL_STATE_CHANGED, handler);
+          callbacks?.onAfterAd?.();
           resolve({ success: true, type: "interstitial", requestedAt, completedAt: Date.now() });
         } else if (state === "failed") {
-          window.bridge.advertisement.off("interstitial_state_changed", handler);
+          bridge.advertisement.off(bridge.EVENT_NAME.INTERSTITIAL_STATE_CHANGED, handler);
+          callbacks?.onAfterAd?.();
           resolve({
             success: false,
             type: "interstitial",
@@ -877,13 +674,14 @@ var PlaygamaService = class {
           });
         }
       };
-      window.bridge.advertisement.on("interstitial_state_changed", handler);
-      window.bridge.advertisement.showInterstitial();
+      bridge.advertisement.on(bridge.EVENT_NAME.INTERSTITIAL_STATE_CHANGED, handler);
+      bridge.advertisement.showInterstitial();
     });
   }
-  async showRewarded() {
+  async showRewarded(callbacks) {
     const requestedAt = Date.now();
-    if (!this.initialized || !window.bridge) {
+    const bridge = window.bridge;
+    if (!this.initialized || !bridge) {
       return {
         success: false,
         type: "rewarded",
@@ -892,13 +690,26 @@ var PlaygamaService = class {
         completedAt: Date.now()
       };
     }
+    if (!bridge.advertisement.isRewardedSupported) {
+      return {
+        success: false,
+        type: "rewarded",
+        error: new Error("Rewarded ads not supported on this platform"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
     return new Promise((resolve) => {
       let rewarded = false;
       const handler = (state) => {
-        if (state === "rewarded") {
+        if (state === "opened") {
+          callbacks?.onBeforeAd?.();
+        } else if (state === "rewarded") {
           rewarded = true;
+          callbacks?.onRewardEarned?.();
         } else if (state === "closed" || state === "failed") {
-          window.bridge.advertisement.off("rewarded_state_changed", handler);
+          bridge.advertisement.off(bridge.EVENT_NAME.REWARDED_STATE_CHANGED, handler);
+          callbacks?.onAfterAd?.();
           resolve({
             success: rewarded,
             type: "rewarded",
@@ -908,8 +719,8 @@ var PlaygamaService = class {
           });
         }
       };
-      window.bridge.advertisement.on("rewarded_state_changed", handler);
-      window.bridge.advertisement.showRewarded();
+      bridge.advertisement.on(bridge.EVENT_NAME.REWARDED_STATE_CHANGED, handler);
+      bridge.advertisement.showRewarded();
     });
   }
   loadScript() {
@@ -927,6 +738,176 @@ var PlaygamaService = class {
   }
 };
 
+// src/services/crazygames.ts
+var CRAZYGAMES_SDK_CDN = "https://sdk.crazygames.com/crazygames-sdk-v2.js";
+var CrazyGamesService = class {
+  initialized = false;
+  /**
+   * Detects if the game is running on the CrazyGames platform.
+   * Games on CrazyGames run inside an iframe, so we check document.referrer
+   * and attempt to read the parent frame location.
+   */
+  static isCrazyGamesDomain() {
+    try {
+      if (document.referrer.includes("crazygames.com")) {
+        return true;
+      }
+      if (window !== window.top) {
+        try {
+          if (window.parent.location.hostname.includes("crazygames.com")) {
+            return true;
+          }
+        } catch {
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Loads the CrazyGames SDK from CDN and confirms the environment is 'crazygames'.
+   * Safe to call multiple times — resolves immediately if already initialized.
+   */
+  async initialize() {
+    if (this.initialized) return true;
+    try {
+      await this.loadScript();
+      const sdk = window.CrazyGames?.SDK;
+      if (!sdk) {
+        logger.warn("[CrazyGamesService] SDK not found after script load");
+        return false;
+      }
+      const env = await sdk.getEnvironment();
+      if (env !== "crazygames" && env !== "local") {
+        logger.warn("[CrazyGamesService] Unexpected environment:", env);
+        return false;
+      }
+      this.initialized = true;
+      return true;
+    } catch (error) {
+      logger.warn("[CrazyGamesService] Failed to initialize:", error);
+      return false;
+    }
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Shows a midgame (interstitial) ad via the CrazyGames SDK.
+   */
+  async showInterstitial(callbacks) {
+    const requestedAt = Date.now();
+    const sdk = window.CrazyGames?.SDK;
+    if (!this.initialized || !sdk) {
+      return {
+        success: false,
+        type: "interstitial",
+        error: new Error("CrazyGames SDK not initialized"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    return new Promise((resolve) => {
+      sdk.ad.requestAd("midgame", {
+        adStarted: () => {
+          callbacks?.onBeforeAd?.();
+        },
+        adFinished: () => {
+          callbacks?.onAfterAd?.();
+          resolve({ success: true, type: "interstitial", requestedAt, completedAt: Date.now() });
+        },
+        adError: (error) => {
+          callbacks?.onAfterAd?.();
+          resolve({
+            success: false,
+            type: "interstitial",
+            error: new Error(`CrazyGames interstitial ad error: ${error}`),
+            requestedAt,
+            completedAt: Date.now()
+          });
+        }
+      });
+    });
+  }
+  /**
+   * Shows a rewarded ad via the CrazyGames SDK.
+   * Resolves with success: true only when adFinished fires (ad was fully watched).
+   */
+  async showRewarded(callbacks) {
+    const requestedAt = Date.now();
+    const sdk = window.CrazyGames?.SDK;
+    if (!this.initialized || !sdk) {
+      return {
+        success: false,
+        type: "rewarded",
+        error: new Error("CrazyGames SDK not initialized"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    return new Promise((resolve) => {
+      sdk.ad.requestAd("rewarded", {
+        adStarted: () => {
+          callbacks?.onBeforeAd?.();
+        },
+        adFinished: () => {
+          callbacks?.onRewardEarned?.();
+          callbacks?.onAfterAd?.();
+          resolve({ success: true, type: "rewarded", requestedAt, completedAt: Date.now() });
+        },
+        adError: (error) => {
+          callbacks?.onAfterAd?.();
+          resolve({
+            success: false,
+            type: "rewarded",
+            error: new Error(`CrazyGames rewarded ad error: ${error}`),
+            requestedAt,
+            completedAt: Date.now()
+          });
+        }
+      });
+    });
+  }
+  /**
+   * Notifies CrazyGames that gameplay has started.
+   * Call when the player actively begins or resumes playing.
+   */
+  gameplayStart() {
+    if (!this.initialized) return;
+    window.CrazyGames?.SDK.game.gameplayStart();
+  }
+  /**
+   * Notifies CrazyGames that gameplay has stopped.
+   * Call during menu access, level completion, or pausing.
+   */
+  gameplayStop() {
+    if (!this.initialized) return;
+    window.CrazyGames?.SDK.game.gameplayStop();
+  }
+  /**
+   * Triggers a celebration effect on the CrazyGames website.
+   * Use sparingly for significant achievements (boss defeat, personal record, etc.)
+   */
+  happytime() {
+    if (!this.initialized) return;
+    window.CrazyGames?.SDK.game.happytime();
+  }
+  loadScript() {
+    return new Promise((resolve, reject) => {
+      if (window.CrazyGames?.SDK) {
+        resolve();
+        return;
+      }
+      const script = document.createElement("script");
+      script.src = CRAZYGAMES_SDK_CDN;
+      script.onload = () => resolve();
+      script.onerror = () => reject(new Error("Failed to load CrazyGames SDK script"));
+      document.head.appendChild(script);
+    });
+  }
+};
+
 // src/services/billing.ts
 var BillingPlatform = /* @__PURE__ */ ((BillingPlatform3) => {
   BillingPlatform3["WEB"] = "web";
@@ -937,41 +918,28 @@ var BillingPlatform = /* @__PURE__ */ ((BillingPlatform3) => {
 var BillingService = class {
   config;
   platform = "unknown" /* UNKNOWN */;
-  isInitialized = false;
+  initPromise = null;
   nativeAvailable = false;
-  products = [];
   // Stripe instance for web payments
   stripe = null;
   checkoutElement = null;
   // Callbacks for purchase events
   onPurchaseCompleteCallback;
   onPurchaseErrorCallback;
-  // Callback for logging (so external UI can capture logs)
-  onLogCallback;
   constructor(config) {
     this.config = config;
     this.detectPlatform();
   }
   /**
-   * Register a callback to receive all internal logs
-   * Useful for displaying logs in a UI
-   */
-  onLog(callback) {
-    this.onLogCallback = callback;
-  }
-  /**
-   * Internal logging method that calls both logger and custom callback
+   * Update billing configuration. Resets initialization so next call re-inits with new config.
    */
-  log(level, message, data) {
-    const consoleMethod = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
-    if (data !== void 0) {
-      consoleMethod(message, data);
-    } else {
-      consoleMethod(message);
-    }
-    if (this.onLogCallback) {
-      this.onLogCallback(level, message, data);
-    }
+  configure(config) {
+    this.config = {
+      ...this.config,
+      ...config
+    };
+    this.initPromise = null;
+    logger.info("[BillingService] Configuration updated");
   }
   /**
    * Detects if running on web or native platform
@@ -981,13 +949,13 @@ var BillingService = class {
     const hasWindow = typeof window !== "undefined";
     if (isNative) {
       this.platform = "native" /* NATIVE */;
-      this.log("info", "[BillingService] Platform: NATIVE");
+      logger.info("[BillingService] Platform: NATIVE");
     } else if (hasWindow) {
       this.platform = "web" /* WEB */;
-      this.log("info", "[BillingService] Platform: WEB");
+      logger.info("[BillingService] Platform: WEB");
     } else {
       this.platform = "unknown" /* UNKNOWN */;
-      this.log("warn", "[BillingService] Platform: UNKNOWN");
+      logger.warn("[BillingService] Platform: UNKNOWN");
     }
   }
   /**
@@ -997,38 +965,40 @@ var BillingService = class {
     return this.platform;
   }
   /**
-   * Initialize the billing service
-   * Must be called before using any other methods
+   * Initialize the billing service. Idempotent — returns cached promise on subsequent calls.
+   * Called automatically by getProducts() and purchase().
    */
-  async initialize() {
-    if (this.isInitialized) {
-      return true;
-    }
-    this.log("info", `[BillingService] Initializing for ${this.platform} platform...`);
-    try {
-      if (this.platform === "native" /* NATIVE */) {
-        return await this.initializeNative();
-      } else if (this.platform === "web" /* WEB */) {
-        return await this.initializeWeb();
+  initialize() {
+    if (this.initPromise) return this.initPromise;
+    logger.info(`[BillingService] Initializing for ${this.platform} platform...`);
+    this.initPromise = (async () => {
+      try {
+        if (this.platform === "native" /* NATIVE */) {
+          return await this.initializeNative();
+        } else if (this.platform === "web" /* WEB */) {
+          return await this.initializeWeb();
+        }
+        logger.error("[BillingService] Cannot initialize: unknown platform");
+        return false;
+      } catch (error) {
+        logger.error("[BillingService] Initialization failed:", error?.message);
+        return false;
       }
-      this.log("error", "[BillingService] Cannot initialize: unknown platform");
-      return false;
-    } catch (error) {
-      this.log("error", "[BillingService] Initialization failed:", error?.message);
-      return false;
-    }
+    })();
+    return this.initPromise;
   }
   /**
    * Initialize native billing
    */
   async initializeNative() {
     return new Promise((resolve) => {
+      let resolved = false;
       try {
         NativeBridge.initialize();
         NativeBridge.on(
           "PURCHASE_COMPLETE" /* PURCHASE_COMPLETE */,
           (payload) => {
-            this.log("info", "[BillingService] Purchase complete:", payload.productId);
+            logger.info("[BillingService] Purchase complete:", payload.productId);
             const result = {
               success: true,
               productId: payload.productId,
@@ -1043,7 +1013,7 @@ var BillingService = class {
         NativeBridge.on(
           "PURCHASE_ERROR" /* PURCHASE_ERROR */,
           (payload) => {
-            this.log("error", "[BillingService] Purchase error:", payload.message);
+            logger.error("[BillingService] Purchase error:", payload.message);
             const result = {
               success: false,
               productId: payload.productId || "unknown",
@@ -1061,8 +1031,8 @@ var BillingService = class {
           "IAP_AVAILABILITY_RESULT" /* IAP_AVAILABILITY_RESULT */,
           (payload) => {
             this.nativeAvailable = payload.available;
-            this.isInitialized = true;
-            this.log("info", `[BillingService] Native billing ${payload.available ? "available" : "unavailable"}`);
+            logger.info(`[BillingService] Native billing ${payload.available ? "available" : "unavailable"}`);
+            resolved = true;
             resolve(payload.available);
           }
         );
@@ -1070,15 +1040,15 @@ var BillingService = class {
           NativeBridge.checkIAPAvailability();
         }, 100);
         setTimeout(() => {
-          if (!this.isInitialized) {
-            this.log("warn", "[BillingService] Native initialization timeout");
-            this.isInitialized = true;
+          if (!resolved) {
+            logger.warn("[BillingService] Native initialization timeout");
+            resolved = true;
             resolve(false);
           }
         }, 5e3);
       } catch (error) {
-        this.log("error", "[BillingService] Native initialization failed:", error?.message);
-        this.isInitialized = true;
+        logger.error("[BillingService] Native initialization failed:", error?.message);
+        resolved = true;
         resolve(false);
       }
     });
@@ -1088,12 +1058,12 @@ var BillingService = class {
    */
   async initializeWeb() {
     if (!this.config.stripePublishableKey) {
-      this.log("error", "[BillingService] Stripe publishable key not provided");
+      logger.error("[BillingService] Stripe publishable key not provided");
       return false;
     }
     try {
       if (typeof window === "undefined") {
-        this.log("error", "[BillingService] Window is undefined (not in browser)");
+        logger.error("[BillingService] Window is undefined (not in browser)");
         return false;
       }
       if (!window.Stripe) {
@@ -1101,15 +1071,14 @@ var BillingService = class {
       }
       if (window.Stripe) {
         this.stripe = window.Stripe(this.config.stripePublishableKey);
-        this.isInitialized = true;
-        this.log("info", "[BillingService] Web billing initialized");
+        logger.info("[BillingService] Web billing initialized");
         return true;
       } else {
-        this.log("error", "[BillingService] Stripe not available after loading");
+        logger.error("[BillingService] Stripe not available after loading");
         return false;
       }
     } catch (error) {
-      this.log("error", "[BillingService] Stripe initialization failed:", error?.message);
+      logger.error("[BillingService] Stripe initialization failed:", error?.message);
       return false;
     }
   }
@@ -1134,11 +1103,11 @@ var BillingService = class {
       script.src = "https://js.stripe.com/v3/";
       script.async = true;
       script.onload = () => {
-        this.log("info", "[BillingService] Stripe.js loaded");
+        logger.info("[BillingService] Stripe.js loaded");
         resolve();
       };
       script.onerror = () => {
-        this.log("error", "[BillingService] Failed to load Stripe.js");
+        logger.error("[BillingService] Failed to load Stripe.js");
         reject(new Error("Failed to load Stripe.js"));
       };
       try {
@@ -1149,12 +1118,9 @@ var BillingService = class {
     });
   }
   /**
-   * Check if billing is available
+   * Check if billing is available based on current config and platform state
    */
   isAvailable() {
-    if (!this.isInitialized) {
-      return false;
-    }
     if (this.platform === "native" /* NATIVE */) {
       return this.nativeAvailable;
     } else if (this.platform === "web" /* WEB */) {
@@ -1163,12 +1129,10 @@ var BillingService = class {
     return false;
   }
   /**
-   * Get available products
+   * Get available products. Auto-initializes on first call.
    */
   async getProducts() {
-    if (!this.isInitialized) {
-      throw new Error("BillingService not initialized. Call initialize() first.");
-    }
+    await this.initialize();
     if (this.platform === "native" /* NATIVE */) {
       return await this.getProductsNative();
     } else if (this.platform === "web" /* WEB */) {
@@ -1180,38 +1144,31 @@ var BillingService = class {
    * Get products from native IAP
    */
   async getProductsNative() {
-    return new Promise((resolve, reject) => {
-      if (!this.config.gameId || !this.config.checkoutUrl) {
-        const error = new Error("gameId and checkoutUrl required for native purchases");
-        this.log("error", "[BillingService]", error.message);
-        reject(error);
-        return;
-      }
-      const url = `${this.config.checkoutUrl}/get-native-packages?game_id=${this.config.gameId}`;
-      fetch(url).then((response) => {
-        if (!response.ok) {
-          throw new Error(`Failed to fetch native products: ${response.status}`);
-        }
-        return response.json();
-      }).then((data) => {
-        if (!data.packages || !Array.isArray(data.packages)) {
-          throw new Error("Invalid response format: missing packages array");
-        }
-        this.products = data.packages.map((pkg) => ({
-          productId: pkg.productId,
-          title: pkg.package_name,
-          description: `${pkg.game_name} - ${pkg.package_name}`,
-          price: pkg.price_cents / 100,
-          localizedPrice: pkg.price_display,
-          currency: "USD"
-        }));
-        this.log("info", `[BillingService] Fetched ${this.products.length} native products`);
-        resolve(this.products);
-      }).catch((error) => {
-        this.log("error", "[BillingService] Failed to fetch native products:", error?.message);
-        reject(error);
-      });
-    });
+    if (!this.config.gameId || !this.config.checkoutUrl) {
+      const error = new Error("gameId and checkoutUrl required for native purchases");
+      logger.error("[BillingService]", error.message);
+      throw error;
+    }
+    const response = await fetch(
+      `${this.config.checkoutUrl}/get-native-packages?game_id=${this.config.gameId}`
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch native products: ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data.packages || !Array.isArray(data.packages)) {
+      throw new Error("Invalid response format: missing packages array");
+    }
+    const products = data.packages.map((pkg) => ({
+      productId: pkg.productId,
+      title: pkg.package_name,
+      description: `${pkg.game_name} - ${pkg.package_name}`,
+      price: pkg.price_cents / 100,
+      localizedPrice: pkg.price_display,
+      currency: "USD"
+    }));
+    logger.info(`[BillingService] Fetched ${products.length} native products`);
+    return products;
   }
   /**
    * Get products from web API (Stripe)
@@ -1219,7 +1176,7 @@ var BillingService = class {
   async getProductsWeb() {
     if (!this.config.checkoutUrl || !this.config.gameId) {
       const error = new Error("checkoutUrl and gameId required for web purchases");
-      this.log("error", "[BillingService]", error.message);
+      logger.error("[BillingService]", error.message);
       throw error;
     }
     try {
@@ -1232,7 +1189,7 @@ var BillingService = class {
       if (!data.packages || !Array.isArray(data.packages)) {
         throw new Error("Invalid response format: missing packages array");
       }
-      this.products = data.packages.map((pkg) => ({
+      const products = data.packages.map((pkg) => ({
         productId: pkg.priceId || pkg.productId,
         // Prefer priceId for Stripe
         title: pkg.package_name,
@@ -1241,23 +1198,21 @@ var BillingService = class {
         localizedPrice: pkg.price_display,
         currency: "USD"
       }));
-      this.log("info", `[BillingService] Fetched ${this.products.length} web products`);
-      return this.products;
+      logger.info(`[BillingService] Fetched ${products.length} web products`);
+      return products;
     } catch (error) {
-      this.log("error", "[BillingService] Failed to fetch web products:", error?.message);
+      logger.error("[BillingService] Failed to fetch web products:", error?.message);
       throw error;
     }
   }
   /**
-   * Purchase a product
+   * Purchase a product. Auto-initializes on first call.
    * @param productId - The product ID (priceId for web/Stripe, productId for native)
    * @param options - Optional purchase options
    * @param options.elementId - For web: DOM element ID to mount Stripe checkout (default: 'stripe-checkout-element')
    */
   async purchase(productId, options) {
-    if (!this.isInitialized) {
-      throw new Error("BillingService not initialized. Call initialize() first.");
-    }
+    await this.initialize();
     if (!this.isAvailable()) {
       throw new Error("Billing is not available on this platform");
     }
@@ -1277,7 +1232,7 @@ var BillingService = class {
         reject(new Error("userId is required for native purchases"));
         return;
       }
-      this.log("info", `[BillingService] Purchasing: ${productId}`);
+      logger.info(`[BillingService] Purchasing: ${productId}`);
       const previousCompleteCallback = this.onPurchaseCompleteCallback;
       const previousErrorCallback = this.onPurchaseErrorCallback;
       const cleanup = () => {
@@ -1351,14 +1306,14 @@ var BillingService = class {
         throw new Error("No client_secret returned from checkout session");
       }
       await this.mountCheckoutElement(client_secret, elementId || "stripe-checkout-element");
-      this.log("info", `[BillingService] Checkout session created: ${id}`);
+      logger.info(`[BillingService] Checkout session created: ${id}`);
       return {
         success: true,
         productId,
         transactionId: id
       };
     } catch (error) {
-      this.log("error", "[BillingService] Web purchase failed:", error?.message);
+      logger.error("[BillingService] Web purchase failed:", error?.message);
       return {
         success: false,
         productId,
@@ -1380,7 +1335,7 @@ var BillingService = class {
     }
     try {
       if (this.checkoutElement) {
-        this.log("info", "[BillingService] Unmounting existing checkout element");
+        logger.info("[BillingService] Unmounting existing checkout element");
         this.unmountCheckoutElement();
         await new Promise((resolve) => setTimeout(resolve, 100));
       }
@@ -1389,15 +1344,15 @@ var BillingService = class {
         throw new Error(`Element with id "${elementId}" not found in the DOM`);
       }
       container.innerHTML = "";
-      this.log("info", "[BillingService] Creating new checkout instance");
+      logger.info("[BillingService] Creating new checkout instance");
       this.checkoutElement = await this.stripe.initEmbeddedCheckout({
         clientSecret
       });
-      this.log("info", "[BillingService] Mounting checkout element to DOM");
+      logger.info("[BillingService] Mounting checkout element to DOM");
       this.checkoutElement.mount(`#${elementId}`);
       this.setupCheckoutEventListeners();
     } catch (error) {
-      this.log("error", "[BillingService] Failed to mount checkout:", error?.message);
+      logger.error("[BillingService] Failed to mount checkout:", error?.message);
       throw error;
     }
   }
@@ -1418,7 +1373,7 @@ var BillingService = class {
             transactionId: sessionId || void 0
           });
         }
-        this.log("info", "[BillingService] Payment completed");
+        logger.info("[BillingService] Payment completed");
         urlParams.delete("payment");
         urlParams.delete("session_id");
         const newUrl = `${window.location.pathname}${urlParams.toString() ? "?" + urlParams.toString() : ""}`;
@@ -1437,7 +1392,7 @@ var BillingService = class {
           this.checkoutElement.destroy();
         }
       } catch (error) {
-        this.log("warn", "[BillingService] Error unmounting checkout element:", error?.message);
+        logger.warn("[BillingService] Error unmounting checkout element:", error?.message);
       }
       this.checkoutElement = null;
     }
@@ -1465,9 +1420,8 @@ var BillingService = class {
       NativeBridge.off("PURCHASE_ERROR" /* PURCHASE_ERROR */);
     }
     this.unmountCheckoutElement();
-    this.isInitialized = false;
+    this.initPromise = null;
     this.nativeAvailable = false;
-    this.products = [];
     this.stripe = null;
     this.onPurchaseCompleteCallback = void 0;
     this.onPurchaseErrorCallback = void 0;
@@ -1639,10 +1593,10 @@ var HyveClient = class {
   gameId = null;
   adsService;
   playgamaService = null;
+  playgamaInitPromise = null;
+  crazyGamesService = null;
+  crazyGamesInitPromise = null;
   billingService;
-  billingConfig;
-  // Store callbacks to preserve them when recreating BillingService
-  billingCallbacks = {};
   storageMode;
   cloudStorageAdapter;
   localStorageAdapter;
@@ -1668,17 +1622,33 @@ var HyveClient = class {
     }
     if (typeof window !== "undefined" && PlaygamaService.isPlaygamaDomain()) {
       this.playgamaService = new PlaygamaService();
-      this.playgamaService.initialize().then((success) => {
+      this.playgamaInitPromise = this.playgamaService.initialize().then((success) => {
         logger.info("Playgama Bridge initialized:", success);
+        return success;
+      });
+    }
+    if (typeof window !== "undefined" && CrazyGamesService.isCrazyGamesDomain()) {
+      this.crazyGamesService = new CrazyGamesService();
+      this.crazyGamesInitPromise = this.crazyGamesService.initialize().then((success) => {
+        logger.info("CrazyGames SDK initialized:", success);
+        return success;
       });
     }
-    this.billingConfig = config?.billing || {};
-    this.billingService = new BillingService(this.billingConfig);
     this.storageMode = config?.storageMode || "cloud";
     this.cloudStorageAdapter = new CloudStorageAdapter(
       (endpoint, options) => this.callApi(endpoint, options)
     );
     this.localStorageAdapter = new LocalStorageAdapter(() => this.getUserId());
+    if (typeof window !== "undefined") {
+      this._parseUrlAuth();
+    }
+    const billingConfig = {
+      checkoutUrl: this.apiBaseUrl,
+      userId: this.userId ?? void 0,
+      gameId: this.gameId ? Number(this.gameId) : void 0,
+      ...config?.billing
+    };
+    this.billingService = new BillingService(billingConfig);
     const envSource = config?.isDev !== void 0 ? "explicit config" : "auto-detected from parent URL";
     logger.info("==========================================");
     logger.info("HyveClient Initialized");
@@ -1690,28 +1660,27 @@ var HyveClient = class {
       `(${envSource})`
     );
     logger.info("API Base URL:", this.apiBaseUrl);
-    logger.info("Ads enabled:", this.adsService.isEnabled());
     logger.info("Playgama platform:", this.playgamaService !== null);
+    logger.info("CrazyGames platform:", this.crazyGamesService !== null);
     logger.info(
       "Billing configured:",
-      Object.keys(this.billingConfig).length > 0
+      !!config?.billing && Object.keys(config.billing).length > 0
     );
     logger.info("Storage mode:", this.storageMode);
+    logger.info("Authenticated:", this.jwtToken !== null);
     logger.debug("Config:", {
       isDev: this.telemetryConfig.isDev,
       hasCustomApiUrl: !!config?.apiBaseUrl,
-      adsEnabled: config?.ads?.enabled || false,
-      billingConfigured: Object.keys(this.billingConfig).length > 0,
+      billingConfigured: !!config?.billing && Object.keys(config.billing).length > 0,
       storageMode: this.storageMode
     });
     logger.info("==========================================");
   }
   /**
-   * Authenticates a user from URL parameters
-   * @param urlParams URL parameters or search string
-   * @returns Promise resolving to boolean indicating success
+   * Parses JWT and game ID from the current window URL and stores them on the client.
+   * Called automatically during construction.
    */
-  async authenticateFromUrl(urlParams) {
+  _parseUrlAuth(urlParams) {
     try {
       const params = urlParams ? parseUrlParams(urlParams) : parseUrlParams(window.location.search);
       if (params.hyveAccess) {
@@ -1736,27 +1705,11 @@ var HyveClient = class {
       }
       if (this.jwtToken) {
         logger.info("Authentication successful via JWT");
-        return true;
-      }
-      const authResult = verifyAuthentication({
-        hyveToken: params.hyveToken,
-        signature: params.signature,
-        message: params.message
-      });
-      if (authResult.isValid && authResult.address) {
-        this.userId = authResult.address;
-        logger.info("Authentication successful:", authResult.address);
-        logger.info("Authentication method:", authResult.method);
-        return true;
       } else {
-        logger.error("Authentication failed:", authResult.error);
-        this.userId = null;
-        return false;
+        logger.info("No hyve-access JWT token in URL \u2014 unauthenticated");
       }
     } catch (error) {
-      logger.error("Authentication error:", error);
-      this.userId = null;
-      return false;
+      logger.error("Error parsing URL auth:", error);
     }
   }
   /**
@@ -1773,7 +1726,7 @@ var HyveClient = class {
    */
   async sendTelemetry(eventLocation, eventCategory, eventAction, eventSubCategory, eventSubAction, eventDetails, platformId) {
     if (!this.jwtToken) {
-      logger.error("JWT token required. Call authenticateFromUrl first.");
+      logger.error("JWT token required. Ensure hyve-access and game-id are present in the URL.");
       return false;
     }
     if (!this.gameId) {
@@ -1845,7 +1798,7 @@ var HyveClient = class {
   async callApi(endpoint, options = {}) {
     if (!this.jwtToken) {
       throw new Error(
-        "No JWT token available. Call authenticateFromUrl first."
+        "No JWT token available. Ensure hyve-access and game-id are present in the URL."
       );
     }
     try {
@@ -1975,6 +1928,13 @@ var HyveClient = class {
     const storageMode = mode || this.storageMode;
     return storageMode === "local" ? this.localStorageAdapter : this.cloudStorageAdapter;
   }
+  /**
+   * Returns the current game ID or throws if not available.
+   */
+  requireGameId() {
+    const gameId = this.requireGameId();
+    return gameId;
+  }
   /**
    * Save persistent game data
    * @param key Data key
@@ -1983,10 +1943,7 @@ var HyveClient = class {
    * @returns Promise resolving to save response
    */
   async saveGameData(key, value, storage) {
-    const gameId = this.getGameId();
-    if (!gameId) {
-      throw new Error("game-id is required for persistent storage. Call authenticateFromUrl first.");
-    }
+    const gameId = this.requireGameId();
     const storageMode = storage || this.storageMode;
     logger.debug(`Saving game data to ${storageMode}: ${gameId}/${key}`);
     const adapter = this.getStorageAdapter(storage);
@@ -2001,10 +1958,7 @@ var HyveClient = class {
    * @returns Promise resolving to save response
    */
   async batchSaveGameData(items, storage) {
-    const gameId = this.getGameId();
-    if (!gameId) {
-      throw new Error("game-id is required for persistent storage. Call authenticateFromUrl first.");
-    }
+    const gameId = this.requireGameId();
     const storageMode = storage || this.storageMode;
     logger.debug(`Batch saving ${items.length} game data entries to ${storageMode} for game: ${gameId}`);
     const adapter = this.getStorageAdapter(storage);
@@ -2019,10 +1973,7 @@ var HyveClient = class {
    * @returns Promise resolving to game data item or null if not found
    */
   async getGameData(key, storage) {
-    const gameId = this.getGameId();
-    if (!gameId) {
-      throw new Error("game-id is required for persistent storage. Call authenticateFromUrl first.");
-    }
+    const gameId = this.requireGameId();
     const storageMode = storage || this.storageMode;
     logger.debug(`Getting game data from ${storageMode}: ${gameId}/${key}`);
     const adapter = this.getStorageAdapter(storage);
@@ -2041,10 +1992,7 @@ var HyveClient = class {
    * @returns Promise resolving to array of game data items
    */
   async getMultipleGameData(keys, storage) {
-    const gameId = this.getGameId();
-    if (!gameId) {
-      throw new Error("game-id is required for persistent storage. Call authenticateFromUrl first.");
-    }
+    const gameId = this.requireGameId();
     const storageMode = storage || this.storageMode;
     logger.debug(`Getting ${keys.length} game data entries from ${storageMode} for game: ${gameId}`);
     const adapter = this.getStorageAdapter(storage);
@@ -2059,10 +2007,7 @@ var HyveClient = class {
    * @returns Promise resolving to boolean indicating if data was deleted
    */
   async deleteGameData(key, storage) {
-    const gameId = this.getGameId();
-    if (!gameId) {
-      throw new Error("game-id is required for persistent storage. Call authenticateFromUrl first.");
-    }
+    const gameId = this.requireGameId();
     const storageMode = storage || this.storageMode;
     logger.debug(`Deleting game data from ${storageMode}: ${gameId}/${key}`);
     const adapter = this.getStorageAdapter(storage);
@@ -2081,10 +2026,7 @@ var HyveClient = class {
    * @returns Promise resolving to number of entries deleted
    */
   async deleteMultipleGameData(keys, storage) {
-    const gameId = this.getGameId();
-    if (!gameId) {
-      throw new Error("game-id is required for persistent storage. Call authenticateFromUrl first.");
-    }
+    const gameId = this.requireGameId();
     const storageMode = storage || this.storageMode;
     logger.debug(`Deleting ${keys.length} game data entries from ${storageMode} for game: ${gameId}`);
     const adapter = this.getStorageAdapter(storage);
@@ -2121,66 +2063,82 @@ var HyveClient = class {
    * @returns Promise resolving to ad result
    */
   async showAd(type) {
-    if (this.playgamaService?.isInitialized()) {
-      if (type === "rewarded") return this.playgamaService.showRewarded();
-      return this.playgamaService.showInterstitial();
+    if (this.crazyGamesService) {
+      if (this.crazyGamesInitPromise) {
+        await this.crazyGamesInitPromise;
+      }
+      if (this.crazyGamesService.isInitialized()) {
+        const { onBeforeAd, onAfterAd, onRewardEarned } = this.adsService.getCallbacks();
+        if (type === "rewarded") {
+          return this.crazyGamesService.showRewarded({
+            onBeforeAd: () => onBeforeAd("rewarded"),
+            onAfterAd: () => onAfterAd("rewarded"),
+            onRewardEarned
+          });
+        }
+        return this.crazyGamesService.showInterstitial({
+          onBeforeAd: () => onBeforeAd(type),
+          onAfterAd: () => onAfterAd(type)
+        });
+      }
+    }
+    if (this.playgamaService) {
+      if (this.playgamaInitPromise) {
+        await this.playgamaInitPromise;
+      }
+      if (this.playgamaService.isInitialized()) {
+        const { onBeforeAd, onAfterAd, onRewardEarned } = this.adsService.getCallbacks();
+        if (type === "rewarded") {
+          return this.playgamaService.showRewarded({
+            onBeforeAd: () => onBeforeAd("rewarded"),
+            onAfterAd: () => onAfterAd("rewarded"),
+            onRewardEarned
+          });
+        }
+        return this.playgamaService.showInterstitial({
+          onBeforeAd: () => onBeforeAd(type),
+          onAfterAd: () => onAfterAd(type)
+        });
+      }
     }
     return this.adsService.show(type);
   }
   /**
-   * Check if ads are enabled
-   * @returns Boolean indicating if ads are enabled
+   * Notifies CrazyGames that gameplay has started.
+   * No-op on other platforms.
    */
-  areAdsEnabled() {
-    return this.adsService.isEnabled();
+  async gameplayStart() {
+    if (this.crazyGamesService) {
+      if (this.crazyGamesInitPromise) await this.crazyGamesInitPromise;
+      this.crazyGamesService.gameplayStart();
+    }
   }
   /**
-   * Check if ads are ready to show
-   * @returns Boolean indicating if ads are ready
+   * Notifies CrazyGames that gameplay has stopped.
+   * No-op on other platforms.
    */
-  areAdsReady() {
-    return this.adsService.isReady();
+  async gameplayStop() {
+    if (this.crazyGamesService) {
+      if (this.crazyGamesInitPromise) await this.crazyGamesInitPromise;
+      this.crazyGamesService.gameplayStop();
+    }
   }
   /**
-   * Configure billing service
-   * @param config Billing configuration
+   * Triggers a celebration effect on the CrazyGames website for significant achievements.
+   * No-op on other platforms.
    */
-  configureBilling(config) {
-    this.billingConfig = {
-      ...this.billingConfig,
-      ...config
-    };
-    logger.info("Billing configuration updated");
+  async happytime() {
+    if (this.crazyGamesService) {
+      if (this.crazyGamesInitPromise) await this.crazyGamesInitPromise;
+      this.crazyGamesService.happytime();
+    }
   }
   /**
-   * Initialize billing service
-   * Must be called before using billing features
-   * @returns Promise resolving to boolean indicating success
+   * Check if ads are ready to show
+   * @returns Boolean indicating if ads have initialized successfully
    */
-  async initializeBilling() {
-    const mergedConfig = {
-      ...this.billingConfig
-    };
-    if (!mergedConfig.userId && this.userId) {
-      mergedConfig.userId = this.userId;
-    }
-    if (!mergedConfig.gameId && this.gameId) {
-      mergedConfig.gameId = Number(this.gameId);
-    }
-    if (!mergedConfig.checkoutUrl) {
-      mergedConfig.checkoutUrl = this.apiBaseUrl;
-    }
-    this.billingService = new BillingService(mergedConfig);
-    if (this.billingCallbacks.onComplete) {
-      this.billingService.onPurchaseComplete(this.billingCallbacks.onComplete);
-    }
-    if (this.billingCallbacks.onError) {
-      this.billingService.onPurchaseError(this.billingCallbacks.onError);
-    }
-    if (this.billingCallbacks.onLog) {
-      this.billingService.onLog(this.billingCallbacks.onLog);
-    }
-    return await this.billingService.initialize();
+  areAdsReady() {
+    return this.adsService.isReady();
   }
   /**
    * Get the billing platform
@@ -2217,7 +2175,6 @@ var HyveClient = class {
    * @param callback Function to call on purchase completion
    */
   onPurchaseComplete(callback) {
-    this.billingCallbacks.onComplete = callback;
     this.billingService.onPurchaseComplete(callback);
   }
   /**
@@ -2225,7 +2182,6 @@ var HyveClient = class {
    * @param callback Function to call on purchase error
    */
   onPurchaseError(callback) {
-    this.billingCallbacks.onError = callback;
     this.billingService.onPurchaseError(callback);
   }
   /**
@@ -2234,14 +2190,6 @@ var HyveClient = class {
   unmountBillingCheckout() {
     this.billingService.unmountCheckoutElement();
   }
-  /**
-   * Register a callback to receive billing logs
-   * @param callback Function to call with log messages
-   */
-  onBillingLog(callback) {
-    this.billingCallbacks.onLog = callback;
-    this.billingService.onLog(callback);
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2249,6 +2197,7 @@ var HyveClient = class {
   BillingPlatform,
   BillingService,
   CloudStorageAdapter,
+  CrazyGamesService,
   HyveClient,
   LocalStorageAdapter,
   Logger,
@@ -2256,11 +2205,7 @@ var HyveClient = class {
   NativeMessageType,
   PlaygamaService,
   generateUUID,
-  handleVerifyMessage,
   isDomainAllowed,
   logger,
-  parseUrlParams,
-  validateSignature,
-  verifyAuthentication,
-  verifyHyveToken
+  parseUrlParams
 });