@hyve-sdk/js 1.3.2 → 1.3.3

package/dist/index.mjs

@@ -757,7 +757,568 @@ var AdsService = class {
   }
 };
 
+// src/services/billing.ts
+var BillingPlatform = /* @__PURE__ */ ((BillingPlatform3) => {
+  BillingPlatform3["WEB"] = "web";
+  BillingPlatform3["NATIVE"] = "native";
+  BillingPlatform3["UNKNOWN"] = "unknown";
+  return BillingPlatform3;
+})(BillingPlatform || {});
+var BillingService = class {
+  config;
+  platform = "unknown" /* UNKNOWN */;
+  isInitialized = false;
+  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
+   */
+  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);
+    }
+  }
+  /**
+   * Detects if running on web or native platform
+   */
+  detectPlatform() {
+    const isNative = NativeBridge.isNativeContext();
+    const hasWindow = typeof window !== "undefined";
+    if (isNative) {
+      this.platform = "native" /* NATIVE */;
+      this.log("info", "[BillingService] Platform: NATIVE");
+    } else if (hasWindow) {
+      this.platform = "web" /* WEB */;
+      this.log("info", "[BillingService] Platform: WEB");
+    } else {
+      this.platform = "unknown" /* UNKNOWN */;
+      this.log("warn", "[BillingService] Platform: UNKNOWN");
+    }
+  }
+  /**
+   * Get the current platform
+   */
+  getPlatform() {
+    return this.platform;
+  }
+  /**
+   * Initialize the billing service
+   * Must be called before using any other methods
+   */
+  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();
+      }
+      this.log("error", "[BillingService] Cannot initialize: unknown platform");
+      return false;
+    } catch (error) {
+      this.log("error", "[BillingService] Initialization failed:", error?.message);
+      return false;
+    }
+  }
+  /**
+   * Initialize native billing
+   */
+  async initializeNative() {
+    return new Promise((resolve) => {
+      try {
+        NativeBridge.initialize();
+        NativeBridge.on(
+          "PURCHASE_COMPLETE" /* PURCHASE_COMPLETE */,
+          (payload) => {
+            this.log("info", "[BillingService] Purchase complete:", payload.productId);
+            const result = {
+              success: true,
+              productId: payload.productId,
+              transactionId: payload.transactionId,
+              transactionDate: payload.transactionDate
+            };
+            if (this.onPurchaseCompleteCallback) {
+              this.onPurchaseCompleteCallback(result);
+            }
+          }
+        );
+        NativeBridge.on(
+          "PURCHASE_ERROR" /* PURCHASE_ERROR */,
+          (payload) => {
+            this.log("error", "[BillingService] Purchase error:", payload.message);
+            const result = {
+              success: false,
+              productId: payload.productId || "unknown",
+              error: {
+                code: payload.code,
+                message: payload.message
+              }
+            };
+            if (this.onPurchaseErrorCallback) {
+              this.onPurchaseErrorCallback(result);
+            }
+          }
+        );
+        NativeBridge.on(
+          "IAP_AVAILABILITY_RESULT" /* IAP_AVAILABILITY_RESULT */,
+          (payload) => {
+            this.nativeAvailable = payload.available;
+            this.isInitialized = true;
+            this.log("info", `[BillingService] Native billing ${payload.available ? "available" : "unavailable"}`);
+            resolve(payload.available);
+          }
+        );
+        setTimeout(() => {
+          NativeBridge.checkIAPAvailability();
+        }, 100);
+        setTimeout(() => {
+          if (!this.isInitialized) {
+            this.log("warn", "[BillingService] Native initialization timeout");
+            this.isInitialized = true;
+            resolve(false);
+          }
+        }, 5e3);
+      } catch (error) {
+        this.log("error", "[BillingService] Native initialization failed:", error?.message);
+        this.isInitialized = true;
+        resolve(false);
+      }
+    });
+  }
+  /**
+   * Initialize web billing (Stripe)
+   */
+  async initializeWeb() {
+    if (!this.config.stripePublishableKey) {
+      this.log("error", "[BillingService] Stripe publishable key not provided");
+      return false;
+    }
+    try {
+      if (typeof window === "undefined") {
+        this.log("error", "[BillingService] Window is undefined (not in browser)");
+        return false;
+      }
+      if (!window.Stripe) {
+        await this.loadStripeScript();
+      }
+      if (window.Stripe) {
+        this.stripe = window.Stripe(this.config.stripePublishableKey);
+        this.isInitialized = true;
+        this.log("info", "[BillingService] Web billing initialized");
+        return true;
+      } else {
+        this.log("error", "[BillingService] Stripe not available after loading");
+        return false;
+      }
+    } catch (error) {
+      this.log("error", "[BillingService] Stripe initialization failed:", error?.message);
+      return false;
+    }
+  }
+  /**
+   * Load Stripe.js script dynamically
+   */
+  loadStripeScript() {
+    return new Promise((resolve, reject) => {
+      if (typeof window === "undefined") {
+        reject(new Error("Window is not defined"));
+        return;
+      }
+      if (window.Stripe) {
+        resolve();
+        return;
+      }
+      if (!document || !document.head) {
+        reject(new Error("document is undefined"));
+        return;
+      }
+      const script = document.createElement("script");
+      script.src = "https://js.stripe.com/v3/";
+      script.async = true;
+      script.onload = () => {
+        this.log("info", "[BillingService] Stripe.js loaded");
+        resolve();
+      };
+      script.onerror = () => {
+        this.log("error", "[BillingService] Failed to load Stripe.js");
+        reject(new Error("Failed to load Stripe.js"));
+      };
+      try {
+        document.head.appendChild(script);
+      } catch (appendError) {
+        reject(appendError);
+      }
+    });
+  }
+  /**
+   * Check if billing is available
+   */
+  isAvailable() {
+    if (!this.isInitialized) {
+      return false;
+    }
+    if (this.platform === "native" /* NATIVE */) {
+      return this.nativeAvailable;
+    } else if (this.platform === "web" /* WEB */) {
+      return !!this.config.stripePublishableKey;
+    }
+    return false;
+  }
+  /**
+   * Get available products
+   */
+  async getProducts() {
+    if (!this.isInitialized) {
+      throw new Error("BillingService not initialized. Call initialize() first.");
+    }
+    if (this.platform === "native" /* NATIVE */) {
+      return await this.getProductsNative();
+    } else if (this.platform === "web" /* WEB */) {
+      return await this.getProductsWeb();
+    }
+    throw new Error("Cannot get products: unknown platform");
+  }
+  /**
+   * 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);
+      });
+    });
+  }
+  /**
+   * Get products from web API (Stripe)
+   */
+  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);
+      throw error;
+    }
+    try {
+      const url = `${this.config.checkoutUrl}/get-packages?game_id=${this.config.gameId}`;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch web products: ${response.status}`);
+      }
+      const data = await response.json();
+      if (!data.packages || !Array.isArray(data.packages)) {
+        throw new Error("Invalid response format: missing packages array");
+      }
+      this.products = data.packages.map((pkg) => ({
+        productId: pkg.priceId || pkg.productId,
+        // Prefer priceId for Stripe
+        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} web products`);
+      return this.products;
+    } catch (error) {
+      this.log("error", "[BillingService] Failed to fetch web products:", error?.message);
+      throw error;
+    }
+  }
+  /**
+   * Purchase a product
+   * @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.");
+    }
+    if (!this.isAvailable()) {
+      throw new Error("Billing is not available on this platform");
+    }
+    if (this.platform === "native" /* NATIVE */) {
+      return await this.purchaseNative(productId);
+    } else if (this.platform === "web" /* WEB */) {
+      return await this.purchaseWeb(productId, options?.elementId);
+    }
+    throw new Error("Cannot purchase: unknown platform");
+  }
+  /**
+   * Purchase via native IAP
+   */
+  async purchaseNative(productId) {
+    return new Promise((resolve, reject) => {
+      if (!this.config.userId) {
+        reject(new Error("userId is required for native purchases"));
+        return;
+      }
+      this.log("info", `[BillingService] Purchasing: ${productId}`);
+      const previousCompleteCallback = this.onPurchaseCompleteCallback;
+      const previousErrorCallback = this.onPurchaseErrorCallback;
+      const cleanup = () => {
+        this.onPurchaseCompleteCallback = previousCompleteCallback;
+        this.onPurchaseErrorCallback = previousErrorCallback;
+      };
+      const completeHandler = (result) => {
+        if (result.productId === productId) {
+          cleanup();
+          resolve(result);
+          if (previousCompleteCallback) {
+            previousCompleteCallback(result);
+          }
+        }
+      };
+      const errorHandler = (result) => {
+        if (result.productId === productId) {
+          cleanup();
+          reject(new Error(result.error?.message || "Purchase failed"));
+          if (previousErrorCallback) {
+            previousErrorCallback(result);
+          }
+        }
+      };
+      this.onPurchaseCompleteCallback = completeHandler;
+      this.onPurchaseErrorCallback = errorHandler;
+      NativeBridge.purchase(productId, this.config.userId);
+      setTimeout(() => {
+        cleanup();
+        reject(new Error("Purchase timeout"));
+      }, 6e4);
+    });
+  }
+  /**
+   * Purchase via web (Stripe)
+   * @param productId - The priceId (Stripe price ID) for web purchases
+   * @param elementId - Optional DOM element ID to mount the checkout form (default: 'stripe-checkout-element')
+   */
+  async purchaseWeb(productId, elementId) {
+    if (!this.config.userId || !this.config.checkoutUrl) {
+      throw new Error("userId and checkoutUrl are required for web purchases");
+    }
+    if (!this.stripe) {
+      throw new Error("Stripe not initialized. Call initialize() first.");
+    }
+    try {
+      const returnUrl = typeof window !== "undefined" ? `${window.location.href}${window.location.href.includes("?") ? "&" : "?"}payment=complete` : void 0;
+      const requestBody = {
+        priceId: productId,
+        // API expects priceId for Stripe
+        userId: this.config.userId,
+        gameId: this.config.gameId,
+        embedded: true,
+        // Enable embedded checkout
+        return_url: returnUrl
+      };
+      const response = await fetch(`${this.config.checkoutUrl}/create-checkout-session`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to create checkout session: ${response.status} - ${errorText}`);
+      }
+      const responseData = await response.json();
+      const { client_secret, id } = responseData;
+      if (!client_secret) {
+        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}`);
+      return {
+        success: true,
+        productId,
+        transactionId: id
+      };
+    } catch (error) {
+      this.log("error", "[BillingService] Web purchase failed:", error?.message);
+      return {
+        success: false,
+        productId,
+        error: {
+          code: "WEB_PURCHASE_FAILED",
+          message: error.message || "Purchase failed"
+        }
+      };
+    }
+  }
+  /**
+   * Mount Stripe embedded checkout element to the DOM
+   * @param clientSecret - The client secret from the checkout session
+   * @param elementId - The ID of the DOM element to mount to
+   */
+  async mountCheckoutElement(clientSecret, elementId) {
+    if (!this.stripe) {
+      throw new Error("Stripe not initialized");
+    }
+    try {
+      const container = document.getElementById(elementId);
+      if (!container) {
+        throw new Error(`Element with id "${elementId}" not found in the DOM`);
+      }
+      container.innerHTML = "";
+      this.checkoutElement = await this.stripe.initEmbeddedCheckout({
+        clientSecret
+      });
+      this.checkoutElement.mount(`#${elementId}`);
+      this.setupCheckoutEventListeners();
+    } catch (error) {
+      this.log("error", "[BillingService] Failed to mount checkout:", error?.message);
+      throw error;
+    }
+  }
+  /**
+   * Set up event listeners for checkout completion
+   */
+  setupCheckoutEventListeners() {
+    if (typeof window !== "undefined") {
+      const urlParams = new URLSearchParams(window.location.search);
+      const paymentStatus = urlParams.get("payment");
+      if (paymentStatus === "complete") {
+        const sessionId = urlParams.get("session_id");
+        if (this.onPurchaseCompleteCallback) {
+          this.onPurchaseCompleteCallback({
+            success: true,
+            productId: "",
+            // Would need to be tracked separately
+            transactionId: sessionId || void 0
+          });
+        }
+        this.log("info", "[BillingService] Payment completed");
+        urlParams.delete("payment");
+        urlParams.delete("session_id");
+        const newUrl = `${window.location.pathname}${urlParams.toString() ? "?" + urlParams.toString() : ""}`;
+        window.history.replaceState({}, "", newUrl);
+      }
+    }
+  }
+  /**
+   * Unmount and destroy the checkout element
+   */
+  unmountCheckoutElement() {
+    if (this.checkoutElement) {
+      this.checkoutElement.unmount();
+      this.checkoutElement = null;
+    }
+  }
+  /**
+   * Set callback for successful purchases
+   */
+  onPurchaseComplete(callback) {
+    this.onPurchaseCompleteCallback = callback;
+  }
+  /**
+   * Set callback for failed purchases
+   */
+  onPurchaseError(callback) {
+    this.onPurchaseErrorCallback = callback;
+  }
+  /**
+   * Clean up resources
+   */
+  dispose() {
+    if (this.platform === "native" /* NATIVE */) {
+      NativeBridge.off("IAP_AVAILABILITY_RESULT" /* IAP_AVAILABILITY_RESULT */);
+      NativeBridge.off("PRODUCTS_RESULT" /* PRODUCTS_RESULT */);
+      NativeBridge.off("PURCHASE_COMPLETE" /* PURCHASE_COMPLETE */);
+      NativeBridge.off("PURCHASE_ERROR" /* PURCHASE_ERROR */);
+    }
+    this.unmountCheckoutElement();
+    this.isInitialized = false;
+    this.nativeAvailable = false;
+    this.products = [];
+    this.stripe = null;
+    this.onPurchaseCompleteCallback = void 0;
+    this.onPurchaseErrorCallback = void 0;
+  }
+};
+
 // src/core/client.ts
+function determineEnvironmentFromParentUrl() {
+  try {
+    let parentUrl = "";
+    if (window !== window.top) {
+      try {
+        parentUrl = window.parent.location.href;
+      } catch (e) {
+        parentUrl = document.referrer;
+      }
+    } else {
+      parentUrl = window.location.href;
+    }
+    logger.debug("Detected parent URL:", parentUrl);
+    if (parentUrl.includes("dev.hyve.gg")) {
+      logger.info("Environment detected: dev (from parent URL)");
+      return true;
+    }
+    if (parentUrl.includes("hyve.gg")) {
+      logger.info("Environment detected: prod (from parent URL)");
+      return false;
+    }
+    logger.info("Environment unknown, defaulting to dev");
+    return true;
+  } catch (error) {
+    logger.warn("Failed to determine environment from parent URL:", error);
+    return true;
+  }
+}
 var HyveClient = class {
   telemetryConfig;
   apiBaseUrl;
@@ -766,14 +1327,18 @@ var HyveClient = class {
   jwtToken = null;
   gameId = null;
   adsService;
+  billingService;
+  billingConfig;
+  // Store callbacks to preserve them when recreating BillingService
+  billingCallbacks = {};
   /**
    * Creates a new HyveClient instance
    * @param config Optional configuration including telemetry and ads
    */
   constructor(config) {
+    const isDev = config?.isDev !== void 0 ? config.isDev : determineEnvironmentFromParentUrl();
     this.telemetryConfig = {
-      isDev: true,
-      // Default to dev environment
+      isDev,
       ...config
     };
     if (this.telemetryConfig.apiBaseUrl) {
@@ -786,10 +1351,24 @@ var HyveClient = class {
     if (config?.ads) {
       this.adsService.configure(config.ads);
     }
-    logger.info("Client initialized with sessionId:", this.sessionId);
+    this.billingConfig = config?.billing || {};
+    this.billingService = new BillingService(this.billingConfig);
+    const envSource = config?.isDev !== void 0 ? "explicit config" : "auto-detected from parent URL";
+    logger.info("==========================================");
+    logger.info("HyveClient Initialized");
+    logger.info("==========================================");
+    logger.info("Session ID:", this.sessionId);
+    logger.info("Environment:", this.telemetryConfig.isDev ? "DEVELOPMENT" : "PRODUCTION", `(${envSource})`);
     logger.info("API Base URL:", this.apiBaseUrl);
-    logger.info("Environment:", this.telemetryConfig.isDev ? "dev" : "prod");
     logger.info("Ads enabled:", this.adsService.isEnabled());
+    logger.info("Billing configured:", Object.keys(this.billingConfig).length > 0);
+    logger.debug("Config:", {
+      isDev: this.telemetryConfig.isDev,
+      hasCustomApiUrl: !!config?.apiBaseUrl,
+      adsEnabled: config?.ads?.enabled || false,
+      billingConfigured: Object.keys(this.billingConfig).length > 0
+    });
+    logger.info("==========================================");
   }
   /**
    * Authenticates a user from URL parameters
@@ -940,826 +1519,237 @@ var HyveClient = class {
       return await response.json();
     } catch (error) {
       logger.error("API call failed:", error);
-      throw error;
-    }
-  }
-  /**
-   * Gets the user's inventory
-   * @returns Promise resolving to the user's inventory
-   */
-  async getInventory() {
-    return this.callApi("/api/v1/inventory");
-  }
-  /**
-   * Gets a specific inventory item by ID
-   * @param itemId The inventory item ID
-   * @returns Promise resolving to the inventory item details
-   */
-  async getInventoryItem(itemId) {
-    return this.callApi(`/api/v1/inventory/${itemId}`);
-  }
-  /**
-   * Updates the telemetry configuration
-   * @param config New telemetry configuration
-   */
-  updateTelemetryConfig(config) {
-    this.telemetryConfig = {
-      ...this.telemetryConfig,
-      ...config
-    };
-    if (config.apiBaseUrl !== void 0) {
-      this.apiBaseUrl = config.apiBaseUrl;
-    } else if (config.isDev !== void 0) {
-      this.apiBaseUrl = config.isDev ? "https://product-api.dev.hyve.gg" : "https://product-api.prod.hyve.gg";
-    }
-    logger.info("Config updated");
-    logger.info("API Base URL:", this.apiBaseUrl);
-  }
-  /**
-   * Gets the current user ID
-   * @returns Current user ID or null if not authenticated
-   */
-  getUserId() {
-    return this.userId;
-  }
-  /**
-   * Gets the current session ID
-   * @returns Current session ID
-   */
-  getSessionId() {
-    return this.sessionId;
-  }
-  /**
-   * Gets the current JWT token
-   * @returns Current JWT token or null if not available
-   */
-  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
-   */
-  getApiBaseUrl() {
-    return this.apiBaseUrl;
-  }
-  /**
-   * Checks if user is authenticated
-   * @returns Boolean indicating authentication status
-   */
-  isUserAuthenticated() {
-    return this.userId !== null;
-  }
-  /**
-   * Checks if JWT token is available
-   * @returns Boolean indicating if JWT token is present
-   */
-  hasJwtToken() {
-    return this.jwtToken !== null;
-  }
-  /**
-   * Logs out the current user
-   */
-  logout() {
-    this.userId = null;
-    this.jwtToken = null;
-    this.gameId = null;
-    logger.info("User logged out");
-  }
-  /**
-   * Resets the client state
-   */
-  reset() {
-    this.logout();
-    this.sessionId = generateUUID();
-    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();
-  }
-};
-
-// src/services/billing.ts
-var BillingPlatform = /* @__PURE__ */ ((BillingPlatform2) => {
-  BillingPlatform2["WEB"] = "web";
-  BillingPlatform2["NATIVE"] = "native";
-  BillingPlatform2["UNKNOWN"] = "unknown";
-  return BillingPlatform2;
-})(BillingPlatform || {});
-var BillingService = class {
-  config;
-  platform = "unknown" /* UNKNOWN */;
-  isInitialized = false;
-  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
-   */
-  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);
+      throw error;
     }
   }
   /**
-   * Detects if running on web or native platform
+   * Gets the user's inventory
+   * @returns Promise resolving to the user's inventory
    */
-  detectPlatform() {
-    this.log("info", "[BillingService] ========== PLATFORM DETECTION ==========");
-    this.log("info", "[BillingService] Checking environment...");
-    this.log("info", "[BillingService] Checking NativeBridge.isNativeContext()...");
-    const isNative = NativeBridge.isNativeContext();
-    this.log("info", `[BillingService] NativeBridge.isNativeContext() = ${isNative}`);
-    this.log("info", "[BillingService] Checking typeof window...");
-    const hasWindow = typeof window !== "undefined";
-    this.log("info", `[BillingService] typeof window !== "undefined" = ${hasWindow}`);
-    if (hasWindow) {
-      this.log("info", "[BillingService] Checking window.ReactNativeWebView...");
-      const hasWebView = !!window.ReactNativeWebView;
-      this.log("info", `[BillingService] window.ReactNativeWebView exists = ${hasWebView}`);
-    }
-    if (isNative) {
-      this.platform = "native" /* NATIVE */;
-      this.log("info", "[BillingService] \u2713 Platform: NATIVE (React Native WebView)");
-    } else if (hasWindow) {
-      this.platform = "web" /* WEB */;
-      this.log("info", "[BillingService] \u2713 Platform: WEB (Browser)");
-    } else {
-      this.platform = "unknown" /* UNKNOWN */;
-      this.log("warn", "[BillingService] \u26A0 Platform: UNKNOWN");
-    }
-    this.log("info", "[BillingService] ========================================");
+  async getInventory() {
+    return this.callApi("/api/v1/inventory");
   }
   /**
-   * Get the current platform
+   * Gets a specific inventory item by ID
+   * @param itemId The inventory item ID
+   * @returns Promise resolving to the inventory item details
    */
-  getPlatform() {
-    return this.platform;
+  async getInventoryItem(itemId) {
+    return this.callApi(`/api/v1/inventory/${itemId}`);
   }
   /**
-   * Initialize the billing service
-   * Must be called before using any other methods
+   * Updates the telemetry configuration
+   * @param config New telemetry configuration
    */
-  async initialize() {
-    this.log("info", "[BillingService] ========== INITIALIZATION START ==========");
-    this.log("info", "[BillingService] Current config:", {
-      hasStripeKey: !!this.config.stripePublishableKey,
-      stripeKeyLength: this.config.stripePublishableKey?.length,
-      gameId: this.config.gameId,
-      userId: this.config.userId,
-      hasCheckoutUrl: !!this.config.checkoutUrl,
-      checkoutUrl: this.config.checkoutUrl
-    });
-    if (this.isInitialized) {
-      this.log("info", "[BillingService] Already initialized");
-      return true;
-    }
-    this.log("info", `[BillingService] Detected platform: ${this.platform}`);
-    try {
-      if (this.platform === "native" /* NATIVE */) {
-        this.log("info", "[BillingService] Attempting native initialization...");
-        const result = await this.initializeNative();
-        this.log("info", `[BillingService] Native initialization result: ${result}`);
-        return result;
-      } else if (this.platform === "web" /* WEB */) {
-        this.log("info", "[BillingService] Attempting web initialization...");
-        const result = await this.initializeWeb();
-        this.log("info", `[BillingService] Web initialization result: ${result}`);
-        return result;
-      }
-      this.log("error", "[BillingService] Cannot initialize: unknown platform");
-      this.log("error", "[BillingService] Platform detection may have failed");
-      return false;
-    } catch (error) {
-      this.log("error", "[BillingService] Initialization failed with exception:", error);
-      this.log("error", "[BillingService] Error message:", error?.message);
-      this.log("error", "[BillingService] Error stack:", error?.stack);
-      return false;
-    } finally {
-      this.log("info", "[BillingService] ========== INITIALIZATION END ==========");
+  updateTelemetryConfig(config) {
+    this.telemetryConfig = {
+      ...this.telemetryConfig,
+      ...config
+    };
+    if (config.apiBaseUrl !== void 0) {
+      this.apiBaseUrl = config.apiBaseUrl;
+    } else if (config.isDev !== void 0) {
+      this.apiBaseUrl = config.isDev ? "https://product-api.dev.hyve.gg" : "https://product-api.prod.hyve.gg";
     }
+    logger.info("Config updated");
+    logger.info("API Base URL:", this.apiBaseUrl);
   }
   /**
-   * Initialize native billing
+   * Gets the current user ID
+   * @returns Current user ID or null if not authenticated
    */
-  async initializeNative() {
-    this.log("info", "[BillingService] --- Native Initialization Start ---");
-    return new Promise((resolve) => {
-      this.log("info", "[BillingService] Checking NativeBridge...");
-      try {
-        this.log("info", "[BillingService] Calling NativeBridge.initialize()...");
-        NativeBridge.initialize();
-        this.log("info", "[BillingService] \u2713 NativeBridge.initialize() called");
-        this.log("info", "[BillingService] Setting up PURCHASE_COMPLETE listener...");
-        NativeBridge.on(
-          "PURCHASE_COMPLETE" /* PURCHASE_COMPLETE */,
-          (payload) => {
-            this.log("info", "[BillingService] \u2713 Native purchase complete:", payload);
-            const result = {
-              success: true,
-              productId: payload.productId,
-              transactionId: payload.transactionId,
-              transactionDate: payload.transactionDate
-            };
-            if (this.onPurchaseCompleteCallback) {
-              this.onPurchaseCompleteCallback(result);
-            }
-          }
-        );
-        this.log("info", "[BillingService] \u2713 PURCHASE_COMPLETE listener registered");
-        this.log("info", "[BillingService] Setting up PURCHASE_ERROR listener...");
-        NativeBridge.on(
-          "PURCHASE_ERROR" /* PURCHASE_ERROR */,
-          (payload) => {
-            this.log("error", "[BillingService] \u274C Native purchase error:", payload);
-            const result = {
-              success: false,
-              productId: payload.productId || "unknown",
-              error: {
-                code: payload.code,
-                message: payload.message
-              }
-            };
-            if (this.onPurchaseErrorCallback) {
-              this.onPurchaseErrorCallback(result);
-            }
-          }
-        );
-        this.log("info", "[BillingService] \u2713 PURCHASE_ERROR listener registered");
-        this.log("info", "[BillingService] Setting up IAP_AVAILABILITY_RESULT listener...");
-        NativeBridge.on(
-          "IAP_AVAILABILITY_RESULT" /* IAP_AVAILABILITY_RESULT */,
-          (payload) => {
-            this.log("info", "[BillingService] \u2713 IAP availability result received:", payload.available);
-            this.nativeAvailable = payload.available;
-            this.isInitialized = true;
-            if (payload.available) {
-              this.log("info", "[BillingService] \u2713\u2713\u2713 Native billing available and initialized \u2713\u2713\u2713");
-            } else {
-              this.log("warn", "[BillingService] \u26A0 Native billing initialized but IAP not available");
-            }
-            resolve(payload.available);
-          }
-        );
-        this.log("info", "[BillingService] \u2713 IAP_AVAILABILITY_RESULT listener registered");
-        this.log("info", "[BillingService] Waiting 100ms for event listeners to be ready...");
-        setTimeout(() => {
-          this.log("info", "[BillingService] Sending checkIAPAvailability message to native...");
-          NativeBridge.checkIAPAvailability();
-          this.log("info", "[BillingService] \u2713 checkIAPAvailability message sent");
-          this.log("info", "[BillingService] Waiting for IAP availability response (5s timeout)...");
-        }, 100);
-        setTimeout(() => {
-          if (!this.isInitialized) {
-            this.log("warn", "[BillingService] \u274C Native billing initialization TIMEOUT after 5 seconds");
-            this.log("warn", "[BillingService] No response from native app");
-            this.log("warn", "[BillingService] Marking as initialized but unavailable");
-            this.isInitialized = true;
-            resolve(false);
-          }
-        }, 5e3);
-      } catch (error) {
-        this.log("error", "[BillingService] \u274C Exception during native initialization:", error);
-        this.log("error", "[BillingService] Error message:", error?.message);
-        this.log("error", "[BillingService] Error stack:", error?.stack);
-        this.isInitialized = true;
-        resolve(false);
-      } finally {
-        this.log("info", "[BillingService] --- Native Initialization End ---");
-      }
-    });
+  getUserId() {
+    return this.userId;
   }
   /**
-   * Initialize web billing (Stripe)
+   * Gets the current session ID
+   * @returns Current session ID
    */
-  async initializeWeb() {
-    this.log("info", "[BillingService] --- Web Initialization Start ---");
-    this.log("info", "[BillingService] Checking for Stripe publishable key...");
-    if (!this.config.stripePublishableKey) {
-      this.log(
-        "error",
-        "[BillingService] \u274C FAILED: stripePublishableKey not provided in config"
-      );
-      this.log("error", "[BillingService] Config keys present:", Object.keys(this.config));
-      return false;
-    }
-    this.log(
-      "info",
-      `[BillingService] \u2713 Stripe key found (length: ${this.config.stripePublishableKey.length})`
-    );
-    this.log(
-      "info",
-      `[BillingService] Key starts with: ${this.config.stripePublishableKey.substring(0, 12)}...`
-    );
-    try {
-      this.log("info", "[BillingService] Checking window object...");
-      if (typeof window === "undefined") {
-        this.log("error", "[BillingService] \u274C FAILED: window is undefined (not in browser)");
-        return false;
-      }
-      this.log("info", "[BillingService] \u2713 Window object exists");
-      this.log("info", "[BillingService] Checking if Stripe.js is already loaded...");
-      if (!window.Stripe) {
-        this.log("info", "[BillingService] Stripe.js not loaded, loading now...");
-        await this.loadStripeScript();
-        this.log("info", "[BillingService] Stripe.js load complete");
-      } else {
-        this.log("info", "[BillingService] \u2713 Stripe.js already loaded");
-      }
-      this.log("info", "[BillingService] Attempting to initialize Stripe instance...");
-      if (window.Stripe) {
-        this.log("info", "[BillingService] Creating Stripe instance with publishable key...");
-        this.stripe = window.Stripe(this.config.stripePublishableKey);
-        this.log("info", "[BillingService] \u2713 Stripe instance created");
-        this.log("info", "[BillingService] Stripe object type:", typeof this.stripe);
-        this.log("info", "[BillingService] Stripe object keys:", Object.keys(this.stripe || {}));
-        this.isInitialized = true;
-        this.log("info", "[BillingService] \u2713\u2713\u2713 Web billing initialized successfully \u2713\u2713\u2713");
-        return true;
-      } else {
-        this.log("error", "[BillingService] \u274C FAILED: window.Stripe is undefined after loading");
-        this.log("error", "[BillingService] window keys:", Object.keys(window));
-        return false;
-      }
-    } catch (error) {
-      this.log("error", "[BillingService] \u274C EXCEPTION during Stripe initialization:");
-      this.log("error", "[BillingService] Error type:", error?.constructor?.name);
-      this.log("error", "[BillingService] Error message:", error?.message);
-      this.log("error", "[BillingService] Error stack:", error?.stack);
-      return false;
-    } finally {
-      this.log("info", "[BillingService] --- Web Initialization End ---");
-    }
+  getSessionId() {
+    return this.sessionId;
   }
   /**
-   * Load Stripe.js script dynamically
+   * Gets the current JWT token
+   * @returns Current JWT token or null if not available
    */
-  loadStripeScript() {
-    this.log("info", "[BillingService] --- loadStripeScript() Start ---");
-    return new Promise((resolve, reject) => {
-      this.log("info", "[BillingService] Checking window object in loadStripeScript...");
-      if (typeof window === "undefined") {
-        this.log("error", "[BillingService] \u274C FAILED: Window is not defined");
-        reject(new Error("Window is not defined"));
-        return;
-      }
-      this.log("info", "[BillingService] \u2713 Window exists");
-      this.log("info", "[BillingService] Checking if Stripe is already on window...");
-      if (window.Stripe) {
-        this.log("info", "[BillingService] \u2713 Stripe already exists, no need to load");
-        resolve();
-        return;
-      }
-      this.log("info", "[BillingService] Stripe not found, need to load script");
-      this.log("info", "[BillingService] Checking document object...");
-      if (!document) {
-        this.log("error", "[BillingService] \u274C FAILED: document is undefined");
-        reject(new Error("document is undefined"));
-        return;
-      }
-      this.log("info", "[BillingService] \u2713 Document exists");
-      this.log("info", "[BillingService] Checking document.head...");
-      if (!document.head) {
-        this.log("error", "[BillingService] \u274C FAILED: document.head is undefined");
-        reject(new Error("document.head is undefined"));
-        return;
-      }
-      this.log("info", "[BillingService] \u2713 document.head exists");
-      this.log("info", "[BillingService] Creating script element...");
-      const script = document.createElement("script");
-      script.src = "https://js.stripe.com/v3/";
-      script.async = true;
-      this.log("info", "[BillingService] \u2713 Script element created");
-      this.log("info", "[BillingService] Script src:", script.src);
-      script.onload = () => {
-        this.log("info", "[BillingService] \u2713\u2713\u2713 Stripe.js script loaded successfully \u2713\u2713\u2713");
-        this.log("info", "[BillingService] Checking if window.Stripe now exists...");
-        if (window.Stripe) {
-          this.log("info", "[BillingService] \u2713 window.Stripe confirmed to exist");
-        } else {
-          this.log("warn", "[BillingService] \u26A0 Warning: Script loaded but window.Stripe is still undefined");
-        }
-        resolve();
-      };
-      script.onerror = (error) => {
-        this.log("error", "[BillingService] \u274C\u274C\u274C Failed to load Stripe.js script");
-        this.log("error", "[BillingService] Script error event:", error);
-        this.log("error", "[BillingService] Script src attempted:", script.src);
-        reject(new Error("Failed to load Stripe.js"));
-      };
-      this.log("info", "[BillingService] Appending script to document.head...");
-      try {
-        document.head.appendChild(script);
-        this.log("info", "[BillingService] \u2713 Script appended to head, waiting for load...");
-      } catch (appendError) {
-        this.log("error", "[BillingService] \u274C Exception while appending script:", appendError);
-        reject(appendError);
-      }
-    });
+  getJwtToken() {
+    return this.jwtToken;
   }
   /**
-   * Check if billing is available
+   * Gets the current game ID
+   * @returns Current game ID or null if not available
    */
-  isAvailable() {
-    if (!this.isInitialized) {
-      this.log("warn", "[BillingService] Not initialized. Call initialize() first.");
-      return false;
-    }
-    if (this.platform === "native" /* NATIVE */) {
-      return this.nativeAvailable;
-    } else if (this.platform === "web" /* WEB */) {
-      return !!this.config.stripePublishableKey;
-    }
-    return false;
+  getGameId() {
+    return this.gameId;
   }
   /**
-   * Get available products
+   * Gets the API base URL
+   * @returns API base URL
    */
-  async getProducts() {
-    if (!this.isInitialized) {
-      throw new Error("BillingService not initialized. Call initialize() first.");
-    }
-    if (this.platform === "native" /* NATIVE */) {
-      return await this.getProductsNative();
-    } else if (this.platform === "web" /* WEB */) {
-      return await this.getProductsWeb();
-    }
-    throw new Error("Cannot get products: unknown platform");
+  getApiBaseUrl() {
+    return this.apiBaseUrl;
   }
   /**
-   * Get products from native IAP
+   * Checks if user is authenticated
+   * @returns Boolean indicating authentication status
    */
-  async getProductsNative() {
-    return new Promise((resolve, reject) => {
-      if (!this.config.gameId) {
-        const error = new Error("gameId is required for native purchases");
-        this.log("error", "[BillingService] getProductsNative failed:", error);
-        reject(error);
-        return;
-      }
-      if (!this.config.checkoutUrl) {
-        const error = new Error("checkoutUrl is required for native purchases");
-        this.log("error", "[BillingService] getProductsNative failed:", error);
-        reject(error);
-        return;
-      }
-      this.log(
-        "info",
-        `[BillingService] Fetching native products for gameId: ${this.config.gameId}`
-      );
-      const url = `${this.config.checkoutUrl}/get-native-packages?game_id=${this.config.gameId}`;
-      this.log("info", `[BillingService] Native products URL: ${url}`);
-      fetch(url).then((response) => {
-        this.log(
-          "info",
-          `[BillingService] Native products response status: ${response.status}`
-        );
-        if (!response.ok) {
-          throw new Error(`Failed to fetch native products: ${response.status}`);
-        }
-        return response.json();
-      }).then((data) => {
-        this.log("info", `[BillingService] Native products data:`, 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] Successfully fetched ${this.products.length} native products`
-        );
-        resolve(this.products);
-      }).catch((error) => {
-        this.log("error", "[BillingService] Failed to fetch native products:", error);
-        reject(error);
-      });
-    });
+  isUserAuthenticated() {
+    return this.userId !== null;
+  }
+  /**
+   * Checks if JWT token is available
+   * @returns Boolean indicating if JWT token is present
+   */
+  hasJwtToken() {
+    return this.jwtToken !== null;
   }
   /**
-   * Get products from web API (Stripe)
+   * Logs out the current user
    */
-  async getProductsWeb() {
-    this.log("info", "[BillingService] Fetching web products (Stripe)...");
-    if (!this.config.checkoutUrl || !this.config.gameId) {
-      const error = new Error("checkoutUrl and gameId are required for web purchases");
-      this.log("error", "[BillingService] getProductsWeb failed:", error);
-      throw error;
-    }
-    try {
-      const url = `${this.config.checkoutUrl}/get-packages?game_id=${this.config.gameId}`;
-      this.log("info", `[BillingService] Web products URL: ${url}`);
-      const response = await fetch(url);
-      this.log("info", `[BillingService] Web products response status: ${response.status}`);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch web products: ${response.status}`);
-      }
-      const data = await response.json();
-      this.log("info", `[BillingService] Web products data:`, 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.priceId || pkg.productId,
-        // Prefer priceId for Stripe
-        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] Successfully fetched ${this.products.length} web products`
-      );
-      return this.products;
-    } catch (error) {
-      this.log("error", "[BillingService] Failed to fetch web products:", error);
-      throw error;
-    }
+  logout() {
+    this.userId = null;
+    this.jwtToken = null;
+    this.gameId = null;
+    logger.info("User logged out");
   }
   /**
-   * Purchase a product
-   * @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')
+   * Resets the client state
    */
-  async purchase(productId, options) {
-    if (!this.isInitialized) {
-      throw new Error("BillingService not initialized. Call initialize() first.");
-    }
-    if (!this.isAvailable()) {
-      throw new Error("Billing is not available on this platform");
-    }
-    if (this.platform === "native" /* NATIVE */) {
-      return await this.purchaseNative(productId);
-    } else if (this.platform === "web" /* WEB */) {
-      return await this.purchaseWeb(productId, options?.elementId);
-    }
-    throw new Error("Cannot purchase: unknown platform");
+  reset() {
+    this.logout();
+    this.sessionId = generateUUID();
+    logger.info("Client reset with new sessionId:", this.sessionId);
   }
   /**
-   * Purchase via native IAP
+   * Configure ads service
+   * @param config Ads configuration
    */
-  async purchaseNative(productId) {
-    return new Promise((resolve, reject) => {
-      if (!this.config.userId) {
-        reject(new Error("userId is required for native purchases"));
-        return;
-      }
-      this.log("info", `[BillingService] Initiating native purchase for: ${productId}`);
-      const previousCompleteCallback = this.onPurchaseCompleteCallback;
-      const previousErrorCallback = this.onPurchaseErrorCallback;
-      const cleanup = () => {
-        this.onPurchaseCompleteCallback = previousCompleteCallback;
-        this.onPurchaseErrorCallback = previousErrorCallback;
-      };
-      const completeHandler = (result) => {
-        if (result.productId === productId) {
-          cleanup();
-          resolve(result);
-          if (previousCompleteCallback) {
-            previousCompleteCallback(result);
-          }
-        }
-      };
-      const errorHandler = (result) => {
-        if (result.productId === productId) {
-          cleanup();
-          reject(new Error(result.error?.message || "Purchase failed"));
-          if (previousErrorCallback) {
-            previousErrorCallback(result);
-          }
-        }
-      };
-      this.onPurchaseCompleteCallback = completeHandler;
-      this.onPurchaseErrorCallback = errorHandler;
-      NativeBridge.purchase(productId, this.config.userId);
-      setTimeout(() => {
-        cleanup();
-        reject(new Error("Purchase timeout"));
-      }, 6e4);
-    });
+  configureAds(config) {
+    this.adsService.configure(config);
+    logger.info("Ads configuration updated");
   }
   /**
-   * Purchase via web (Stripe)
-   * @param productId - The priceId (Stripe price ID) for web purchases
-   * @param elementId - Optional DOM element ID to mount the checkout form (default: 'stripe-checkout-element')
+   * Show an ad
+   * @param type Type of ad to show ('rewarded', 'interstitial', or 'preroll')
+   * @returns Promise resolving to ad result
    */
-  async purchaseWeb(productId, elementId) {
-    this.log("info", `[BillingService] Initiating web purchase for priceId: ${productId}`);
-    if (!this.config.userId || !this.config.checkoutUrl) {
-      throw new Error("userId and checkoutUrl are required for web purchases");
+  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();
+  }
+  /**
+   * Configure billing service
+   * @param config Billing configuration
+   */
+  configureBilling(config) {
+    this.billingConfig = {
+      ...this.billingConfig,
+      ...config
+    };
+    logger.info("Billing configuration updated");
+  }
+  /**
+   * Initialize billing service
+   * Must be called before using billing features
+   * @returns Promise resolving to boolean indicating success
+   */
+  async initializeBilling() {
+    const mergedConfig = {
+      ...this.billingConfig
+    };
+    if (!mergedConfig.userId && this.userId) {
+      mergedConfig.userId = this.userId;
     }
-    if (!this.stripe) {
-      throw new Error("Stripe not initialized. Call initialize() first.");
+    if (!mergedConfig.gameId && this.gameId) {
+      mergedConfig.gameId = Number(this.gameId);
     }
-    try {
-      const returnUrl = typeof window !== "undefined" ? `${window.location.href}${window.location.href.includes("?") ? "&" : "?"}payment=complete` : void 0;
-      this.log("info", `[BillingService] Creating checkout session with return URL: ${returnUrl}`);
-      const requestBody = {
-        priceId: productId,
-        // API expects priceId for Stripe
-        userId: this.config.userId,
-        gameId: this.config.gameId,
-        embedded: true,
-        // Enable embedded checkout
-        return_url: returnUrl
-      };
-      this.log("info", `[BillingService] Checkout session request:`, requestBody);
-      const response = await fetch(`${this.config.checkoutUrl}/create-checkout-session`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(requestBody)
-      });
-      this.log("info", `[BillingService] Checkout session response status: ${response.status}`);
-      if (!response.ok) {
-        const errorText = await response.text();
-        this.log("error", `[BillingService] Checkout session error: ${errorText}`);
-        throw new Error(`Failed to create checkout session: ${response.status} - ${errorText}`);
-      }
-      const responseData = await response.json();
-      this.log("info", `[BillingService] Checkout session created:`, responseData);
-      const { client_secret, id } = responseData;
-      if (!client_secret) {
-        throw new Error("No client_secret returned from checkout session");
-      }
-      await this.mountCheckoutElement(client_secret, elementId || "stripe-checkout-element");
-      return {
-        success: true,
-        productId,
-        transactionId: id
-      };
-    } catch (error) {
-      this.log("error", "[BillingService] Web purchase failed:", error);
-      return {
-        success: false,
-        productId,
-        error: {
-          code: "WEB_PURCHASE_FAILED",
-          message: error.message || "Purchase failed"
-        }
-      };
+    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();
   }
   /**
-   * Mount Stripe embedded checkout element to the DOM
-   * @param clientSecret - The client secret from the checkout session
-   * @param elementId - The ID of the DOM element to mount to
+   * Get the billing platform
+   * @returns Current billing platform
    */
-  async mountCheckoutElement(clientSecret, elementId) {
-    this.log("info", `[BillingService] Mounting checkout element to #${elementId}`);
-    if (!this.stripe) {
-      throw new Error("Stripe not initialized");
-    }
-    try {
-      const container = document.getElementById(elementId);
-      if (!container) {
-        throw new Error(`Element with id "${elementId}" not found in the DOM`);
-      }
-      container.innerHTML = "";
-      this.checkoutElement = await this.stripe.initEmbeddedCheckout({
-        clientSecret
-      });
-      this.checkoutElement.mount(`#${elementId}`);
-      this.log("info", "[BillingService] Checkout element mounted successfully");
-      this.setupCheckoutEventListeners();
-    } catch (error) {
-      this.log("error", "[BillingService] Failed to mount checkout element:", error);
-      throw error;
-    }
+  getBillingPlatform() {
+    return this.billingService.getPlatform();
   }
   /**
-   * Set up event listeners for checkout completion
+   * Check if billing is available
+   * @returns Boolean indicating if billing is available
    */
-  setupCheckoutEventListeners() {
-    if (typeof window !== "undefined") {
-      const urlParams = new URLSearchParams(window.location.search);
-      const paymentStatus = urlParams.get("payment");
-      if (paymentStatus === "complete") {
-        this.log("info", "[BillingService] Payment completed, processing result...");
-        const sessionId = urlParams.get("session_id");
-        if (this.onPurchaseCompleteCallback) {
-          this.onPurchaseCompleteCallback({
-            success: true,
-            productId: "",
-            // Would need to be tracked separately
-            transactionId: sessionId || void 0
-          });
-        }
-        urlParams.delete("payment");
-        urlParams.delete("session_id");
-        const newUrl = `${window.location.pathname}${urlParams.toString() ? "?" + urlParams.toString() : ""}`;
-        window.history.replaceState({}, "", newUrl);
-      }
-    }
+  isBillingAvailable() {
+    return this.billingService.isAvailable();
   }
   /**
-   * Unmount and destroy the checkout element
+   * Get available billing products
+   * @returns Promise resolving to array of products
    */
-  unmountCheckoutElement() {
-    if (this.checkoutElement) {
-      this.log("info", "[BillingService] Unmounting checkout element");
-      this.checkoutElement.unmount();
-      this.checkoutElement = null;
-    }
+  async getBillingProducts() {
+    return await this.billingService.getProducts();
+  }
+  /**
+   * Purchase a product
+   * @param productId Product ID to purchase
+   * @param options Optional purchase options (e.g., elementId for web)
+   * @returns Promise resolving to purchase result
+   */
+  async purchaseProduct(productId, options) {
+    return await this.billingService.purchase(productId, options);
   }
   /**
    * Set callback for successful purchases
+   * @param callback Function to call on purchase completion
    */
   onPurchaseComplete(callback) {
-    this.onPurchaseCompleteCallback = callback;
+    this.billingCallbacks.onComplete = callback;
+    this.billingService.onPurchaseComplete(callback);
   }
   /**
    * Set callback for failed purchases
+   * @param callback Function to call on purchase error
    */
   onPurchaseError(callback) {
-    this.onPurchaseErrorCallback = callback;
+    this.billingCallbacks.onError = callback;
+    this.billingService.onPurchaseError(callback);
   }
   /**
-   * Clean up resources
+   * Unmount Stripe checkout element
    */
-  dispose() {
-    this.log("info", "[BillingService] Disposing...");
-    if (this.platform === "native" /* NATIVE */) {
-      NativeBridge.off("IAP_AVAILABILITY_RESULT" /* IAP_AVAILABILITY_RESULT */);
-      NativeBridge.off("PRODUCTS_RESULT" /* PRODUCTS_RESULT */);
-      NativeBridge.off("PURCHASE_COMPLETE" /* PURCHASE_COMPLETE */);
-      NativeBridge.off("PURCHASE_ERROR" /* PURCHASE_ERROR */);
-    }
-    this.unmountCheckoutElement();
-    this.isInitialized = false;
-    this.nativeAvailable = false;
-    this.products = [];
-    this.stripe = null;
-    this.onPurchaseCompleteCallback = void 0;
-    this.onPurchaseErrorCallback = void 0;
+  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);
   }
 };
 export {