ton-provider-system 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2696 @@
+'use strict';
+
+var zod = require('zod');
+var ton = require('@ton/ton');
+
+// src/types.ts
+var TimeoutError = class extends Error {
+  constructor(operation, timeoutMs, message) {
+    super(message || `Operation "${operation}" timed out after ${timeoutMs}ms`);
+    this.operation = operation;
+    this.timeoutMs = timeoutMs;
+    this.name = "TimeoutError";
+  }
+};
+var ProviderError = class extends Error {
+  constructor(providerId, operation, message, cause) {
+    super(`[${providerId}] ${operation}: ${message}`);
+    this.providerId = providerId;
+    this.operation = operation;
+    this.cause = cause;
+    this.name = "ProviderError";
+  }
+};
+var RateLimitError = class extends Error {
+  constructor(providerId, retryAfterMs) {
+    super(`Provider ${providerId} rate limited${retryAfterMs ? `, retry after ${retryAfterMs}ms` : ""}`);
+    this.providerId = providerId;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "RateLimitError";
+  }
+};
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+var NetworkSchema = zod.z.enum(["testnet", "mainnet"]);
+var ProviderTypeSchema = zod.z.enum([
+  "chainstack",
+  "quicknode",
+  "toncenter",
+  "orbs",
+  "onfinality",
+  "ankr",
+  "getblock",
+  "tatum",
+  "tonhub",
+  "custom"
+]);
+var ApiVersionSchema = zod.z.enum(["v2", "v3", "v4"]);
+var ProviderEndpointsSchema = zod.z.object({
+  v2: zod.z.string().url().optional(),
+  v3: zod.z.string().url().optional(),
+  v4: zod.z.string().url().optional(),
+  ws: zod.z.string().url().optional()
+}).refine(
+  (data) => data.v2 || data.v3 || data.v4,
+  { message: "At least one endpoint (v2, v3, or v4) must be provided" }
+);
+var ProviderConfigSchema = zod.z.object({
+  name: zod.z.string().min(1, "Provider name is required"),
+  type: ProviderTypeSchema,
+  network: NetworkSchema,
+  endpoints: ProviderEndpointsSchema,
+  keyEnvVar: zod.z.string().optional(),
+  apiKeyEnvVar: zod.z.string().optional(),
+  rps: zod.z.number().int().positive().default(1),
+  priority: zod.z.number().int().nonnegative().default(10),
+  enabled: zod.z.boolean().default(true),
+  isDynamic: zod.z.boolean().optional().default(false),
+  description: zod.z.string().optional()
+});
+var NetworkDefaultsSchema = zod.z.object({
+  testnet: zod.z.array(zod.z.string()).default([]),
+  mainnet: zod.z.array(zod.z.string()).default([])
+});
+var RpcConfigSchema = zod.z.object({
+  $schema: zod.z.string().optional(),
+  version: zod.z.string().default("1.0"),
+  providers: zod.z.record(zod.z.string(), ProviderConfigSchema),
+  defaults: NetworkDefaultsSchema
+}).refine(
+  (data) => {
+    const providerIds = Object.keys(data.providers);
+    const allDefaults = [...data.defaults.testnet, ...data.defaults.mainnet];
+    const invalidIds = allDefaults.filter((id) => !providerIds.includes(id));
+    return invalidIds.length === 0;
+  },
+  {
+    message: "Default provider IDs must reference existing providers"
+  }
+);
+function parseRpcConfig(data) {
+  const result = RpcConfigSchema.safeParse(data);
+  if (!result.success) {
+    const errors = result.error.errors.map((e) => {
+      const path = e.path.join(".");
+      return `  - ${path}: ${e.message}`;
+    }).join("\n");
+    throw new Error(`Invalid rpc.json configuration:
+${errors}`);
+  }
+  return result.data;
+}
+function parseProviderConfig(id, data) {
+  const result = ProviderConfigSchema.safeParse(data);
+  if (!result.success) {
+    const errors = result.error.errors.map((e) => {
+      const path = e.path.join(".");
+      return `${path}: ${e.message}`;
+    }).join(", ");
+    throw new Error(`Invalid provider "${id}": ${errors}`);
+  }
+  return result.data;
+}
+function createEmptyConfig() {
+  return {
+    version: "1.0",
+    providers: {},
+    defaults: {
+      testnet: [],
+      mainnet: []
+    }
+  };
+}
+function mergeConfigs(base, override) {
+  return {
+    ...base,
+    ...override,
+    providers: {
+      ...base.providers,
+      ...override.providers || {}
+    },
+    defaults: {
+      testnet: override.defaults?.testnet || base.defaults.testnet,
+      mainnet: override.defaults?.mainnet || base.defaults.mainnet
+    }
+  };
+}
+function isNetwork(value) {
+  return value === "testnet" || value === "mainnet";
+}
+function isProviderType(value) {
+  const types = [
+    "chainstack",
+    "quicknode",
+    "toncenter",
+    "orbs",
+    "onfinality",
+    "ankr",
+    "getblock",
+    "tatum",
+    "tonhub",
+    "custom"
+  ];
+  return typeof value === "string" && types.includes(value);
+}
+function isApiVersion(value) {
+  return value === "v2" || value === "v3" || value === "v4";
+}
+
+// src/config/parser.ts
+var RPC_CONFIG_FILENAME = "rpc.json";
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  if (typeof window !== "undefined" && window.__ENV__) {
+    return window.__ENV__[name];
+  }
+  return void 0;
+}
+function resolveKeyPlaceholder(url, keyEnvVar) {
+  if (!keyEnvVar || !url.includes("{key}")) {
+    return url;
+  }
+  const key = getEnvVar(keyEnvVar);
+  if (!key) {
+    console.warn(`[ConfigParser] Environment variable ${keyEnvVar} not set for URL: ${url}`);
+    return url;
+  }
+  return url.replace("{key}", key);
+}
+function resolveEndpoints(endpoints, keyEnvVar) {
+  return {
+    v2: endpoints.v2 ? resolveKeyPlaceholder(endpoints.v2, keyEnvVar) : void 0,
+    v3: endpoints.v3 ? resolveKeyPlaceholder(endpoints.v3, keyEnvVar) : void 0,
+    v4: endpoints.v4 ? resolveKeyPlaceholder(endpoints.v4, keyEnvVar) : void 0,
+    ws: endpoints.ws ? resolveKeyPlaceholder(endpoints.ws, keyEnvVar) : void 0
+  };
+}
+function resolveProvider(id, config) {
+  if (!config.enabled) {
+    return null;
+  }
+  const resolved = resolveEndpoints(config.endpoints, config.keyEnvVar);
+  if (!resolved.v2 && !resolved.v3 && !resolved.v4) {
+    console.warn(`[ConfigParser] Provider ${id} has no valid endpoints after resolution`);
+    return null;
+  }
+  const apiKey = config.apiKeyEnvVar ? getEnvVar(config.apiKeyEnvVar) : void 0;
+  return {
+    id,
+    name: config.name,
+    type: config.type,
+    network: config.network,
+    endpointV2: resolved.v2 || resolved.v3 || "",
+    // Fallback to v3 if v2 not available
+    endpointV3: resolved.v3,
+    endpointV4: resolved.v4,
+    endpointWs: resolved.ws,
+    apiKey,
+    rps: config.rps,
+    priority: config.priority,
+    isDynamic: config.isDynamic || false
+  };
+}
+function resolveAllProviders(config) {
+  const resolved = [];
+  for (const [id, providerConfig] of Object.entries(config.providers)) {
+    const provider = resolveProvider(id, providerConfig);
+    if (provider) {
+      resolved.push(provider);
+    }
+  }
+  return resolved;
+}
+function getProvidersForNetwork(config, network) {
+  const all = resolveAllProviders(config);
+  return all.filter((p) => p.network === network);
+}
+function getDefaultProvidersForNetwork(config, network) {
+  const defaultOrder = config.defaults[network];
+  const networkProviders = getProvidersForNetwork(config, network);
+  const inOrder = [];
+  const remaining = [];
+  for (const provider of networkProviders) {
+    const defaultIndex = defaultOrder.indexOf(provider.id);
+    if (defaultIndex !== -1) {
+      inOrder[defaultIndex] = provider;
+    } else {
+      remaining.push(provider);
+    }
+  }
+  const orderedProviders = inOrder.filter(Boolean);
+  remaining.sort((a, b) => a.priority - b.priority);
+  return [...orderedProviders, ...remaining];
+}
+async function loadBuiltinConfig() {
+  const fs = await import('fs').then((m) => m.promises);
+  const path = await import('path');
+  const possiblePaths = [
+    // When running from project root (e.g., ts-node scripts/...)
+    path.resolve(process.cwd(), "provider_system", RPC_CONFIG_FILENAME),
+    // When running from provider_system folder
+    path.resolve(process.cwd(), RPC_CONFIG_FILENAME),
+    // Relative to this file (CommonJS style)
+    path.resolve(__dirname, "..", RPC_CONFIG_FILENAME)
+  ];
+  for (const configPath of possiblePaths) {
+    try {
+      const content = await fs.readFile(configPath, "utf-8");
+      const data = JSON.parse(content);
+      return parseRpcConfig(data);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw new Error(`Failed to load RPC config from ${configPath}: ${error.message}`);
+      }
+    }
+  }
+  console.warn(`[ConfigParser] Config file ${RPC_CONFIG_FILENAME} not found, using defaults`);
+  return createDefaultConfig();
+}
+async function loadConfigFromUrl(url) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return parseRpcConfig(data);
+  } catch (error) {
+    throw new Error(`Failed to load RPC config from ${url}: ${error.message}`);
+  }
+}
+function loadConfigFromData(data) {
+  return parseRpcConfig(data);
+}
+async function loadConfig() {
+  if (typeof window !== "undefined" && window.__RPC_CONFIG__) {
+    return parseRpcConfig(window.__RPC_CONFIG__);
+  }
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return loadBuiltinConfig();
+  }
+  console.warn("[ConfigParser] No config source available, using defaults");
+  return createDefaultConfig();
+}
+var DEFAULT_PROVIDERS = {
+  toncenter_testnet: {
+    name: "TON Center Testnet",
+    type: "toncenter",
+    network: "testnet",
+    endpoints: {
+      v2: "https://testnet.toncenter.com/api/v2"
+    },
+    rps: 1,
+    // Without API key
+    priority: 100,
+    enabled: true,
+    description: "Official TON Center public endpoint"
+  },
+  orbs_testnet: {
+    name: "Orbs TON Access Testnet",
+    type: "orbs",
+    network: "testnet",
+    endpoints: {
+      v2: "https://ton-testnet.orbs.network/api/v2"
+    },
+    rps: 10,
+    priority: 50,
+    enabled: true,
+    isDynamic: true,
+    description: "Decentralized gateway - no API key needed"
+  },
+  toncenter_mainnet: {
+    name: "TON Center Mainnet",
+    type: "toncenter",
+    network: "mainnet",
+    endpoints: {
+      v2: "https://toncenter.com/api/v2"
+    },
+    rps: 1,
+    // Without API key
+    priority: 100,
+    enabled: true,
+    description: "Official TON Center public endpoint"
+  },
+  orbs_mainnet: {
+    name: "Orbs TON Access Mainnet",
+    type: "orbs",
+    network: "mainnet",
+    endpoints: {
+      v2: "https://ton-mainnet.orbs.network/api/v2"
+    },
+    rps: 10,
+    priority: 50,
+    enabled: true,
+    isDynamic: true,
+    description: "Decentralized gateway - no API key needed"
+  }
+};
+function createDefaultConfig() {
+  return {
+    version: "1.0",
+    providers: { ...DEFAULT_PROVIDERS },
+    defaults: {
+      testnet: ["orbs_testnet", "toncenter_testnet"],
+      mainnet: ["orbs_mainnet", "toncenter_mainnet"]
+    }
+  };
+}
+function mergeWithDefaults(config) {
+  const defaults = createDefaultConfig();
+  return {
+    ...config,
+    providers: {
+      ...defaults.providers,
+      ...config.providers
+    },
+    defaults: {
+      testnet: config.defaults.testnet.length > 0 ? config.defaults.testnet : defaults.defaults.testnet,
+      mainnet: config.defaults.mainnet.length > 0 ? config.defaults.mainnet : defaults.defaults.mainnet
+    }
+  };
+}
+
+// src/core/registry.ts
+var consoleLogger = {
+  debug: (msg, data) => console.debug(`[ProviderRegistry] ${msg}`, data || ""),
+  info: (msg, data) => console.log(`[ProviderRegistry] ${msg}`, data || ""),
+  warn: (msg, data) => console.warn(`[ProviderRegistry] ${msg}`, data || ""),
+  error: (msg, data) => console.error(`[ProviderRegistry] ${msg}`, data || "")
+};
+var ProviderRegistry = class {
+  constructor(config, logger) {
+    this.providers = /* @__PURE__ */ new Map();
+    this.config = config || createDefaultConfig();
+    this.logger = logger || consoleLogger;
+    this.loadProviders();
+  }
+  /**
+   * Load and resolve all providers from config
+   */
+  loadProviders() {
+    this.providers.clear();
+    const resolved = resolveAllProviders(this.config);
+    for (const provider of resolved) {
+      this.providers.set(provider.id, provider);
+    }
+    this.logger.info(`Loaded ${this.providers.size} providers`);
+  }
+  /**
+   * Get a provider by ID
+   */
+  getProvider(id) {
+    return this.providers.get(id);
+  }
+  /**
+   * Get all providers
+   */
+  getAllProviders() {
+    return Array.from(this.providers.values());
+  }
+  /**
+   * Get providers for a specific network
+   */
+  getProvidersForNetwork(network) {
+    return Array.from(this.providers.values()).filter(
+      (p) => p.network === network
+    );
+  }
+  /**
+   * Get providers in default order for a network
+   */
+  getDefaultOrderForNetwork(network) {
+    return getDefaultProvidersForNetwork(this.config, network);
+  }
+  /**
+   * Get providers by type
+   */
+  getProvidersByType(type) {
+    return Array.from(this.providers.values()).filter(
+      (p) => p.type === type
+    );
+  }
+  /**
+   * Get providers that have v2 API endpoints
+   */
+  getV2Providers() {
+    return Array.from(this.providers.values()).filter(
+      (p) => p.endpointV2 && p.endpointV2.length > 0
+    );
+  }
+  /**
+   * Get v2 providers for a specific network
+   */
+  getV2ProvidersForNetwork(network) {
+    return this.getProvidersForNetwork(network).filter(
+      (p) => p.endpointV2 && p.endpointV2.length > 0
+    );
+  }
+  /**
+   * Check if a provider exists
+   */
+  hasProvider(id) {
+    return this.providers.has(id);
+  }
+  /**
+   * Get provider count
+   */
+  get size() {
+    return this.providers.size;
+  }
+  /**
+   * Get the underlying config
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Update config and reload providers
+   */
+  updateConfig(config) {
+    this.config = config;
+    this.loadProviders();
+  }
+  /**
+   * Add or update a provider at runtime
+   */
+  setProvider(id, provider) {
+    this.providers.set(id, provider);
+    this.logger.debug(`Provider ${id} added/updated`);
+  }
+  /**
+   * Remove a provider
+   */
+  removeProvider(id) {
+    const removed = this.providers.delete(id);
+    if (removed) {
+      this.logger.debug(`Provider ${id} removed`);
+    }
+    return removed;
+  }
+  /**
+   * Get provider IDs
+   */
+  getProviderIds() {
+    return Array.from(this.providers.keys());
+  }
+  /**
+   * Get network default provider IDs
+   */
+  getDefaultProviderIds(network) {
+    return this.config.defaults[network];
+  }
+  /**
+   * Find provider by endpoint URL (useful for error reporting)
+   */
+  findProviderByEndpoint(endpoint) {
+    const normalizedEndpoint = endpoint.toLowerCase().replace(/\/jsonrpc$/i, "");
+    for (const provider of this.providers.values()) {
+      const v2Normalized = provider.endpointV2?.toLowerCase().replace(/\/jsonrpc$/i, "");
+      const v3Normalized = provider.endpointV3?.toLowerCase().replace(/\/jsonrpc$/i, "");
+      if (v2Normalized && normalizedEndpoint.includes(v2Normalized.split("/api/")[0])) {
+        return provider;
+      }
+      if (v3Normalized && normalizedEndpoint.includes(v3Normalized.split("/api/")[0])) {
+        return provider;
+      }
+    }
+    return void 0;
+  }
+};
+async function createRegistry(logger) {
+  const config = await loadConfig();
+  const mergedConfig = mergeWithDefaults(config);
+  return new ProviderRegistry(mergedConfig, logger);
+}
+async function createRegistryFromFile(_filePath, logger) {
+  return createRegistry(logger);
+}
+function createDefaultRegistry(logger) {
+  const config = createDefaultConfig();
+  return new ProviderRegistry(config, logger);
+}
+function createRegistryFromData(data, logger) {
+  const mergedConfig = mergeWithDefaults(data);
+  return new ProviderRegistry(mergedConfig, logger);
+}
+
+// src/utils/endpoint.ts
+function normalizeV2Endpoint(endpoint) {
+  let normalized = endpoint.trim();
+  if (normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  if (normalized.toLowerCase().endsWith("/jsonrpc")) {
+    return normalized;
+  }
+  if (normalized.endsWith("/api/v2")) {
+    return normalized + "/jsonRPC";
+  }
+  if (normalized.endsWith("/api/v3")) {
+    return normalized.replace("/api/v3", "/api/v2/jsonRPC");
+  }
+  try {
+    const url = new URL(normalized);
+    if (!url.pathname || url.pathname === "/") {
+      return normalized + "/jsonRPC";
+    }
+  } catch {
+  }
+  return normalized;
+}
+function toV2Base(endpoint) {
+  let normalized = endpoint.trim();
+  if (normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  if (normalized.toLowerCase().endsWith("/jsonrpc")) {
+    normalized = normalized.slice(0, -8);
+  }
+  normalized = normalized.replace(/\/api\/v3\b/, "/api/v2");
+  if (!normalized.endsWith("/api/v2")) {
+    if (normalized.includes("/api/v2")) {
+      const idx = normalized.indexOf("/api/v2");
+      normalized = normalized.slice(0, idx + 7);
+    }
+  }
+  return normalized;
+}
+function toV3Base(endpoint) {
+  let normalized = toV2Base(endpoint);
+  return normalized.replace("/api/v2", "/api/v3");
+}
+function getBaseUrl(endpoint) {
+  try {
+    const url = new URL(endpoint);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return endpoint;
+  }
+}
+function isChainstackUrl(url) {
+  try {
+    const parsed = new URL(url.trim());
+    return parsed.hostname.includes("chainstack.com");
+  } catch {
+    return false;
+  }
+}
+function isQuickNodeUrl(url) {
+  try {
+    const parsed = new URL(url.trim());
+    return parsed.hostname.includes("quiknode.pro");
+  } catch {
+    return false;
+  }
+}
+function isTonCenterUrl(url) {
+  try {
+    const parsed = new URL(url.trim());
+    return parsed.hostname.includes("toncenter.com");
+  } catch {
+    return false;
+  }
+}
+function isOrbsUrl(url) {
+  try {
+    const parsed = new URL(url.trim());
+    return parsed.hostname.includes("orbs.network") || parsed.hostname.includes("ton-access");
+  } catch {
+    return false;
+  }
+}
+function buildRestUrl(baseEndpoint, method) {
+  const base = toV2Base(baseEndpoint);
+  return `${base}/${method}`;
+}
+function buildGetAddressStateUrl(baseEndpoint, address) {
+  const base = toV2Base(baseEndpoint);
+  return `${base}/getAddressState?address=${encodeURIComponent(address)}`;
+}
+function buildGetAddressBalanceUrl(baseEndpoint, address) {
+  const base = toV2Base(baseEndpoint);
+  return `${base}/getAddressBalance?address=${encodeURIComponent(address)}`;
+}
+function buildGetAddressInfoUrl(baseEndpoint, address) {
+  const base = toV2Base(baseEndpoint);
+  return `${base}/getAddressInformation?address=${encodeURIComponent(address)}`;
+}
+function detectNetworkFromEndpoint(endpoint) {
+  const lower = endpoint.toLowerCase();
+  if (lower.includes("testnet") || lower.includes("test") || lower.includes("sandbox")) {
+    return "testnet";
+  }
+  if (lower.includes("mainnet") || lower.includes("main") || // TonCenter mainnet doesn't have 'mainnet' in URL
+  lower.includes("toncenter.com") && !lower.includes("testnet")) {
+    return "mainnet";
+  }
+  return null;
+}
+function isValidHttpUrl(str) {
+  try {
+    const url = new URL(str);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isValidWsUrl(str) {
+  try {
+    const url = new URL(str);
+    return url.protocol === "ws:" || url.protocol === "wss:";
+  } catch {
+    return false;
+  }
+}
+
+// src/core/healthChecker.ts
+var consoleLogger2 = {
+  debug: (msg, data) => console.debug(`[HealthChecker] ${msg}`, data || ""),
+  info: (msg, data) => console.log(`[HealthChecker] ${msg}`, data || ""),
+  warn: (msg, data) => console.warn(`[HealthChecker] ${msg}`, data || ""),
+  error: (msg, data) => console.error(`[HealthChecker] ${msg}`, data || "")
+};
+var DEFAULT_CONFIG = {
+  timeoutMs: 1e4,
+  maxBlocksBehind: 10,
+  degradedLatencyMs: 3e3
+};
+var HealthChecker = class {
+  constructor(config, logger) {
+    this.results = /* @__PURE__ */ new Map();
+    this.highestSeqno = /* @__PURE__ */ new Map();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.logger = logger || consoleLogger2;
+  }
+  /**
+   * Test a single provider's health
+   */
+  async testProvider(provider) {
+    const startTime = performance.now();
+    const key = this.getResultKey(provider.id, provider.network);
+    const testingResult = {
+      id: provider.id,
+      network: provider.network,
+      success: false,
+      status: "testing",
+      latencyMs: null,
+      seqno: null,
+      blocksBehind: 0,
+      lastTested: null
+    };
+    this.results.set(key, testingResult);
+    try {
+      const endpoint = await this.getEndpoint(provider);
+      if (!endpoint) {
+        throw new Error("No valid endpoint available");
+      }
+      const normalizedEndpoint = normalizeV2Endpoint(endpoint);
+      const info = await this.callGetMasterchainInfo(normalizedEndpoint);
+      const endTime = performance.now();
+      const latencyMs = Math.round(endTime - startTime);
+      const seqno = info.last?.seqno || 0;
+      const currentHighest = this.highestSeqno.get(provider.network) || 0;
+      if (seqno > currentHighest) {
+        this.highestSeqno.set(provider.network, seqno);
+      }
+      const blocksBehind = Math.max(0, (this.highestSeqno.get(provider.network) || seqno) - seqno);
+      let status = "available";
+      if (blocksBehind > this.config.maxBlocksBehind) {
+        status = "stale";
+      } else if (latencyMs > this.config.degradedLatencyMs) {
+        status = "degraded";
+      }
+      const result = {
+        id: provider.id,
+        network: provider.network,
+        success: true,
+        status,
+        latencyMs,
+        seqno,
+        blocksBehind,
+        lastTested: /* @__PURE__ */ new Date(),
+        cachedEndpoint: normalizedEndpoint
+      };
+      this.results.set(key, result);
+      this.logger.debug(
+        `Provider ${provider.id} health check: ${status} (${latencyMs}ms, seqno=${seqno}, behind=${blocksBehind})`
+      );
+      return result;
+    } catch (error) {
+      const endTime = performance.now();
+      const latencyMs = Math.round(endTime - startTime);
+      const errorMsg = error.message || String(error) || "Unknown error";
+      const is429 = errorMsg.includes("429") || errorMsg.toLowerCase().includes("rate limit");
+      const is404 = errorMsg.includes("404") || errorMsg.toLowerCase().includes("not found");
+      const isTimeout = error.name === "AbortError" || errorMsg.includes("timeout");
+      let status = "offline";
+      if (is429) {
+        status = "degraded";
+      } else if (is404) {
+        status = "offline";
+      } else if (isTimeout) {
+        status = "offline";
+      }
+      const result = {
+        id: provider.id,
+        network: provider.network,
+        success: false,
+        status,
+        latencyMs: isTimeout ? null : latencyMs,
+        seqno: null,
+        blocksBehind: 0,
+        lastTested: /* @__PURE__ */ new Date(),
+        error: errorMsg
+      };
+      this.results.set(key, result);
+      this.logger.warn(`Provider ${provider.id} health check failed: ${result.error}`);
+      return result;
+    }
+  }
+  /**
+   * Test multiple providers in parallel with staggered batches
+   */
+  async testProviders(providers, batchSize = 2, batchDelayMs = 300) {
+    const results = [];
+    for (let i = 0; i < providers.length; i += batchSize) {
+      const batch = providers.slice(i, i + batchSize);
+      const batchResults = await Promise.all(
+        batch.map((p) => this.testProvider(p))
+      );
+      results.push(...batchResults);
+      if (i + batchSize < providers.length && batchDelayMs > 0) {
+        await this.sleep(batchDelayMs);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get the last health result for a provider
+   */
+  getResult(providerId, network) {
+    const key = this.getResultKey(providerId, network);
+    return this.results.get(key);
+  }
+  /**
+   * Get all results for a network
+   */
+  getResultsForNetwork(network) {
+    const results = [];
+    for (const [key, result] of this.results) {
+      if (result.network === network) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get available providers for a network (status = available or degraded)
+   */
+  getAvailableProviders(network) {
+    return this.getResultsForNetwork(network).filter(
+      (r) => r.status === "available" || r.status === "degraded"
+    );
+  }
+  /**
+   * Get the best provider for a network (lowest latency among available)
+   */
+  getBestProvider(network) {
+    const available = this.getAvailableProviders(network).filter((r) => r.latencyMs !== null).sort((a, b) => (a.latencyMs ?? Infinity) - (b.latencyMs ?? Infinity));
+    return available[0];
+  }
+  /**
+   * Get highest known seqno for a network
+   */
+  getHighestSeqno(network) {
+    return this.highestSeqno.get(network) || 0;
+  }
+  /**
+   * Clear all results
+   */
+  clearResults() {
+    this.results.clear();
+    this.highestSeqno.clear();
+  }
+  /**
+   * Mark a provider as degraded (e.g., on 429 error)
+   */
+  markDegraded(providerId, network, error) {
+    const key = this.getResultKey(providerId, network);
+    const existing = this.results.get(key);
+    if (existing) {
+      this.results.set(key, {
+        ...existing,
+        status: "degraded",
+        error: error || "Marked as degraded",
+        lastTested: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  /**
+   * Mark a provider as offline
+   */
+  markOffline(providerId, network, error) {
+    const key = this.getResultKey(providerId, network);
+    const existing = this.results.get(key);
+    if (existing) {
+      this.results.set(key, {
+        ...existing,
+        status: "offline",
+        error: error || "Marked as offline",
+        lastTested: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  // ========================================================================
+  // Private Methods
+  // ========================================================================
+  getResultKey(providerId, network) {
+    return `${providerId}-${network}`;
+  }
+  /**
+   * Get endpoint URL for a provider (handles dynamic providers like Orbs)
+   */
+  async getEndpoint(provider) {
+    if (provider.isDynamic && provider.type === "orbs") {
+      try {
+        const { getHttpEndpoint } = await import('@orbs-network/ton-access');
+        const endpoint = await getHttpEndpoint({ network: provider.network });
+        return endpoint;
+      } catch (error) {
+        this.logger.warn(`Failed to get Orbs endpoint: ${error.message}`);
+        return null;
+      }
+    }
+    return provider.endpointV2 || provider.endpointV3 || null;
+  }
+  /**
+   * Call getMasterchainInfo API
+   */
+  async callGetMasterchainInfo(endpoint) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeoutMs);
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          id: "1",
+          jsonrpc: "2.0",
+          method: "getMasterchainInfo",
+          params: {}
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const data = await response.json();
+      if (data && typeof data === "object" && "ok" in data) {
+        if (!data.ok) {
+          throw new Error(data.error || "API returned ok=false");
+        }
+        return data.result || data;
+      }
+      if (data.result) {
+        return data.result;
+      }
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createHealthChecker(config, logger) {
+  return new HealthChecker(config, logger);
+}
+
+// src/utils/timeout.ts
+var DEFAULT_PROVIDER_TIMEOUT_MS = 3e4;
+var DEFAULT_CONTRACT_TIMEOUT_MS = 45e3;
+var DEFAULT_HEALTH_CHECK_TIMEOUT_MS = 1e4;
+async function withTimeout(promise, timeoutMs, operationName) {
+  const timeoutPromise = new Promise((_, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new TimeoutError(operationName, timeoutMs));
+    }, timeoutMs);
+    promise.finally(() => clearTimeout(timeoutId));
+  });
+  return Promise.race([promise, timeoutPromise]);
+}
+async function withTimeoutFn(fn, timeoutMs, operationName) {
+  return withTimeout(fn(), timeoutMs, operationName);
+}
+function createTimeoutController(timeoutMs) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  return {
+    controller,
+    clear: () => clearTimeout(timeoutId)
+  };
+}
+async function fetchWithTimeout(url, options, timeoutMs) {
+  const { controller, clear } = createTimeoutController(timeoutMs);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    return response;
+  } catch (error) {
+    if (error.name === "AbortError") {
+      throw new TimeoutError(url, timeoutMs, `Fetch to ${url} timed out after ${timeoutMs}ms`);
+    }
+    throw error;
+  } finally {
+    clear();
+  }
+}
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 1e4,
+  backoffMultiplier: 2
+};
+async function withRetry(fn, options) {
+  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
+  let lastError = null;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (opts.isRetryable && !opts.isRetryable(error)) {
+        throw error;
+      }
+      if (attempt < opts.maxRetries) {
+        const delay = Math.min(
+          opts.baseDelayMs * Math.pow(opts.backoffMultiplier, attempt),
+          opts.maxDelayMs
+        );
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+async function withTimeoutAndRetry(fn, timeoutMs, operationName, retryOptions) {
+  return withRetry(
+    () => withTimeout(fn(), timeoutMs, operationName),
+    {
+      ...retryOptions,
+      isRetryable: (error) => {
+        if (error instanceof TimeoutError) {
+          return true;
+        }
+        if (retryOptions?.isRetryable) {
+          return retryOptions.isRetryable(error);
+        }
+        const message = error.message?.toLowerCase() || "";
+        return message.includes("network") || message.includes("fetch") || message.includes("econnrefused") || message.includes("etimedout");
+      }
+    }
+  );
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isTimeoutError(error) {
+  return error instanceof TimeoutError;
+}
+function isRateLimitError(error) {
+  if (!error) return false;
+  const message = error.message?.toLowerCase() || "";
+  const status = error.status || error.response?.status;
+  return status === 429 || message.includes("rate limit") || message.includes("429");
+}
+
+// src/core/rateLimiter.ts
+var consoleLogger3 = {
+  debug: (msg, data) => console.debug(`[RateLimiter] ${msg}`, data || ""),
+  info: (msg, data) => console.log(`[RateLimiter] ${msg}`, data || ""),
+  warn: (msg, data) => console.warn(`[RateLimiter] ${msg}`, data || ""),
+  error: (msg, data) => console.error(`[RateLimiter] ${msg}`, data || "")
+};
+var DEFAULT_RATE_LIMIT = {
+  rps: 1,
+  burstSize: 3,
+  minDelayMs: 1e3,
+  backoffMultiplier: 2,
+  maxBackoffMs: 3e4
+};
+var CHAINSTACK_RATE_LIMIT = {
+  rps: 25,
+  burstSize: 30,
+  minDelayMs: 40,
+  backoffMultiplier: 2,
+  maxBackoffMs: 1e4
+};
+var QUICKNODE_RATE_LIMIT = {
+  rps: 10,
+  burstSize: 15,
+  minDelayMs: 100,
+  backoffMultiplier: 2,
+  maxBackoffMs: 1e4
+};
+var ORBS_RATE_LIMIT = {
+  rps: 10,
+  burstSize: 20,
+  minDelayMs: 100,
+  backoffMultiplier: 2,
+  maxBackoffMs: 1e4
+};
+function getRateLimitForType(type) {
+  switch (type.toLowerCase()) {
+    case "chainstack":
+      return CHAINSTACK_RATE_LIMIT;
+    case "quicknode":
+      return QUICKNODE_RATE_LIMIT;
+    case "orbs":
+      return ORBS_RATE_LIMIT;
+    default:
+      return DEFAULT_RATE_LIMIT;
+  }
+}
+var TokenBucketRateLimiter = class {
+  constructor(config, logger) {
+    this.currentBackoff = 0;
+    this.consecutiveErrors = 0;
+    this.requestQueue = [];
+    this.processing = false;
+    this.config = { ...DEFAULT_RATE_LIMIT, ...config };
+    this.tokens = this.config.burstSize;
+    this.lastRefill = Date.now();
+    this.logger = logger || consoleLogger3;
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    this.refill();
+    return {
+      tokens: this.tokens,
+      lastRefill: this.lastRefill,
+      currentBackoff: this.currentBackoff,
+      consecutiveErrors: this.consecutiveErrors,
+      processing: this.processing,
+      queueLength: this.requestQueue.length
+    };
+  }
+  /**
+   * Acquire a token (wait if necessary)
+   *
+   * @param timeoutMs - Maximum time to wait for a token (default: 60s)
+   * @returns true if token acquired, false if timeout
+   */
+  async acquire(timeoutMs = 6e4) {
+    const startTime = Date.now();
+    if (this.processing) {
+      const acquired = await new Promise((resolve) => {
+        const checkTimeout = () => {
+          if (Date.now() - startTime > timeoutMs) {
+            const idx = this.requestQueue.indexOf(resolveCallback);
+            if (idx >= 0) {
+              this.requestQueue.splice(idx, 1);
+            }
+            resolve(false);
+          }
+        };
+        const resolveCallback = () => resolve(true);
+        this.requestQueue.push(resolveCallback);
+        const timeoutInterval = setInterval(checkTimeout, 1e3);
+        const cleanup = () => clearInterval(timeoutInterval);
+        Promise.resolve().then(() => {
+          if (this.requestQueue.includes(resolveCallback)) ; else {
+            cleanup();
+          }
+        });
+      });
+      if (!acquired) {
+        return false;
+      }
+    }
+    this.processing = true;
+    try {
+      this.refill();
+      if (this.currentBackoff > 0) {
+        this.logger.debug(`Applying backoff: ${this.currentBackoff}ms`);
+        await sleep(this.currentBackoff);
+      }
+      while (this.tokens <= 0) {
+        if (Date.now() - startTime > timeoutMs) {
+          return false;
+        }
+        await sleep(Math.min(100, this.config.minDelayMs));
+        this.refill();
+      }
+      this.tokens--;
+      const timeSinceLastRefill = Date.now() - this.lastRefill;
+      if (timeSinceLastRefill < this.config.minDelayMs) {
+        await sleep(this.config.minDelayMs - timeSinceLastRefill);
+      }
+      this.lastRefill = Date.now();
+      return true;
+    } finally {
+      this.processing = false;
+      if (this.requestQueue.length > 0) {
+        const next = this.requestQueue.shift();
+        next();
+      }
+    }
+  }
+  /**
+   * Release a token (call on request completion)
+   */
+  release() {
+  }
+  /**
+   * Report a successful request (resets backoff)
+   */
+  reportSuccess() {
+    this.currentBackoff = 0;
+    this.consecutiveErrors = 0;
+  }
+  /**
+   * Report a rate limit error (applies backoff)
+   */
+  reportRateLimitError() {
+    this.consecutiveErrors++;
+    if (this.currentBackoff === 0) {
+      this.currentBackoff = this.config.minDelayMs * this.config.backoffMultiplier;
+    } else {
+      this.currentBackoff = Math.min(
+        this.currentBackoff * this.config.backoffMultiplier,
+        this.config.maxBackoffMs
+      );
+    }
+    this.logger.warn(`Rate limit hit, backoff: ${this.currentBackoff}ms, errors: ${this.consecutiveErrors}`);
+  }
+  /**
+   * Report a general error
+   */
+  reportError() {
+    this.consecutiveErrors++;
+    if (this.consecutiveErrors >= 3) {
+      this.currentBackoff = Math.min(
+        this.config.minDelayMs * this.consecutiveErrors,
+        this.config.maxBackoffMs / 2
+      );
+    }
+  }
+  /**
+   * Reset rate limiter state
+   */
+  reset() {
+    this.tokens = this.config.burstSize;
+    this.lastRefill = Date.now();
+    this.currentBackoff = 0;
+    this.consecutiveErrors = 0;
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    if (this.tokens > this.config.burstSize) {
+      this.tokens = this.config.burstSize;
+    }
+  }
+  /**
+   * Refill tokens based on time elapsed
+   */
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    const tokensToAdd = Math.floor(elapsed / 1e3 * this.config.rps);
+    if (tokensToAdd > 0) {
+      this.tokens = Math.min(this.config.burstSize, this.tokens + tokensToAdd);
+      this.lastRefill = now;
+    }
+  }
+};
+var RateLimiterManager = class {
+  constructor(logger) {
+    this.limiters = /* @__PURE__ */ new Map();
+    this.configs = /* @__PURE__ */ new Map();
+    this.logger = logger || consoleLogger3;
+  }
+  /**
+   * Get or create rate limiter for a provider
+   */
+  getLimiter(providerId, config) {
+    let limiter = this.limiters.get(providerId);
+    if (!limiter) {
+      const savedConfig = this.configs.get(providerId);
+      limiter = new TokenBucketRateLimiter(
+        { ...savedConfig, ...config },
+        this.logger
+      );
+      this.limiters.set(providerId, limiter);
+    }
+    return limiter;
+  }
+  /**
+   * Set rate limit config for a provider
+   */
+  setConfig(providerId, config) {
+    this.configs.set(providerId, config);
+    const limiter = this.limiters.get(providerId);
+    if (limiter) {
+      limiter.updateConfig(config);
+    }
+  }
+  /**
+   * Get rate limit state for a provider
+   */
+  getState(providerId) {
+    const limiter = this.limiters.get(providerId);
+    return limiter ? limiter.getState() : null;
+  }
+  /**
+   * Acquire token for a provider
+   */
+  async acquire(providerId, timeoutMs) {
+    const limiter = this.getLimiter(providerId);
+    return limiter.acquire(timeoutMs);
+  }
+  /**
+   * Report success for a provider
+   */
+  reportSuccess(providerId) {
+    const limiter = this.limiters.get(providerId);
+    if (limiter) {
+      limiter.reportSuccess();
+    }
+  }
+  /**
+   * Report rate limit error for a provider
+   */
+  reportRateLimitError(providerId) {
+    const limiter = this.getLimiter(providerId);
+    limiter.reportRateLimitError();
+  }
+  /**
+   * Report general error for a provider
+   */
+  reportError(providerId) {
+    const limiter = this.getLimiter(providerId);
+    limiter.reportError();
+  }
+  /**
+   * Reset a provider's rate limiter
+   */
+  reset(providerId) {
+    const limiter = this.limiters.get(providerId);
+    if (limiter) {
+      limiter.reset();
+    }
+  }
+  /**
+   * Reset all rate limiters
+   */
+  resetAll() {
+    for (const limiter of this.limiters.values()) {
+      limiter.reset();
+    }
+  }
+  /**
+   * Remove a provider's rate limiter
+   */
+  remove(providerId) {
+    this.limiters.delete(providerId);
+    this.configs.delete(providerId);
+  }
+  /**
+   * Clear all limiters
+   */
+  clear() {
+    this.limiters.clear();
+    this.configs.clear();
+  }
+};
+function createRateLimiter(rps, logger) {
+  return new TokenBucketRateLimiter(
+    {
+      rps,
+      burstSize: Math.max(3, Math.ceil(rps * 1.5)),
+      minDelayMs: Math.ceil(1e3 / rps),
+      backoffMultiplier: 2,
+      maxBackoffMs: 3e4
+    },
+    logger
+  );
+}
+function createRateLimiterManager(logger) {
+  return new RateLimiterManager(logger);
+}
+
+// src/core/selector.ts
+var consoleLogger4 = {
+  debug: (msg, data) => console.debug(`[ProviderSelector] ${msg}`, data || ""),
+  info: (msg, data) => console.log(`[ProviderSelector] ${msg}`, data || ""),
+  warn: (msg, data) => console.warn(`[ProviderSelector] ${msg}`, data || ""),
+  error: (msg, data) => console.error(`[ProviderSelector] ${msg}`, data || "")
+};
+var DEFAULT_CONFIG2 = {
+  preferredLatencyMs: 1e3,
+  latencyWeight: 0.4,
+  priorityWeight: 0.3,
+  freshnessWeight: 0.3,
+  minStatus: ["available", "degraded"]
+};
+var ProviderSelector = class {
+  constructor(registry, healthChecker, config, logger) {
+    // Selection state
+    this.selectedProviderId = null;
+    this.autoSelect = true;
+    this.customEndpoint = null;
+    this.bestProviderByNetwork = /* @__PURE__ */ new Map();
+    this.registry = registry;
+    this.healthChecker = healthChecker;
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+    this.logger = logger || consoleLogger4;
+  }
+  // ========================================================================
+  // Selection Methods
+  // ========================================================================
+  /**
+   * Get the best provider for a network
+   */
+  getBestProvider(network) {
+    if (this.customEndpoint) {
+      return this.createCustomProvider(network);
+    }
+    if (!this.autoSelect && this.selectedProviderId) {
+      const provider = this.registry.getProvider(this.selectedProviderId);
+      if (provider && provider.network === network) {
+        return provider;
+      }
+      this.logger.warn(
+        `Selected provider ${this.selectedProviderId} not found or wrong network, using auto-select`
+      );
+    }
+    const cachedBestId = this.bestProviderByNetwork.get(network);
+    if (cachedBestId) {
+      const cached = this.registry.getProvider(cachedBestId);
+      const health = this.healthChecker.getResult(cachedBestId, network);
+      if (cached && health && this.config.minStatus.includes(health.status)) {
+        return cached;
+      }
+    }
+    return this.findBestProvider(network);
+  }
+  /**
+   * Find the best provider for a network (recalculates)
+   */
+  findBestProvider(network) {
+    const providers = this.registry.getProvidersForNetwork(network);
+    if (providers.length === 0) {
+      this.logger.warn(`No providers available for ${network}`);
+      return null;
+    }
+    const scored = providers.map((provider) => ({
+      provider,
+      score: this.scoreProvider(provider, network)
+    })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
+    if (scored.length === 0) {
+      const defaults = this.registry.getDefaultOrderForNetwork(network);
+      if (defaults.length > 0) {
+        this.logger.warn(`No healthy providers for ${network}, using first default`);
+        return defaults[0];
+      }
+      return providers[0];
+    }
+    const best = scored[0].provider;
+    this.bestProviderByNetwork.set(network, best.id);
+    this.logger.debug(
+      `Best provider for ${network}: ${best.id} (score: ${scored[0].score.toFixed(2)})`
+    );
+    return best;
+  }
+  /**
+   * Get all available providers for a network, sorted by score
+   */
+  getAvailableProviders(network) {
+    const providers = this.registry.getProvidersForNetwork(network);
+    return providers.map((provider) => ({
+      provider,
+      score: this.scoreProvider(provider, network)
+    })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score).map((item) => item.provider);
+  }
+  /**
+   * Get the next best provider (for failover)
+   */
+  getNextProvider(network, excludeIds) {
+    const providers = this.registry.getProvidersForNetwork(network);
+    const available = providers.filter((p) => !excludeIds.includes(p.id)).map((provider) => ({
+      provider,
+      score: this.scoreProvider(provider, network)
+    })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
+    if (available.length === 0) {
+      return null;
+    }
+    return available[0].provider;
+  }
+  // ========================================================================
+  // Scoring
+  // ========================================================================
+  /**
+   * Calculate a score for a provider (higher is better)
+   */
+  scoreProvider(provider, network) {
+    const health = this.healthChecker.getResult(provider.id, network);
+    if (!health || health.status === "untested") {
+      return 0.1 * (1 / (provider.priority + 1));
+    }
+    if (health.success === false) {
+      return 0;
+    }
+    if (health.status === "offline") {
+      return 0;
+    }
+    if (!this.config.minStatus.includes(health.status)) {
+      return 0;
+    }
+    const statusScore = this.getStatusScore(health.status);
+    const latencyScore = this.getLatencyScore(health.latencyMs);
+    const priorityScore = this.getPriorityScore(provider.priority);
+    const freshnessScore = this.getFreshnessScore(health.blocksBehind);
+    const score = statusScore * 0.2 + // Base status score
+    latencyScore * this.config.latencyWeight + priorityScore * this.config.priorityWeight + freshnessScore * this.config.freshnessWeight;
+    return score;
+  }
+  getStatusScore(status) {
+    switch (status) {
+      case "available":
+        return 1;
+      case "degraded":
+        return 0.5;
+      case "stale":
+        return 0.3;
+      default:
+        return 0;
+    }
+  }
+  getLatencyScore(latencyMs) {
+    if (latencyMs === null) {
+      return 0.5;
+    }
+    const ratio = latencyMs / this.config.preferredLatencyMs;
+    return Math.max(0, 1 - Math.log(ratio + 1) / Math.log(11));
+  }
+  getPriorityScore(priority) {
+    return Math.max(0, 1 - priority / 100);
+  }
+  getFreshnessScore(blocksBehind) {
+    return Math.max(0, 1 - blocksBehind / 10);
+  }
+  // ========================================================================
+  // Selection Control
+  // ========================================================================
+  /**
+   * Set manual provider selection
+   */
+  setSelectedProvider(providerId) {
+    this.selectedProviderId = providerId;
+    if (providerId !== null) {
+      this.autoSelect = false;
+    }
+    this.logger.info(`Selected provider: ${providerId || "(auto)"}`);
+  }
+  /**
+   * Get currently selected provider ID
+   */
+  getSelectedProviderId() {
+    return this.selectedProviderId;
+  }
+  /**
+   * Enable/disable auto-selection
+   */
+  setAutoSelect(enabled) {
+    this.autoSelect = enabled;
+    if (enabled) {
+      this.selectedProviderId = null;
+    }
+    this.logger.info(`Auto-select: ${enabled}`);
+  }
+  /**
+   * Check if auto-selection is enabled
+   */
+  isAutoSelectEnabled() {
+    return this.autoSelect;
+  }
+  /**
+   * Set custom endpoint override
+   */
+  setCustomEndpoint(endpoint) {
+    this.customEndpoint = endpoint?.trim() || null;
+    this.logger.info(`Custom endpoint: ${this.customEndpoint || "(none)"}`);
+  }
+  /**
+   * Get custom endpoint
+   */
+  getCustomEndpoint() {
+    return this.customEndpoint;
+  }
+  /**
+   * Check if using custom endpoint
+   */
+  isUsingCustomEndpoint() {
+    return this.customEndpoint !== null && this.customEndpoint.length > 0;
+  }
+  /**
+   * Clear cached best providers (forces recalculation)
+   */
+  clearCache() {
+    this.bestProviderByNetwork.clear();
+  }
+  /**
+   * Update best provider after health check
+   */
+  updateBestProvider(network) {
+    this.findBestProvider(network);
+  }
+  /**
+   * Handle provider failure (switch to next best)
+   */
+  handleProviderFailure(providerId, network) {
+    if (this.bestProviderByNetwork.get(network) === providerId) {
+      this.bestProviderByNetwork.delete(network);
+    }
+    return this.getNextProvider(network, [providerId]);
+  }
+  // ========================================================================
+  // Info
+  // ========================================================================
+  /**
+   * Get active provider info
+   */
+  getActiveProviderInfo(network) {
+    if (this.customEndpoint) {
+      return { id: "custom", name: "Custom Endpoint", isCustom: true };
+    }
+    const provider = this.getBestProvider(network);
+    if (provider) {
+      return { id: provider.id, name: provider.name, isCustom: false };
+    }
+    return null;
+  }
+  // ========================================================================
+  // Private Helpers
+  // ========================================================================
+  /**
+   * Create a pseudo-provider for custom endpoint
+   */
+  createCustomProvider(network) {
+    return {
+      id: "custom",
+      name: "Custom Endpoint",
+      type: "custom",
+      network,
+      endpointV2: this.customEndpoint,
+      rps: 10,
+      priority: 0,
+      isDynamic: false
+    };
+  }
+};
+function createSelector(registry, healthChecker, config, logger) {
+  return new ProviderSelector(registry, healthChecker, config, logger);
+}
+
+// src/core/manager.ts
+var consoleLogger5 = {
+  debug: (msg, data) => console.debug(`[ProviderManager] ${msg}`, data || ""),
+  info: (msg, data) => console.log(`[ProviderManager] ${msg}`, data || ""),
+  warn: (msg, data) => console.warn(`[ProviderManager] ${msg}`, data || ""),
+  error: (msg, data) => console.error(`[ProviderManager] ${msg}`, data || "")
+};
+var DEFAULT_OPTIONS = {
+  configPath: "",
+  // Unused - config is loaded from provider_system/rpc.json
+  adapter: "node",
+  autoInit: true,
+  requestTimeoutMs: 1e4,
+  healthCheckIntervalMs: 0,
+  // Disabled by default
+  maxBlocksBehind: 10,
+  logger: consoleLogger5
+};
+var _ProviderManager = class _ProviderManager {
+  constructor(options) {
+    // Components
+    this.registry = null;
+    this.healthChecker = null;
+    this.rateLimiter = null;
+    this.selector = null;
+    this.network = null;
+    this.initialized = false;
+    this.isTesting = false;
+    this.healthCheckInterval = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  // ========================================================================
+  // Singleton Pattern
+  // ========================================================================
+  /**
+   * Get singleton instance (recommended for Node.js)
+   */
+  static getInstance(options) {
+    if (!_ProviderManager.instance) {
+      _ProviderManager.instance = new _ProviderManager(options);
+    }
+    return _ProviderManager.instance;
+  }
+  /**
+   * Reset singleton instance (for testing)
+   */
+  static resetInstance() {
+    if (_ProviderManager.instance) {
+      _ProviderManager.instance.destroy();
+      _ProviderManager.instance = null;
+    }
+  }
+  // ========================================================================
+  // Initialization
+  // ========================================================================
+  /**
+   * Initialize the provider manager
+   *
+   * @param network - Network to initialize for
+   * @param testProviders - Whether to test providers immediately (default: true)
+   */
+  async init(network, testProviders = true) {
+    if (this.initialized && this.network === network) {
+      this.options.logger.debug("Already initialized for this network");
+      return;
+    }
+    this.options.logger.info(`Initializing for ${network}...`);
+    this.network = network;
+    const config = await loadConfig();
+    const mergedConfig = mergeWithDefaults(config);
+    this.registry = new ProviderRegistry(mergedConfig, this.options.logger);
+    this.healthChecker = createHealthChecker(
+      {
+        timeoutMs: this.options.requestTimeoutMs,
+        maxBlocksBehind: this.options.maxBlocksBehind
+      },
+      this.options.logger
+    );
+    this.rateLimiter = createRateLimiterManager(this.options.logger);
+    this.selector = createSelector(
+      this.registry,
+      this.healthChecker,
+      void 0,
+      this.options.logger
+    );
+    for (const provider of this.registry.getAllProviders()) {
+      const config2 = getRateLimitForType(provider.type);
+      this.rateLimiter.setConfig(provider.id, {
+        ...config2,
+        rps: provider.rps,
+        minDelayMs: Math.ceil(1e3 / provider.rps)
+      });
+    }
+    this.initialized = true;
+    this.notifyListeners();
+    if (testProviders) {
+      await this.testAllProviders();
+    }
+    if (this.options.healthCheckIntervalMs > 0) {
+      this.startHealthCheckInterval();
+    }
+    this.options.logger.info("Initialization complete");
+  }
+  /**
+   * Check if manager is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Destroy the manager (cleanup)
+   */
+  destroy() {
+    this.stopHealthCheckInterval();
+    this.listeners.clear();
+    this.registry = null;
+    this.healthChecker = null;
+    this.rateLimiter = null;
+    this.selector = null;
+    this.initialized = false;
+    this.network = null;
+  }
+  // ========================================================================
+  // Provider Testing
+  // ========================================================================
+  /**
+   * Test all providers for current network
+   */
+  async testAllProviders() {
+    this.ensureInitialized();
+    if (this.isTesting) {
+      this.options.logger.debug("Already testing providers");
+      return [];
+    }
+    this.isTesting = true;
+    this.notifyListeners();
+    this.options.logger.info(`Testing all providers for ${this.network}...`);
+    try {
+      const providers = this.registry.getProvidersForNetwork(this.network);
+      const results = await this.healthChecker.testProviders(providers);
+      this.selector.updateBestProvider(this.network);
+      const available = results.filter((r) => r.success);
+      this.options.logger.info(
+        `Provider testing complete: ${available.length}/${results.length} available`
+      );
+      return results;
+    } finally {
+      this.isTesting = false;
+      this.notifyListeners();
+    }
+  }
+  /**
+   * Test a specific provider
+   */
+  async testProvider(providerId) {
+    this.ensureInitialized();
+    const provider = this.registry.getProvider(providerId);
+    if (!provider) {
+      this.options.logger.warn(`Provider ${providerId} not found`);
+      return null;
+    }
+    return this.healthChecker.testProvider(provider);
+  }
+  /**
+   * Check if testing is in progress
+   */
+  isTestingProviders() {
+    return this.isTesting;
+  }
+  // ========================================================================
+  // Endpoint Access
+  // ========================================================================
+  /**
+   * Get endpoint URL for current network
+   *
+   * Handles: custom endpoint > manual selection > auto-selection > fallback
+   */
+  async getEndpoint() {
+    this.ensureInitialized();
+    const provider = this.selector.getBestProvider(this.network);
+    if (!provider) {
+      this.options.logger.warn("No providers available, using fallback");
+      return this.getFallbackEndpoint();
+    }
+    if (provider.isDynamic && provider.type === "orbs") {
+      try {
+        const { getHttpEndpoint } = await import('@orbs-network/ton-access');
+        const endpoint = await getHttpEndpoint({ network: this.network });
+        return normalizeV2Endpoint(endpoint);
+      } catch (error) {
+        this.options.logger.warn(`Failed to get Orbs endpoint: ${error.message}`);
+      }
+    }
+    return normalizeV2Endpoint(provider.endpointV2);
+  }
+  /**
+   * Get endpoint with rate limiting
+   *
+   * Waits for rate limit token before returning endpoint.
+   */
+  async getEndpointWithRateLimit(timeoutMs) {
+    this.ensureInitialized();
+    const provider = this.selector.getBestProvider(this.network);
+    if (!provider) {
+      return this.getFallbackEndpoint();
+    }
+    const acquired = await this.rateLimiter.acquire(provider.id, timeoutMs);
+    if (!acquired) {
+      this.options.logger.warn(`Rate limit timeout for ${provider.id}`);
+      const next = this.selector.getNextProvider(this.network, [provider.id]);
+      if (next) {
+        return normalizeV2Endpoint(next.endpointV2);
+      }
+      return this.getFallbackEndpoint();
+    }
+    return normalizeV2Endpoint(provider.endpointV2);
+  }
+  /**
+   * Get current active provider
+   */
+  getActiveProvider() {
+    if (!this.initialized || !this.network) {
+      return null;
+    }
+    return this.selector.getBestProvider(this.network);
+  }
+  /**
+   * Get active provider info
+   */
+  getActiveProviderInfo() {
+    if (!this.initialized || !this.network) {
+      return null;
+    }
+    return this.selector.getActiveProviderInfo(this.network);
+  }
+  // ========================================================================
+  // Error Reporting
+  // ========================================================================
+  /**
+   * Report a successful request
+   */
+  reportSuccess() {
+    if (!this.initialized || !this.network) return;
+    const provider = this.selector.getBestProvider(this.network);
+    if (provider) {
+      this.rateLimiter.reportSuccess(provider.id);
+    }
+  }
+  /**
+   * Report an error (triggers provider switch if needed)
+   */
+  reportError(error) {
+    if (!this.initialized || !this.network) return;
+    const provider = this.selector.getBestProvider(this.network);
+    if (!provider) return;
+    const errorMsg = error instanceof Error ? error.message : error;
+    if (isRateLimitError(error)) {
+      this.rateLimiter.reportRateLimitError(provider.id);
+      this.healthChecker.markDegraded(provider.id, this.network, errorMsg);
+    } else {
+      this.rateLimiter.reportError(provider.id);
+    }
+    this.selector.handleProviderFailure(provider.id, this.network);
+    this.notifyListeners();
+  }
+  // ========================================================================
+  // Selection Control
+  // ========================================================================
+  /**
+   * Set manual provider selection
+   */
+  setSelectedProvider(providerId) {
+    this.ensureInitialized();
+    this.selector.setSelectedProvider(providerId);
+    this.notifyListeners();
+  }
+  /**
+   * Get selected provider ID
+   */
+  getSelectedProviderId() {
+    if (!this.initialized) return null;
+    return this.selector.getSelectedProviderId();
+  }
+  /**
+   * Set auto-select mode
+   */
+  setAutoSelect(enabled) {
+    this.ensureInitialized();
+    this.selector.setAutoSelect(enabled);
+    this.notifyListeners();
+  }
+  /**
+   * Check if auto-select is enabled
+   */
+  isAutoSelectEnabled() {
+    if (!this.initialized) return true;
+    return this.selector.isAutoSelectEnabled();
+  }
+  /**
+   * Set custom endpoint override
+   */
+  setCustomEndpoint(endpoint) {
+    this.ensureInitialized();
+    this.selector.setCustomEndpoint(endpoint);
+    this.notifyListeners();
+  }
+  /**
+   * Get custom endpoint
+   */
+  getCustomEndpoint() {
+    if (!this.initialized) return null;
+    return this.selector.getCustomEndpoint();
+  }
+  /**
+   * Check if using custom endpoint
+   */
+  isUsingCustomEndpoint() {
+    if (!this.initialized) return false;
+    return this.selector.isUsingCustomEndpoint();
+  }
+  // ========================================================================
+  // State Access
+  // ========================================================================
+  /**
+   * Get current network
+   */
+  getNetwork() {
+    return this.network;
+  }
+  /**
+   * Get all providers for current network
+   */
+  getProviders() {
+    if (!this.initialized || !this.network) return [];
+    return this.registry.getProvidersForNetwork(this.network);
+  }
+  /**
+   * Get provider health results for current network
+   */
+  getProviderHealthResults() {
+    if (!this.initialized || !this.network) return [];
+    return this.healthChecker.getResultsForNetwork(this.network);
+  }
+  /**
+   * Get registry (for advanced usage)
+   */
+  getRegistry() {
+    return this.registry;
+  }
+  /**
+   * Get health checker (for advanced usage)
+   */
+  getHealthChecker() {
+    return this.healthChecker;
+  }
+  /**
+   * Get rate limiter manager (for advanced usage)
+   */
+  getRateLimiter() {
+    return this.rateLimiter;
+  }
+  /**
+   * Get current state (for UI)
+   */
+  getState() {
+    const providers = /* @__PURE__ */ new Map();
+    if (this.initialized && this.network && this.registry) {
+      for (const provider of this.registry.getProvidersForNetwork(this.network)) {
+        const health = this.healthChecker?.getResult(provider.id, this.network);
+        const rateLimit = this.rateLimiter?.getState(provider.id);
+        providers.set(provider.id, {
+          id: provider.id,
+          health: health || {
+            id: provider.id,
+            network: this.network,
+            success: false,
+            status: "untested",
+            latencyMs: null,
+            seqno: null,
+            blocksBehind: 0,
+            lastTested: null
+          },
+          rateLimit: rateLimit || {
+            tokens: 0,
+            lastRefill: 0,
+            currentBackoff: 0,
+            consecutiveErrors: 0,
+            processing: false,
+            queueLength: 0
+          }
+        });
+      }
+    }
+    return {
+      network: this.network,
+      initialized: this.initialized,
+      isTesting: this.isTesting,
+      providers,
+      bestProviderByNetwork: new Map(
+        this.network && this.selector ? [[this.network, this.selector.getBestProvider(this.network)?.id || ""]] : []
+      ),
+      selectedProviderId: this.selector?.getSelectedProviderId() || null,
+      autoSelect: this.selector?.isAutoSelectEnabled() ?? true,
+      customEndpoint: this.selector?.getCustomEndpoint() || null
+    };
+  }
+  // ========================================================================
+  // State Listeners
+  // ========================================================================
+  /**
+   * Subscribe to state changes
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Notify all listeners
+   */
+  notifyListeners() {
+    const state = this.getState();
+    this.listeners.forEach((listener) => listener(state));
+  }
+  // ========================================================================
+  // Private Helpers
+  // ========================================================================
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("ProviderManager not initialized. Call init() first.");
+    }
+  }
+  getFallbackEndpoint() {
+    if (this.network === "mainnet") {
+      return "https://toncenter.com/api/v2/jsonRPC";
+    }
+    return "https://testnet.toncenter.com/api/v2/jsonRPC";
+  }
+  startHealthCheckInterval() {
+    this.stopHealthCheckInterval();
+    this.healthCheckInterval = setInterval(() => {
+      this.testAllProviders().catch((error) => {
+        this.options.logger.error(`Health check interval failed: ${error.message}`);
+      });
+    }, this.options.healthCheckIntervalMs);
+    this.options.logger.debug(
+      `Started health check interval: ${this.options.healthCheckIntervalMs}ms`
+    );
+  }
+  stopHealthCheckInterval() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+  }
+};
+// Singleton instance
+_ProviderManager.instance = null;
+var ProviderManager = _ProviderManager;
+function createProviderManager(options) {
+  return new ProviderManager(options);
+}
+function getProviderManager(options) {
+  return ProviderManager.getInstance(options);
+}
+var consoleLogger6 = {
+  debug: (msg, data) => console.debug(`[NodeAdapter] ${msg}`, data || ""),
+  info: (msg, data) => console.log(`[NodeAdapter] ${msg}`, data || ""),
+  warn: (msg, data) => console.warn(`[NodeAdapter] ${msg}`, data || ""),
+  error: (msg, data) => console.error(`[NodeAdapter] ${msg}`, data || "")
+};
+var cachedClient = null;
+var NodeAdapter = class {
+  constructor(manager, logger) {
+    this.manager = manager;
+    this.logger = logger || consoleLogger6;
+  }
+  /**
+   * Get TonClient instance
+   *
+   * Creates a new client if endpoint changed, otherwise returns cached.
+   */
+  async getClient() {
+    const endpoint = await this.manager.getEndpoint();
+    const network = this.manager.getNetwork();
+    if (!network) {
+      throw new Error("ProviderManager not initialized");
+    }
+    if (cachedClient && cachedClient.endpoint === endpoint && cachedClient.network === network) {
+      return cachedClient.client;
+    }
+    const provider = this.manager.getActiveProvider();
+    const apiKey = provider?.apiKey;
+    const client = new ton.TonClient({
+      endpoint,
+      apiKey
+    });
+    cachedClient = {
+      client,
+      endpoint,
+      network,
+      createdAt: Date.now()
+    };
+    this.logger.debug(`Created TonClient for ${network}`, { endpoint });
+    return client;
+  }
+  /**
+   * Reset client cache (forces new client creation)
+   */
+  resetClient() {
+    cachedClient = null;
+    this.logger.debug("Client cache cleared");
+  }
+  /**
+   * Get cached client info (for debugging)
+   */
+  getClientInfo() {
+    if (!cachedClient) return null;
+    return {
+      endpoint: cachedClient.endpoint,
+      network: cachedClient.network,
+      age: Date.now() - cachedClient.createdAt
+    };
+  }
+  // ========================================================================
+  // Direct REST API Methods
+  // ========================================================================
+  /**
+   * Get address state via REST API
+   */
+  async getAddressState(address, timeoutMs = 1e4) {
+    const endpoint = await this.manager.getEndpoint();
+    const baseV2 = toV2Base(endpoint);
+    const addrStr = typeof address === "string" ? address : address.toString();
+    const url = `${baseV2}/getAddressState?address=${encodeURIComponent(addrStr)}`;
+    try {
+      const response = await fetchWithTimeout(
+        url,
+        { headers: { accept: "application/json" } },
+        timeoutMs
+      );
+      const json = await response.json();
+      const data = this.unwrapResponse(json);
+      if (typeof data === "string") {
+        this.manager.reportSuccess();
+        return data;
+      }
+      if (data && typeof data === "object" && typeof data.state === "string") {
+        this.manager.reportSuccess();
+        return data.state;
+      }
+      throw new Error("Unexpected response format");
+    } catch (error) {
+      this.manager.reportError(error);
+      throw error;
+    }
+  }
+  /**
+   * Get address balance via REST API
+   */
+  async getAddressBalance(address, timeoutMs = 1e4) {
+    const endpoint = await this.manager.getEndpoint();
+    const baseV2 = toV2Base(endpoint);
+    const addrStr = typeof address === "string" ? address : address.toString();
+    const url = `${baseV2}/getAddressBalance?address=${encodeURIComponent(addrStr)}`;
+    try {
+      const response = await fetchWithTimeout(
+        url,
+        { headers: { accept: "application/json" } },
+        timeoutMs
+      );
+      const json = await response.json();
+      const data = this.unwrapResponse(json);
+      if (typeof data === "string" || typeof data === "number") {
+        this.manager.reportSuccess();
+        return BigInt(data);
+      }
+      if (data && typeof data === "object" && data.balance !== void 0) {
+        this.manager.reportSuccess();
+        return BigInt(String(data.balance));
+      }
+      throw new Error("Unexpected response format");
+    } catch (error) {
+      this.manager.reportError(error);
+      throw error;
+    }
+  }
+  /**
+   * Run a get method via REST API
+   */
+  async runGetMethod(address, method, stack = [], timeoutMs = 15e3) {
+    const endpoint = await this.manager.getEndpoint();
+    const baseV2 = toV2Base(endpoint);
+    const addrStr = typeof address === "string" ? address : address.toString();
+    const url = `${baseV2}/runGetMethod`;
+    try {
+      const response = await fetchWithTimeout(
+        url,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            accept: "application/json"
+          },
+          body: JSON.stringify({
+            address: addrStr,
+            method,
+            stack
+          })
+        },
+        timeoutMs
+      );
+      const json = await response.json();
+      const data = this.unwrapResponse(json);
+      if (data.exit_code === void 0) {
+        throw new Error("Missing exit_code in response");
+      }
+      this.manager.reportSuccess();
+      return {
+        exit_code: data.exit_code,
+        stack: data.stack || []
+      };
+    } catch (error) {
+      this.manager.reportError(error);
+      throw error;
+    }
+  }
+  /**
+   * Send BOC via REST API
+   */
+  async sendBoc(boc, timeoutMs = 3e4) {
+    const endpoint = await this.manager.getEndpoint();
+    const baseV2 = toV2Base(endpoint);
+    const url = `${baseV2}/sendBoc`;
+    const bocBase64 = typeof boc === "string" ? boc : boc.toString("base64");
+    try {
+      const response = await fetchWithTimeout(
+        url,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ boc: bocBase64 })
+        },
+        timeoutMs
+      );
+      const json = await response.json();
+      this.unwrapResponse(json);
+      this.manager.reportSuccess();
+    } catch (error) {
+      this.manager.reportError(error);
+      throw error;
+    }
+  }
+  /**
+   * Check if contract is deployed
+   */
+  async isContractDeployed(address, timeoutMs = 1e4) {
+    try {
+      const state = await this.getAddressState(address, timeoutMs);
+      return state === "active";
+    } catch {
+      return false;
+    }
+  }
+  // ========================================================================
+  // Private Helpers
+  // ========================================================================
+  /**
+   * Unwrap TON API response
+   */
+  unwrapResponse(json) {
+    if (json && typeof json === "object" && "ok" in json) {
+      const resp = json;
+      if (!resp.ok) {
+        throw new Error(resp.error || "API returned ok=false");
+      }
+      return resp.result ?? json;
+    }
+    if (json && typeof json === "object" && "result" in json) {
+      return json.result;
+    }
+    return json;
+  }
+};
+function createNodeAdapter(manager, logger) {
+  return new NodeAdapter(manager, logger);
+}
+async function getTonClient(manager) {
+  const adapter = new NodeAdapter(manager);
+  return adapter.getClient();
+}
+async function getTonClientForNetwork(network, configPath) {
+  const manager = ProviderManager.getInstance({ configPath });
+  if (!manager.isInitialized() || manager.getNetwork() !== network) {
+    await manager.init(network);
+  }
+  return getTonClient(manager);
+}
+function resetNodeAdapter() {
+  cachedClient = null;
+  ProviderManager.resetInstance();
+}
+
+// src/adapters/browser.ts
+var consoleLogger7 = {
+  debug: (msg, data) => console.debug(`[BrowserAdapter] ${msg}`, data || ""),
+  info: (msg, data) => console.log(`[BrowserAdapter] ${msg}`, data || ""),
+  warn: (msg, data) => console.warn(`[BrowserAdapter] ${msg}`, data || ""),
+  error: (msg, data) => console.error(`[BrowserAdapter] ${msg}`, data || "")
+};
+var BrowserAdapter = class {
+  constructor(manager, logger) {
+    this.manager = manager;
+    this.logger = logger || consoleLogger7;
+  }
+  /**
+   * Get current endpoint URL
+   */
+  async getEndpoint() {
+    return this.manager.getEndpoint();
+  }
+  /**
+   * Get endpoint with rate limiting
+   */
+  async getEndpointWithRateLimit(timeoutMs) {
+    return this.manager.getEndpointWithRateLimit(timeoutMs);
+  }
+  // ========================================================================
+  // JSON-RPC Methods
+  // ========================================================================
+  /**
+   * Make a JSON-RPC call to the TON API
+   */
+  async jsonRpc(method, params = {}, timeoutMs = 1e4) {
+    const endpoint = await this.manager.getEndpoint();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          id: "1",
+          jsonrpc: "2.0",
+          method,
+          params
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      const data = this.unwrapResponse(json);
+      this.manager.reportSuccess();
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        const timeoutError = new Error(`Request timed out after ${timeoutMs}ms`);
+        this.manager.reportError(timeoutError);
+        throw timeoutError;
+      }
+      this.manager.reportError(error);
+      throw error;
+    }
+  }
+  // ========================================================================
+  // REST API Methods
+  // ========================================================================
+  /**
+   * Get address state
+   */
+  async getAddressState(address, timeoutMs = 1e4) {
+    const endpoint = await this.manager.getEndpoint();
+    const baseV2 = toV2Base(endpoint);
+    const url = `${baseV2}/getAddressState?address=${encodeURIComponent(address)}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        headers: { accept: "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const json = await response.json();
+      const data = this.unwrapResponse(json);
+      if (typeof data === "string") {
+        this.manager.reportSuccess();
+        return data;
+      }
+      if (data && typeof data === "object" && typeof data.state === "string") {
+        this.manager.reportSuccess();
+        return data.state;
+      }
+      throw new Error("Unexpected response format");
+    } catch (error) {
+      clearTimeout(timeoutId);
+      this.manager.reportError(error);
+      throw error;
+    }
+  }
+  /**
+   * Get address balance
+   */
+  async getAddressBalance(address, timeoutMs = 1e4) {
+    const endpoint = await this.manager.getEndpoint();
+    const baseV2 = toV2Base(endpoint);
+    const url = `${baseV2}/getAddressBalance?address=${encodeURIComponent(address)}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        headers: { accept: "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const json = await response.json();
+      const data = this.unwrapResponse(json);
+      if (typeof data === "string" || typeof data === "number") {
+        this.manager.reportSuccess();
+        return BigInt(data);
+      }
+      if (data && typeof data === "object" && data.balance !== void 0) {
+        this.manager.reportSuccess();
+        return BigInt(String(data.balance));
+      }
+      throw new Error("Unexpected response format");
+    } catch (error) {
+      clearTimeout(timeoutId);
+      this.manager.reportError(error);
+      throw error;
+    }
+  }
+  /**
+   * Get address information
+   */
+  async getAddressInfo(address, timeoutMs = 1e4) {
+    const endpoint = await this.manager.getEndpoint();
+    const baseV2 = toV2Base(endpoint);
+    const url = `${baseV2}/getAddressInformation?address=${encodeURIComponent(address)}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        headers: { accept: "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const json = await response.json();
+      const data = this.unwrapResponse(json);
+      this.manager.reportSuccess();
+      return {
+        state: data.state,
+        balance: BigInt(String(data.balance || 0)),
+        lastTransactionLt: data.last_transaction_id?.lt,
+        lastTransactionHash: data.last_transaction_id?.hash
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      this.manager.reportError(error);
+      throw error;
+    }
+  }
+  /**
+   * Run get method
+   */
+  async runGetMethod(address, method, stack = [], timeoutMs = 15e3) {
+    const endpoint = await this.manager.getEndpoint();
+    const baseV2 = toV2Base(endpoint);
+    const url = `${baseV2}/runGetMethod`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          accept: "application/json"
+        },
+        body: JSON.stringify({
+          address,
+          method,
+          stack
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const json = await response.json();
+      const data = this.unwrapResponse(json);
+      if (data.exit_code === void 0) {
+        throw new Error("Missing exit_code in response");
+      }
+      this.manager.reportSuccess();
+      return {
+        exit_code: data.exit_code,
+        stack: data.stack || []
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      this.manager.reportError(error);
+      throw error;
+    }
+  }
+  /**
+   * Get masterchain info
+   */
+  async getMasterchainInfo(timeoutMs = 1e4) {
+    const data = await this.jsonRpc("getMasterchainInfo", {}, timeoutMs);
+    return {
+      seqno: data.last?.seqno || 0,
+      stateRootHash: data.state_root_hash || ""
+    };
+  }
+  // ========================================================================
+  // Provider Management
+  // ========================================================================
+  /**
+   * Get provider manager
+   */
+  getManager() {
+    return this.manager;
+  }
+  /**
+   * Get active provider info
+   */
+  getActiveProviderInfo() {
+    return this.manager.getActiveProviderInfo();
+  }
+  /**
+   * Get provider health results
+   */
+  getProviderHealthResults() {
+    return this.manager.getProviderHealthResults();
+  }
+  /**
+   * Test all providers
+   */
+  async testAllProviders() {
+    return this.manager.testAllProviders();
+  }
+  // ========================================================================
+  // Private Helpers
+  // ========================================================================
+  /**
+   * Unwrap TON API response
+   */
+  unwrapResponse(json) {
+    if (json && typeof json === "object" && "ok" in json) {
+      const resp = json;
+      if (!resp.ok) {
+        throw new Error(resp.error || "API returned ok=false");
+      }
+      return resp.result ?? json;
+    }
+    if (json && typeof json === "object" && "result" in json) {
+      return json.result;
+    }
+    return json;
+  }
+};
+function createBrowserAdapter(manager, logger) {
+  return new BrowserAdapter(manager, logger);
+}
+async function createBrowserAdapterForNetwork(network, configPath, logger) {
+  const manager = new ProviderManager({
+    configPath,
+    adapter: "browser",
+    logger
+  });
+  await manager.init(network);
+  return new BrowserAdapter(manager, logger);
+}
+
+exports.ApiVersionSchema = ApiVersionSchema;
+exports.BrowserAdapter = BrowserAdapter;
+exports.CHAINSTACK_RATE_LIMIT = CHAINSTACK_RATE_LIMIT;
+exports.ConfigError = ConfigError;
+exports.DEFAULT_CONTRACT_TIMEOUT_MS = DEFAULT_CONTRACT_TIMEOUT_MS;
+exports.DEFAULT_HEALTH_CHECK_TIMEOUT_MS = DEFAULT_HEALTH_CHECK_TIMEOUT_MS;
+exports.DEFAULT_PROVIDERS = DEFAULT_PROVIDERS;
+exports.DEFAULT_PROVIDER_TIMEOUT_MS = DEFAULT_PROVIDER_TIMEOUT_MS;
+exports.DEFAULT_RATE_LIMIT = DEFAULT_RATE_LIMIT;
+exports.HealthChecker = HealthChecker;
+exports.NetworkSchema = NetworkSchema;
+exports.NodeAdapter = NodeAdapter;
+exports.ORBS_RATE_LIMIT = ORBS_RATE_LIMIT;
+exports.ProviderConfigSchema = ProviderConfigSchema;
+exports.ProviderError = ProviderError;
+exports.ProviderManager = ProviderManager;
+exports.ProviderRegistry = ProviderRegistry;
+exports.ProviderSelector = ProviderSelector;
+exports.ProviderTypeSchema = ProviderTypeSchema;
+exports.QUICKNODE_RATE_LIMIT = QUICKNODE_RATE_LIMIT;
+exports.RateLimitError = RateLimitError;
+exports.RateLimiterManager = RateLimiterManager;
+exports.RpcConfigSchema = RpcConfigSchema;
+exports.TimeoutError = TimeoutError;
+exports.TokenBucketRateLimiter = TokenBucketRateLimiter;
+exports.buildGetAddressBalanceUrl = buildGetAddressBalanceUrl;
+exports.buildGetAddressInfoUrl = buildGetAddressInfoUrl;
+exports.buildGetAddressStateUrl = buildGetAddressStateUrl;
+exports.buildRestUrl = buildRestUrl;
+exports.createBrowserAdapter = createBrowserAdapter;
+exports.createBrowserAdapterForNetwork = createBrowserAdapterForNetwork;
+exports.createDefaultConfig = createDefaultConfig;
+exports.createDefaultRegistry = createDefaultRegistry;
+exports.createEmptyConfig = createEmptyConfig;
+exports.createHealthChecker = createHealthChecker;
+exports.createNodeAdapter = createNodeAdapter;
+exports.createProviderManager = createProviderManager;
+exports.createRateLimiter = createRateLimiter;
+exports.createRateLimiterManager = createRateLimiterManager;
+exports.createRegistry = createRegistry;
+exports.createRegistryFromData = createRegistryFromData;
+exports.createRegistryFromFile = createRegistryFromFile;
+exports.createSelector = createSelector;
+exports.createTimeoutController = createTimeoutController;
+exports.detectNetworkFromEndpoint = detectNetworkFromEndpoint;
+exports.fetchWithTimeout = fetchWithTimeout;
+exports.getBaseUrl = getBaseUrl;
+exports.getDefaultProvidersForNetwork = getDefaultProvidersForNetwork;
+exports.getEnvVar = getEnvVar;
+exports.getProviderManager = getProviderManager;
+exports.getProvidersForNetwork = getProvidersForNetwork;
+exports.getRateLimitForType = getRateLimitForType;
+exports.getTonClient = getTonClient;
+exports.getTonClientForNetwork = getTonClientForNetwork;
+exports.isApiVersion = isApiVersion;
+exports.isChainstackUrl = isChainstackUrl;
+exports.isNetwork = isNetwork;
+exports.isOrbsUrl = isOrbsUrl;
+exports.isProviderType = isProviderType;
+exports.isQuickNodeUrl = isQuickNodeUrl;
+exports.isRateLimitError = isRateLimitError;
+exports.isTimeoutError = isTimeoutError;
+exports.isTonCenterUrl = isTonCenterUrl;
+exports.isValidHttpUrl = isValidHttpUrl;
+exports.isValidWsUrl = isValidWsUrl;
+exports.loadBuiltinConfig = loadBuiltinConfig;
+exports.loadConfig = loadConfig;
+exports.loadConfigFromData = loadConfigFromData;
+exports.loadConfigFromUrl = loadConfigFromUrl;
+exports.mergeConfigs = mergeConfigs;
+exports.mergeWithDefaults = mergeWithDefaults;
+exports.normalizeV2Endpoint = normalizeV2Endpoint;
+exports.parseProviderConfig = parseProviderConfig;
+exports.parseRpcConfig = parseRpcConfig;
+exports.resetNodeAdapter = resetNodeAdapter;
+exports.resolveAllProviders = resolveAllProviders;
+exports.resolveEndpoints = resolveEndpoints;
+exports.resolveKeyPlaceholder = resolveKeyPlaceholder;
+exports.resolveProvider = resolveProvider;
+exports.sleep = sleep;
+exports.toV2Base = toV2Base;
+exports.toV3Base = toV3Base;
+exports.withRetry = withRetry;
+exports.withTimeout = withTimeout;
+exports.withTimeoutAndRetry = withTimeoutAndRetry;
+exports.withTimeoutFn = withTimeoutFn;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map