ton-provider-system 0.1.8 → 0.1.10

package/dist/index.cjs

@@ -952,13 +952,16 @@ var HealthChecker = class {
     const existing = this.results.get(key);
     const result = existing ? {
       ...existing,
+      success: true,
+      // Degraded providers are still usable, just slower/rate-limited
       status: "degraded",
       error: error || "Marked as degraded",
       lastTested: /* @__PURE__ */ new Date()
     } : {
       id: providerId,
       network,
-      success: false,
+      success: true,
+      // Degraded providers are still usable
       status: "degraded",
       latencyMs: null,
       seqno: null,
@@ -1572,6 +1575,8 @@ var ProviderSelector = class {
     this.autoSelect = true;
     this.customEndpoint = null;
     this.bestProviderByNetwork = /* @__PURE__ */ new Map();
+    // Track currently active provider per network (the one actually being used)
+    this.activeProviderByNetwork = /* @__PURE__ */ new Map();
     this.registry = registry;
     this.healthChecker = healthChecker;
     this.config = { ...DEFAULT_CONFIG2, ...config };
@@ -1590,6 +1595,7 @@ var ProviderSelector = class {
     if (!this.autoSelect && this.selectedProviderId) {
       const provider = this.registry.getProvider(this.selectedProviderId);
       if (provider && provider.network === network) {
+        this.activeProviderByNetwork.set(network, provider.id);
         return provider;
       }
       this.logger.warn(
@@ -1600,8 +1606,13 @@ var ProviderSelector = class {
     if (cachedBestId) {
       const cached = this.registry.getProvider(cachedBestId);
       const health = this.healthChecker.getResult(cachedBestId, network);
-      if (cached && health && health.success !== false && this.config.minStatus.includes(health.status)) {
+      if (cached && health && health.success !== false && health.success !== void 0 && // Explicitly check for undefined
+      this.config.minStatus.includes(health.status)) {
+        this.activeProviderByNetwork.set(network, cachedBestId);
         return cached;
+      } else {
+        this.bestProviderByNetwork.delete(network);
+        this.activeProviderByNetwork.delete(network);
       }
     }
     return this.findBestProvider(network);
@@ -1623,12 +1634,31 @@ var ProviderSelector = class {
       const defaults = this.registry.getDefaultOrderForNetwork(network);
       for (const defaultProvider of defaults) {
         const health = this.healthChecker.getResult(defaultProvider.id, network);
-        if (!health || health.status === "untested" || health.success === true) {
+        if (!health || health.status === "untested") {
+          this.logger.warn(
+            `No healthy providers for ${network}, using untested default: ${defaultProvider.id}`
+          );
+          this.activeProviderByNetwork.set(network, defaultProvider.id);
+          return defaultProvider;
+        }
+        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);
@@ -1636,20 +1666,34 @@ var ProviderSelector = class {
           this.logger.warn(
             `No tested healthy providers for ${network}, using untested: ${provider.id}`
           );
+          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;
     const bestHealth = this.healthChecker.getResult(best.id, network);
     if (bestHealth && bestHealth.success === true) {
       this.bestProviderByNetwork.set(network, best.id);
+      this.activeProviderByNetwork.set(network, best.id);
       this.logger.debug(
         `Best provider for ${network}: ${best.id} (score: ${scored[0].score.toFixed(2)})`
       );
     } else {
+      this.activeProviderByNetwork.set(network, best.id);
       this.logger.debug(
         `Best provider for ${network}: ${best.id} (score: ${scored[0].score.toFixed(2)}, untested)`
       );
@@ -1692,6 +1736,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") {
@@ -1789,9 +1840,16 @@ var ProviderSelector = class {
   }
   /**
    * Clear cached best providers (forces recalculation)
+   * @param network - Optional network to clear cache for. If not provided, clears all networks.
    */
-  clearCache() {
-    this.bestProviderByNetwork.clear();
+  clearCache(network) {
+    if (network) {
+      this.bestProviderByNetwork.delete(network);
+      this.activeProviderByNetwork.delete(network);
+    } else {
+      this.bestProviderByNetwork.clear();
+      this.activeProviderByNetwork.clear();
+    }
   }
   /**
    * Update best provider after health check
@@ -1806,8 +1864,16 @@ var ProviderSelector = class {
     if (this.bestProviderByNetwork.get(network) === providerId) {
       this.bestProviderByNetwork.delete(network);
     }
+    this.activeProviderByNetwork.delete(network);
     return this.getNextProvider(network, [providerId]);
   }
+  /**
+   * Get the currently active provider ID for a network
+   * (the one that was last selected and is being used)
+   */
+  getActiveProviderId(network) {
+    return this.activeProviderByNetwork.get(network) || null;
+  }
   // ========================================================================
   // Info
   // ========================================================================
@@ -2044,6 +2110,7 @@ var _ProviderManager = class _ProviderManager {
       this.options.logger.warn("No providers available, using fallback");
       return this.getFallbackEndpoint();
     }
+    this.selector.getActiveProviderId(this.network) || this.selector.getBestProvider(this.network);
     if (provider.isDynamic && provider.type === "orbs") {
       try {
         const { getHttpEndpoint } = await import('@orbs-network/ton-access');
@@ -2059,9 +2126,14 @@ var _ProviderManager = class _ProviderManager {
    * Get endpoint with rate limiting
    *
    * Waits for rate limit token before returning endpoint.
+   * 
+   * @param forceRefresh - If true, clears cache and forces re-selection
    */
-  async getEndpointWithRateLimit(timeoutMs) {
+  async getEndpointWithRateLimit(timeoutMs, forceRefresh = false) {
     this.ensureInitialized();
+    if (forceRefresh) {
+      this.selector.clearCache(this.network);
+    }
     const provider = this.selector.getBestProvider(this.network);
     if (!provider) {
       return this.getFallbackEndpoint();
@@ -2113,7 +2185,14 @@ var _ProviderManager = class _ProviderManager {
    */
   reportError(error) {
     if (!this.initialized || !this.network) return;
-    const provider = this.selector.getBestProvider(this.network);
+    const activeProviderId = this.selector.getActiveProviderId(this.network);
+    let provider = null;
+    if (activeProviderId) {
+      provider = this.registry.getProvider(activeProviderId) || null;
+    }
+    if (!provider) {
+      provider = this.selector.getBestProvider(this.network);
+    }
     if (!provider) return;
     const errorMsg = error instanceof Error ? error.message : String(error);
     const errorMsgLower = errorMsg.toLowerCase();
@@ -2132,6 +2211,7 @@ var _ProviderManager = class _ProviderManager {
       this.rateLimiter.reportError(provider.id);
       this.healthChecker.markDegraded(provider.id, this.network, errorMsg);
     }
+    this.selector.clearCache(this.network);
     this.selector.handleProviderFailure(provider.id, this.network);
     this.notifyListeners();
   }