ton-provider-system 0.1.9 → 0.1.11

package/dist/index.cjs

@@ -217,7 +217,8 @@ function resolveProvider(id, config) {
     apiKey,
     rps: config.rps,
     priority: config.priority,
-    isDynamic: config.isDynamic || false
+    isDynamic: config.isDynamic || false,
+    browserCompatible: config.browserCompatible !== void 0 ? config.browserCompatible : true
   };
 }
 function resolveAllProviders(config) {
@@ -776,7 +777,8 @@ var HealthChecker = class {
       latencyMs: null,
       seqno: null,
       blocksBehind: 0,
-      lastTested: null
+      lastTested: null,
+      browserCompatible: provider.browserCompatible
     };
     this.results.set(key, testingResult);
     try {
@@ -836,7 +838,8 @@ var HealthChecker = class {
         seqno,
         blocksBehind,
         lastTested: /* @__PURE__ */ new Date(),
-        cachedEndpoint: normalizedEndpoint
+        cachedEndpoint: normalizedEndpoint,
+        browserCompatible: provider.browserCompatible
       };
       this.results.set(key, result);
       this.logger.debug(
@@ -847,6 +850,7 @@ var HealthChecker = class {
       const endTime = performance.now();
       const latencyMs = Math.round(endTime - startTime);
       const errorMsg = error.message || String(error) || "Unknown error";
+      const isCorsError = this.isCorsError(error, errorMsg);
       const is429 = errorMsg.includes("429") || errorMsg.toLowerCase().includes("rate limit");
       const is404 = errorMsg.includes("404") || errorMsg.toLowerCase().includes("not found");
       const is503 = errorMsg.includes("503") || errorMsg.toLowerCase().includes("service unavailable");
@@ -861,6 +865,7 @@ var HealthChecker = class {
       } else if (isTimeout) {
         status = "offline";
       }
+      const browserCompatible = isCorsError ? false : provider.browserCompatible;
       const result = {
         id: provider.id,
         network: provider.network,
@@ -870,7 +875,8 @@ var HealthChecker = class {
         seqno: null,
         blocksBehind: 0,
         lastTested: /* @__PURE__ */ new Date(),
-        error: errorMsg
+        error: errorMsg,
+        browserCompatible
       };
       this.results.set(key, result);
       this.logger.warn(`Provider ${provider.id} health check failed: ${result.error}`);
@@ -952,21 +958,25 @@ var HealthChecker = class {
     const existing = this.results.get(key);
     const result = existing ? {
       ...existing,
-      success: false,
-      // CRITICAL: Always set success: false for degraded providers
+      success: true,
+      // Degraded providers are still usable, just slower/rate-limited
       status: "degraded",
       error: error || "Marked as degraded",
-      lastTested: /* @__PURE__ */ new Date()
+      lastTested: /* @__PURE__ */ new Date(),
+      browserCompatible: existing.browserCompatible ?? true
     } : {
       id: providerId,
       network,
-      success: false,
+      success: true,
+      // Degraded providers are still usable
       status: "degraded",
       latencyMs: null,
       seqno: null,
       blocksBehind: 0,
       lastTested: /* @__PURE__ */ new Date(),
-      error: error || "Marked as degraded"
+      error: error || "Marked as degraded",
+      browserCompatible: true
+      // Default to compatible if unknown
     };
     this.results.set(key, result);
   }
@@ -982,7 +992,8 @@ var HealthChecker = class {
       success: false,
       // Ensure success is false for offline providers
       error: error || "Marked as offline",
-      lastTested: /* @__PURE__ */ new Date()
+      lastTested: /* @__PURE__ */ new Date(),
+      browserCompatible: existing.browserCompatible ?? true
     } : {
       id: providerId,
       network,
@@ -992,7 +1003,9 @@ var HealthChecker = class {
       seqno: null,
       blocksBehind: 0,
       lastTested: /* @__PURE__ */ new Date(),
-      error: error || "Marked as offline"
+      error: error || "Marked as offline",
+      browserCompatible: true
+      // Default to compatible if unknown
     };
     this.results.set(key, result);
   }
@@ -1124,6 +1137,24 @@ var HealthChecker = class {
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
+  /**
+   * Detect CORS errors (browser compatibility issues)
+   * 
+   * CORS errors occur when:
+   * - Request header field is not allowed by Access-Control-Allow-Headers
+   * - Specifically, x-ton-client-version header is blocked by some providers
+   * - Error message contains "CORS", "Access-Control", or "x-ton-client-version"
+   */
+  isCorsError(error, errorMsg) {
+    const msg = errorMsg.toLowerCase();
+    if (msg.includes("cors") || msg.includes("access-control") || msg.includes("x-ton-client-version") || msg.includes("not allowed by access-control-allow-headers") || msg.includes("blocked by cors policy")) {
+      return true;
+    }
+    if (error.name === "TypeError" && (msg.includes("failed to fetch") || msg.includes("network error"))) {
+      return false;
+    }
+    return false;
+  }
 };
 function createHealthChecker(config, logger, rateLimiter) {
   return new HealthChecker(config, logger, rateLimiter);
@@ -1568,7 +1599,7 @@ var DEFAULT_CONFIG2 = {
   minStatus: ["available", "degraded"]
 };
 var ProviderSelector = class {
-  constructor(registry, healthChecker, config, logger) {
+  constructor(registry, healthChecker, config, logger, adapter = "node") {
     // Selection state
     this.selectedProviderId = null;
     this.autoSelect = true;
@@ -1580,6 +1611,7 @@ var ProviderSelector = class {
     this.healthChecker = healthChecker;
     this.config = { ...DEFAULT_CONFIG2, ...config };
     this.logger = logger || consoleLogger4;
+    this.adapter = adapter;
   }
   // ========================================================================
   // Selection Methods
@@ -1620,9 +1652,19 @@ var ProviderSelector = class {
    * Find the best provider for a network (recalculates)
    */
   findBestProvider(network) {
-    const providers = this.registry.getProvidersForNetwork(network);
+    let providers = this.registry.getProvidersForNetwork(network);
+    if (this.adapter === "browser") {
+      const beforeCount = providers.length;
+      providers = this.filterBrowserCompatible(providers, network);
+      const filteredCount = beforeCount - providers.length;
+      if (filteredCount > 0) {
+        this.logger.debug(
+          `Filtered out ${filteredCount} browser-incompatible provider(s) for ${network}`
+        );
+      }
+    }
     if (providers.length === 0) {
-      this.logger.warn(`No providers available for ${network}`);
+      this.logger.warn(`No browser-compatible providers available for ${network}`);
       return null;
     }
     const scored = providers.map((provider) => ({
@@ -1639,13 +1681,25 @@ var ProviderSelector = class {
           );
           this.activeProviderByNetwork.set(network, defaultProvider.id);
           return defaultProvider;
-        } else if (health.success === true) {
+        }
+        if (health.success === true) {
           this.logger.warn(
             `No healthy providers for ${network}, using default: ${defaultProvider.id}`
           );
           this.activeProviderByNetwork.set(network, defaultProvider.id);
           return defaultProvider;
         }
+        if (health.success === false && health.lastTested) {
+          const timeSinceFailure = Date.now() - health.lastTested.getTime();
+          const cooldownMs = 3e4;
+          if (timeSinceFailure > cooldownMs) {
+            this.logger.warn(
+              `No healthy providers for ${network}, retrying failed default after cooldown: ${defaultProvider.id}`
+            );
+            this.activeProviderByNetwork.set(network, defaultProvider.id);
+            return defaultProvider;
+          }
+        }
       }
       for (const provider of providers) {
         const health = this.healthChecker.getResult(provider.id, network);
@@ -1656,8 +1710,19 @@ var ProviderSelector = class {
           this.activeProviderByNetwork.set(network, provider.id);
           return provider;
         }
+        if (health.success === false && health.lastTested) {
+          const timeSinceFailure = Date.now() - health.lastTested.getTime();
+          const cooldownMs = 3e4;
+          if (timeSinceFailure > cooldownMs) {
+            this.logger.warn(
+              `No healthy providers for ${network}, retrying failed provider after cooldown: ${provider.id}`
+            );
+            this.activeProviderByNetwork.set(network, provider.id);
+            return provider;
+          }
+        }
       }
-      this.logger.error(`No available providers for ${network} (all tested and failed)`);
+      this.logger.error(`No available providers for ${network} (all tested and failed, cooldown active)`);
       return null;
     }
     const best = scored[0].provider;
@@ -1680,7 +1745,10 @@ var ProviderSelector = class {
    * Get all available providers for a network, sorted by score
    */
   getAvailableProviders(network) {
-    const providers = this.registry.getProvidersForNetwork(network);
+    let providers = this.registry.getProvidersForNetwork(network);
+    if (this.adapter === "browser") {
+      providers = this.filterBrowserCompatible(providers, network);
+    }
     return providers.map((provider) => ({
       provider,
       score: this.scoreProvider(provider, network)
@@ -1690,7 +1758,10 @@ var ProviderSelector = class {
    * Get the next best provider (for failover)
    */
   getNextProvider(network, excludeIds) {
-    const providers = this.registry.getProvidersForNetwork(network);
+    let providers = this.registry.getProvidersForNetwork(network);
+    if (this.adapter === "browser") {
+      providers = this.filterBrowserCompatible(providers, network);
+    }
     const available = providers.filter((p) => !excludeIds.includes(p.id)).map((provider) => ({
       provider,
       score: this.scoreProvider(provider, network)
@@ -1712,6 +1783,13 @@ var ProviderSelector = class {
       return 0.01 * (1 / (provider.priority + 1));
     }
     if (health.success === false) {
+      if (health.lastTested) {
+        const timeSinceFailure = Date.now() - health.lastTested.getTime();
+        const cooldownMs = 3e4;
+        if (timeSinceFailure > cooldownMs) {
+          return 1e-3 * (1 / (provider.priority + 1));
+        }
+      }
       return 0;
     }
     if (health.status === "offline") {
@@ -1874,12 +1952,39 @@ var ProviderSelector = class {
       endpointV2: this.customEndpoint,
       rps: 10,
       priority: 0,
-      isDynamic: false
+      isDynamic: false,
+      browserCompatible: true
+      // Custom endpoints are assumed compatible
     };
   }
+  /**
+   * Filter providers to only include browser-compatible ones
+   * 
+   * Checks both:
+   * 1. Provider config browserCompatible flag
+   * 2. Health check result browserCompatible flag (if health check was performed)
+   */
+  filterBrowserCompatible(providers, network) {
+    return providers.filter((provider) => {
+      if (!provider.browserCompatible) {
+        this.logger.debug(
+          `Provider ${provider.id} marked as browser-incompatible in config`
+        );
+        return false;
+      }
+      const health = this.healthChecker.getResult(provider.id, network);
+      if (health && health.browserCompatible === false) {
+        this.logger.debug(
+          `Provider ${provider.id} marked as browser-incompatible by health check (CORS error detected)`
+        );
+        return false;
+      }
+      return true;
+    });
+  }
 };
-function createSelector(registry, healthChecker, config, logger) {
-  return new ProviderSelector(registry, healthChecker, config, logger);
+function createSelector(registry, healthChecker, config, logger, adapter = "node") {
+  return new ProviderSelector(registry, healthChecker, config, logger, adapter);
 }
 
 // src/core/manager.ts
@@ -1986,7 +2091,8 @@ var _ProviderManager = class _ProviderManager {
       this.registry,
       this.healthChecker,
       void 0,
-      this.options.logger
+      this.options.logger,
+      this.options.adapter
     );
     this.initialized = true;
     this.notifyListeners();
@@ -2253,7 +2359,20 @@ var _ProviderManager = class _ProviderManager {
    */
   getProviders() {
     if (!this.initialized || !this.network) return [];
-    return this.registry.getProvidersForNetwork(this.network);
+    let providers = this.registry.getProvidersForNetwork(this.network);
+    if (this.options.adapter === "browser") {
+      providers = providers.filter((provider) => {
+        if (!provider.browserCompatible) {
+          return false;
+        }
+        const health = this.healthChecker.getResult(provider.id, this.network);
+        if (health && health.browserCompatible === false) {
+          return false;
+        }
+        return true;
+      });
+    }
+    return providers;
   }
   /**
    * Get provider health results for current network
@@ -2299,7 +2418,8 @@ var _ProviderManager = class _ProviderManager {
             latencyMs: null,
             seqno: null,
             blocksBehind: 0,
-            lastTested: null
+            lastTested: null,
+            browserCompatible: provider.browserCompatible
           },
           rateLimit: rateLimit || {
             tokens: 0,