@paxoslabs/amplify-sdk 0.5.1 → 0.5.3

package/dist/chunk-E5DH5YEE.js

@@ -1,1485 +0,0 @@
-'use strict';
-
-var viem = require('viem');
-var chains = require('viem/chains');
-
-// src/utils/fetch.ts
-var DEFAULT_TIMEOUT = 1e4;
-function createTimeoutSignal(timeoutMs) {
-  const controller = new AbortController();
-  setTimeout(() => controller.abort(), timeoutMs);
-  return controller.signal;
-}
-
-// src/types/telemetry.ts
-var LogLevel = {
-  DEBUG: 0,
-  INFO: 1,
-  WARN: 2,
-  ERROR: 3,
-  NONE: 4
-};
-
-// src/lib/logger.ts
-var ConsoleLogger = class {
-  constructor(level = LogLevel.ERROR) {
-    this.level = level;
-  }
-  /**
-   * Update log level
-   */
-  setLevel(level) {
-    this.level = level;
-  }
-  /**
-   * Get current log level
-   */
-  getLevel() {
-    return this.level;
-  }
-  debug(message, context) {
-    if (this.level <= LogLevel.DEBUG) {
-      if (context) {
-        console.debug("[Amplify SDK]", message, context);
-      } else {
-        console.debug("[Amplify SDK]", message);
-      }
-    }
-  }
-  info(message, context) {
-    if (this.level <= LogLevel.INFO) {
-      if (context) {
-        console.info("[Amplify SDK]", message, context);
-      } else {
-        console.info("[Amplify SDK]", message);
-      }
-    }
-  }
-  warn(message, context) {
-    if (this.level <= LogLevel.WARN) {
-      if (context) {
-        console.warn("[Amplify SDK]", message, context);
-      } else {
-        console.warn("[Amplify SDK]", message);
-      }
-    }
-  }
-  error(message, context) {
-    if (this.level <= LogLevel.ERROR) {
-      if (context) {
-        console.error("[Amplify SDK]", message, context);
-      } else {
-        console.error("[Amplify SDK]", message);
-      }
-    }
-  }
-};
-var currentLogger = new ConsoleLogger(LogLevel.ERROR);
-var defaultLogger = currentLogger;
-function setLogger(logger) {
-  currentLogger = logger;
-}
-function getLogger() {
-  return currentLogger;
-}
-function setLogLevel(level) {
-  if (defaultLogger && typeof defaultLogger.setLevel === "function") {
-    defaultLogger.setLevel(level);
-  }
-}
-
-// src/constants/environment.ts
-var BASE_URL = "https://api.paxoslabs.com";
-function getGraphQLEndpoint() {
-  return `${BASE_URL}/graphql`;
-}
-function getRestV2BaseURL() {
-  return `${BASE_URL}/v2`;
-}
-
-// src/lib/vault-cache.ts
-var DEFAULT_TTL = 6e5;
-var VaultCache = class {
-  /**
-   * Creates a new VaultCache instance
-   *
-   * @param ttl - Time-to-live in milliseconds (default: 600000 = 10 minutes)
-   */
-  constructor(ttl = DEFAULT_TTL) {
-    this.vaults = /* @__PURE__ */ new Map();
-    this.assets = /* @__PURE__ */ new Map();
-    this.vaultsByAddress = /* @__PURE__ */ new Map();
-    this.vaultsByName = /* @__PURE__ */ new Map();
-    this.lastFetch = 0;
-    this.ttl = ttl;
-    this.refreshPromise = null;
-  }
-  /**
-   * Gets vaults by deposit token address
-   *
-   * Returns undefined if no vaults found for the given token address.
-   * Does NOT automatically refresh if cache is expired; use refresh() for that.
-   *
-   * @param tokenAddress - Deposit token address (baseTokenAddress)
-   * @returns Array of AmplifyVault objects, or undefined if not found
-   */
-  getVault(tokenAddress) {
-    return this.vaults.get(tokenAddress);
-  }
-  /**
-   * Gets a vault by its boringVaultAddress (on-chain vault contract).
-   * Case-insensitive lookup.
-   */
-  getVaultByAddress(address) {
-    return this.vaultsByAddress.get(address.toLowerCase());
-  }
-  /**
-   * Gets a vault by its human-readable name.
-   * Case-insensitive lookup.
-   */
-  getVaultByName(name) {
-    return this.vaultsByName.get(name.toLowerCase());
-  }
-  /**
-   * Gets asset by token address
-   *
-   * Returns undefined if asset not found.
-   * Does NOT automatically refresh if cache is expired; use refresh() for that.
-   *
-   * @param tokenAddress - Token address
-   * @returns SupportedAsset object, or undefined if not found
-   */
-  getAsset(tokenAddress) {
-    return this.assets.get(tokenAddress);
-  }
-  /**
-   * Gets all cached vaults
-   *
-   * Returns an array of all vaults across all deposit tokens.
-   * Does NOT automatically refresh if cache is expired; use refresh() for that.
-   *
-   * @returns Array of all AmplifyVault objects
-   */
-  getAllVaults() {
-    const seen = /* @__PURE__ */ new Set();
-    const allVaults = [];
-    for (const vaultArray of this.vaults.values()) {
-      for (const vault of vaultArray) {
-        if (!seen.has(vault.id)) {
-          seen.add(vault.id);
-          allVaults.push(vault);
-        }
-      }
-    }
-    return allVaults;
-  }
-  /**
-   * Gets all cached assets
-   *
-   * Returns an array of all assets.
-   * Does NOT automatically refresh if cache is expired; use refresh() for that.
-   *
-   * @returns Array of all SupportedAsset objects
-   */
-  getAllAssets() {
-    return Array.from(this.assets.values());
-  }
-  /**
-   * Checks if cache is expired
-   *
-   * Cache is considered expired if current time exceeds lastFetch + ttl.
-   *
-   * @returns true if cache is expired, false otherwise
-   */
-  isExpired() {
-    return Date.now() > this.lastFetch + this.ttl;
-  }
-  /**
-   * Gets the time until cache expires
-   *
-   * @returns Milliseconds until expiry, or 0 if already expired
-   */
-  getTimeUntilExpiry() {
-    const expiryTime = this.lastFetch + this.ttl;
-    const now = Date.now();
-    return Math.max(0, expiryTime - now);
-  }
-  /**
-   * Checks if cache is empty (never populated)
-   *
-   * @returns true if cache has never been populated, false otherwise
-   */
-  isEmpty() {
-    return this.lastFetch === 0;
-  }
-  /**
-   * Manually refreshes the cache
-   *
-   * Fetches fresh data from the API and updates both vaults and assets maps.
-   * Updates lastFetch timestamp on success.
-   *
-   * If a refresh is already in progress, this method returns the existing
-   * promise instead of starting a concurrent refresh. This is more efficient
-   * than polling and ensures all callers wait for the same refresh operation.
-   *
-   * @throws {APIError} If the API request fails
-   */
-  async refresh() {
-    if (this.refreshPromise) {
-      return this.refreshPromise;
-    }
-    this.refreshPromise = this._doRefresh();
-    try {
-      await this.refreshPromise;
-    } finally {
-      this.refreshPromise = null;
-    }
-  }
-  /**
-   * Internal refresh implementation
-   * Separated to allow promise reuse in refresh()
-   *
-   * Fetches data via GraphQL and derives both vaults and assets
-   * from the same response.
-   */
-  async _doRefresh() {
-    const { vaults, assets } = await fetchVaultDataFromGraphQL();
-    this.vaults.clear();
-    this.assets.clear();
-    this.vaultsByAddress.clear();
-    this.vaultsByName.clear();
-    for (const vault of vaults) {
-      for (const asset of vault.supportedAssets) {
-        const tokenAddress = asset.address;
-        const existing = this.vaults.get(tokenAddress);
-        if (existing) {
-          if (!existing.includes(vault)) {
-            existing.push(vault);
-          }
-        } else {
-          this.vaults.set(tokenAddress, [vault]);
-        }
-      }
-      this.vaultsByAddress.set(
-        vault.vault.boringVaultAddress.toLowerCase(),
-        vault
-      );
-      if (vault.name) {
-        this.vaultsByName.set(vault.name.toLowerCase(), vault);
-      }
-    }
-    for (const asset of assets) {
-      this.assets.set(asset.address, asset);
-    }
-    this.lastFetch = Date.now();
-  }
-  /**
-   * Check if a refresh is currently in progress
-   *
-   * @returns true if cache is being refreshed, false otherwise
-   */
-  isRefreshing() {
-    return this.refreshPromise !== null;
-  }
-  /**
-   * Clears the cache
-   *
-   * Removes all cached data and resets lastFetch timestamp.
-   * Does not affect TTL setting.
-   */
-  clear() {
-    this.vaults.clear();
-    this.assets.clear();
-    this.vaultsByAddress.clear();
-    this.vaultsByName.clear();
-    this.lastFetch = 0;
-  }
-  /**
-   * Gets cache statistics
-   *
-   * @returns Object with cache statistics
-   */
-  getStats() {
-    return {
-      vaultCount: this.getAllVaults().length,
-      assetCount: this.assets.size,
-      tokenCount: this.vaults.size,
-      lastFetch: this.lastFetch,
-      ttl: this.ttl,
-      isExpired: this.isExpired(),
-      isEmpty: this.isEmpty(),
-      timeUntilExpiry: this.getTimeUntilExpiry()
-    };
-  }
-};
-
-// src/constants/index.ts
-var DEFAULT_DEADLINE = 3;
-var CHAINLINK_ADDRESS = "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419";
-var DEFAULT_APPROVAL_AMOUNT = BigInt(2) ** BigInt(256) - BigInt(1);
-var API_BASE_URL = "https://api.paxoslabs.com";
-
-// src/lib/telemetry.ts
-var SDK_VERSION = "0.1.1-beta.1";
-var MAX_ERROR_BUFFER_SIZE = 10;
-var CONFIG_FETCH_TIMEOUT = 5e3;
-var telemetryState = {
-  enabled: false,
-  isInitialized: false,
-  isInitializing: false,
-  initPromise: null,
-  config: null,
-  apiKey: null
-};
-var posthogClient = null;
-var errorBuffer = [];
-var bufferFullWarningLogged = false;
-function hashApiKey(apiKey) {
-  const FNV_OFFSET = BigInt("0xcbf29ce484222325");
-  const FNV_PRIME = BigInt("0x100000001b3");
-  let hash = FNV_OFFSET;
-  for (let i = 0; i < apiKey.length; i++) {
-    hash ^= BigInt(apiKey.charCodeAt(i));
-    hash = hash * FNV_PRIME & BigInt("0xffffffffffffffff");
-  }
-  return `sdk_${hash.toString(16).slice(0, 12)}`;
-}
-async function fetchTelemetryConfig(apiKey) {
-  const endpoint = "/v1/earn-sdk/config";
-  const url = `${API_BASE_URL}${endpoint}`;
-  try {
-    const headers = getRequestHeaders();
-    if (!headers["x-api-key"]) {
-      headers["x-api-key"] = apiKey;
-    }
-    const response = await fetch(url, {
-      method: "GET",
-      headers,
-      signal: createTimeoutSignal(CONFIG_FETCH_TIMEOUT)
-    });
-    if (!response.ok) {
-      return null;
-    }
-    const data = await response.json();
-    if (!data || typeof data.posthogApiKey !== "string") {
-      return null;
-    }
-    return {
-      posthogApiKey: data.posthogApiKey,
-      posthogHost: data.posthogHost || "https://us.i.posthog.com"
-    };
-  } catch {
-    return null;
-  }
-}
-async function flushErrorBuffer() {
-  if (errorBuffer.length === 0 || !posthogClient) {
-    return;
-  }
-  for (const bufferedError of errorBuffer) {
-    const payload = {
-      error_type: bufferedError.name,
-      error_message: bufferedError.message,
-      error_code: bufferedError.code,
-      sdk_version: SDK_VERSION,
-      buffered: true,
-      ...bufferedError.context
-    };
-    posthogClient.capture("sdk_error", payload);
-  }
-  errorBuffer.length = 0;
-}
-async function initTelemetry(apiKey) {
-  if (telemetryState.isInitialized) {
-    return;
-  }
-  if (telemetryState.isInitializing && telemetryState.initPromise) {
-    await telemetryState.initPromise;
-    return;
-  }
-  telemetryState.isInitializing = true;
-  telemetryState.apiKey = apiKey;
-  telemetryState.initPromise = (async () => {
-    try {
-      const config = await fetchTelemetryConfig(apiKey);
-      if (!config) {
-        telemetryState.enabled = false;
-        telemetryState.isInitialized = true;
-        return;
-      }
-      telemetryState.config = config;
-      const posthogModule = await import('posthog-js');
-      const posthog = posthogModule.default;
-      posthog.init(config.posthogApiKey, {
-        api_host: config.posthogHost,
-        autocapture: false,
-        capture_pageview: false,
-        capture_pageleave: false,
-        disable_session_recording: true,
-        persistence: "memory",
-        // Don't persist to localStorage
-        loaded: (ph) => {
-          ph.identify(hashApiKey(apiKey));
-        }
-      });
-      posthogClient = posthog;
-      telemetryState.enabled = true;
-      telemetryState.isInitialized = true;
-      await flushErrorBuffer();
-      posthog.capture("sdk_initialized", {
-        sdk_version: SDK_VERSION
-      });
-    } catch (error) {
-      const logger = getLogger();
-      logger.warn("Telemetry initialization failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-      telemetryState.enabled = false;
-      telemetryState.isInitialized = true;
-    } finally {
-      telemetryState.isInitializing = false;
-      telemetryState.initPromise = null;
-    }
-  })();
-  await telemetryState.initPromise;
-}
-function trackError(error, context) {
-  const logger = getLogger();
-  logger.error(error.message, {
-    name: error.name,
-    stack: error.stack,
-    ...context
-  });
-  const errorDetails = {
-    name: error.name,
-    message: error.message,
-    code: error.code,
-    context: context || {},
-    timestamp: Date.now()
-  };
-  if (!posthogClient || !telemetryState.enabled) {
-    if (errorBuffer.length < MAX_ERROR_BUFFER_SIZE) {
-      errorBuffer.push(errorDetails);
-    } else if (!bufferFullWarningLogged) {
-      logger.warn(
-        `Telemetry error buffer full (${MAX_ERROR_BUFFER_SIZE} errors). Additional errors will not be tracked until telemetry initializes.`
-      );
-      bufferFullWarningLogged = true;
-    }
-    return;
-  }
-  const payload = {
-    error_type: error.name,
-    error_message: error.message,
-    error_code: error.code,
-    endpoint: error.endpoint,
-    status_code: error.statusCode,
-    sdk_version: SDK_VERSION,
-    ...context
-  };
-  posthogClient.capture("sdk_error", payload);
-}
-function resetTelemetry() {
-  telemetryState.enabled = false;
-  telemetryState.isInitialized = false;
-  telemetryState.isInitializing = false;
-  telemetryState.initPromise = null;
-  telemetryState.config = null;
-  telemetryState.apiKey = null;
-  posthogClient = null;
-  errorBuffer.length = 0;
-  bufferFullWarningLogged = false;
-}
-
-// src/types/amplify-sdk-api.ts
-var APIError = class _APIError extends Error {
-  constructor(message, options) {
-    super(message);
-    this.name = "APIError";
-    this.statusCode = options?.statusCode;
-    this.endpoint = options?.endpoint;
-    this.cause = options?.cause;
-    Object.setPrototypeOf(this, _APIError.prototype);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _APIError);
-    }
-    try {
-      trackError(this, {
-        endpoint: this.endpoint,
-        statusCode: this.statusCode
-      });
-    } catch {
-    }
-  }
-};
-function isValidYieldType(value) {
-  return typeof value === "string" && (value === "CORE" || value === "TREASURY" || value === "FRONTIER");
-}
-function isValidAddress(value) {
-  return typeof value === "string" && /^0x[a-fA-F0-9]{40}$/.test(value);
-}
-function isValidChainId(value) {
-  return typeof value === "number" && value > 0 && Number.isInteger(value);
-}
-
-// src/client/graphql-client.ts
-var VAULT_FIELDS = `
-  id
-  name
-  chainId
-  isDeleted
-  boringVaultModuleId
-  boringVaultAddress
-  rolesAuthorityModuleId
-  tellerModuleId
-  accountantModuleId
-  managerModuleId
-  withdrawQueueModuleId
-  communityCodeDepositorModuleId
-  baseTokenAddressId
-  baseTokenStandInId
-  baseTokenStandIn {
-    decimals
-    symbol
-    coinGeckoApiId
-  }
-  withdrawalSla {
-    withdrawAssetAddress
-    externalWithdrawalQueueDelaySLA
-    externalAccountantRateUpdateSLA
-  }
-  supportedAssets {
-    address
-    chainId
-    depositable
-    withdrawable
-    symbol
-    tokenName
-    decimals
-  }
-`;
-var DEPOSIT_TOKEN_FIELDS = `
-  id
-  address
-  chainId
-  name
-`;
-var TOKEN_METADATA_FIELDS = `
-  address
-  chainId
-  symbol
-  tokenName
-  decimals
-  coinGeckoTokenId
-  tokenStandard
-  source
-  firstSeenAt
-  metadataRefreshedAt
-`;
-var VAULT_ASSET_FLAGS_FIELDS = `
-  depositable
-  withdrawable
-`;
-var SDK_CONFIG_CORE_FIELDS = `
-  id
-  chainId
-  environment
-  yieldType
-  vaultId
-  depositTokenAddressId
-`;
-function buildSdkConfigsQuery(options) {
-  const nestedFields = [];
-  if (options.vault) {
-    nestedFields.push(`vault { ${options.vault} }`);
-  }
-  if (options.depositTokenAddress) {
-    nestedFields.push(
-      `depositTokenAddress { ${options.depositTokenAddress} }`
-    );
-  }
-  if (options.tokenMetadata) {
-    nestedFields.push(
-      `tokenMetadata { ${options.tokenMetadata} }`
-    );
-  }
-  if (options.vaultAssetFlags) {
-    nestedFields.push(
-      `vaultAssetFlags { ${options.vaultAssetFlags} }`
-    );
-  }
-  const allFields = [
-    ...options.fields,
-    ...nestedFields
-  ].join("\n    ");
-  return `
-  query AmplifySdkConfigs(
-    $environment: Environment
-    $chainId: Int
-    $yieldType: YieldType
-  ) {
-    amplifySdkConfigs(
-      environment: $environment
-      chainId: $chainId
-      yieldType: $yieldType
-    ) {
-      ${allFields}
-    }
-  }
-`;
-}
-async function executeGraphQLQuery(endpoint, query, variables) {
-  const headers = getRequestHeaders();
-  let response;
-  try {
-    response = await fetch(endpoint, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ query, variables }),
-      signal: createTimeoutSignal(DEFAULT_TIMEOUT)
-    });
-  } catch (error) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new APIError(
-        "GraphQL request timed out",
-        { endpoint, cause: error }
-      );
-    }
-    throw new APIError(
-      `GraphQL network error: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint, cause: error }
-    );
-  }
-  if (!response.ok) {
-    throw new APIError(
-      `GraphQL HTTP error: ${response.status} ${response.statusText}`,
-      { endpoint, statusCode: response.status }
-    );
-  }
-  let body;
-  try {
-    body = await response.json();
-  } catch (error) {
-    throw new APIError(
-      "GraphQL response is not valid JSON",
-      { endpoint, cause: error }
-    );
-  }
-  if (body.errors && body.errors.length > 0) {
-    const messages = body.errors.map((e) => e.message).join("; ");
-    throw new APIError(`GraphQL errors: ${messages}`, {
-      endpoint,
-      cause: body.errors
-    });
-  }
-  if (!body.data) {
-    throw new APIError(
-      "GraphQL response missing data field",
-      { endpoint }
-    );
-  }
-  return body.data;
-}
-async function fetchAmplifySdkConfigs(endpoint, variables) {
-  const query = buildSdkConfigsQuery({
-    fields: SDK_CONFIG_CORE_FIELDS.trim().split(/\s+/),
-    vault: VAULT_FIELDS,
-    depositTokenAddress: DEPOSIT_TOKEN_FIELDS,
-    tokenMetadata: TOKEN_METADATA_FIELDS,
-    vaultAssetFlags: VAULT_ASSET_FLAGS_FIELDS
-  });
-  return executeGraphQLQuery(
-    endpoint,
-    query,
-    variables
-  );
-}
-
-// src/constants/config.ts
-var YieldType = {
-  CORE: "CORE",
-  TREASURY: "TREASURY",
-  FRONTIER: "FRONTIER"
-};
-var DEFAULT_SLIPPAGE_BPS = 50;
-
-// src/client/graphql-mapper.ts
-function mapYieldType(graphqlYieldType) {
-  switch (graphqlYieldType) {
-    case "CORE":
-    case "PRIME":
-      return YieldType.CORE;
-    case "TREASURY":
-    case "TBILL":
-      return YieldType.TREASURY;
-    case "FRONTIER":
-    case "LENDING":
-      return YieldType.FRONTIER;
-    default: {
-      const logger = getLogger();
-      logger.warn(
-        `Unknown GraphQL yield type: ${graphqlYieldType}, skipping`
-      );
-      return null;
-    }
-  }
-}
-function mapGraphQLConfigToVault(config) {
-  if (!config.vault || !config.depositTokenAddress) {
-    return null;
-  }
-  const yieldType = mapYieldType(config.yieldType);
-  if (!yieldType) {
-    return null;
-  }
-  const { vault, depositTokenAddress } = config;
-  const indexerAssets = vault.supportedAssets && vault.supportedAssets.length > 0 ? vault.supportedAssets.map((a) => ({
-    address: a.address,
-    chainId: a.chainId,
-    symbol: a.symbol ?? a.address,
-    name: a.tokenName ?? a.symbol ?? a.address,
-    decimals: a.decimals ?? 0,
-    depositable: a.depositable,
-    withdrawable: a.withdrawable
-  })) : [
-    {
-      address: depositTokenAddress.address,
-      symbol: config.tokenMetadata?.symbol ?? depositTokenAddress.name,
-      name: config.tokenMetadata?.tokenName ?? depositTokenAddress.name,
-      decimals: config.tokenMetadata?.decimals ?? 0,
-      ...config.vaultAssetFlags && {
-        depositable: config.vaultAssetFlags.depositable,
-        withdrawable: config.vaultAssetFlags.withdrawable
-      }
-    }
-  ];
-  return {
-    id: config.id,
-    chainId: config.chainId,
-    yieldType,
-    name: vault.name,
-    vault: {
-      boringVaultAddress: vault.boringVaultAddress,
-      tellerAddress: vault.tellerModuleId,
-      accountantAddress: vault.accountantModuleId,
-      managerAddress: vault.managerModuleId,
-      rolesAuthorityAddress: vault.rolesAuthorityModuleId,
-      baseTokenAddress: vault.baseTokenAddressId,
-      baseTokenStandIn: vault.baseTokenStandInId ? vault.baseTokenStandInId : void 0,
-      withdrawQueueAddress: vault.withdrawQueueModuleId ? vault.withdrawQueueModuleId : void 0,
-      communityCodeDepositorAddress: vault.communityCodeDepositorModuleId ? vault.communityCodeDepositorModuleId : void 0
-    },
-    supportedAssets: indexerAssets,
-    sla: vault.withdrawalSla && vault.withdrawalSla.length > 0 ? {
-      externalWithdrawalQueueDelaySLA: vault.withdrawalSla[0].externalWithdrawalQueueDelaySLA,
-      externalAccountantRateUpdateSLA: vault.withdrawalSla[0].externalAccountantRateUpdateSLA
-    } : void 0
-  };
-}
-function aggregateVaultConfigs(configs) {
-  const vaultMap = /* @__PURE__ */ new Map();
-  for (const config of configs) {
-    if (!config.vault || !config.depositTokenAddress) continue;
-    if (vaultMap.has(config.vaultId)) continue;
-    const mapped = mapGraphQLConfigToVault(config);
-    if (mapped) {
-      vaultMap.set(config.vaultId, mapped);
-    }
-  }
-  return Array.from(vaultMap.values());
-}
-function extractSupportedAssetsFromConfigs(configs) {
-  const assetMap = /* @__PURE__ */ new Map();
-  for (const config of configs) {
-    if (!config.depositTokenAddress) continue;
-    const key = config.depositTokenAddress.address.toLowerCase();
-    const existing = assetMap.get(key);
-    if (existing) {
-      existing.chains.add(config.chainId);
-      if (existing.decimals === 0 && config.tokenMetadata?.decimals) {
-        existing.decimals = config.tokenMetadata.decimals;
-        existing.symbol = config.tokenMetadata.symbol ?? existing.symbol;
-        existing.name = config.tokenMetadata.tokenName ?? existing.name;
-      }
-    } else {
-      assetMap.set(key, {
-        address: config.depositTokenAddress.address,
-        symbol: config.tokenMetadata?.symbol ?? config.depositTokenAddress.name,
-        name: config.tokenMetadata?.tokenName ?? config.depositTokenAddress.name,
-        decimals: config.tokenMetadata?.decimals ?? 0,
-        chains: /* @__PURE__ */ new Set([config.chainId])
-      });
-    }
-  }
-  return Array.from(assetMap.values()).map((asset) => ({
-    address: asset.address,
-    symbol: asset.symbol,
-    name: asset.name,
-    decimals: asset.decimals,
-    chains: Array.from(asset.chains)
-  }));
-}
-
-// src/client/amplify-sdk-client.ts
-function validateVaultFilterOptions(options) {
-  if (!options) return;
-  if (options.chainId !== void 0 && !isValidChainId(options.chainId)) {
-    throw new APIError(
-      `Invalid chainId: ${options.chainId}. Must be a positive integer.`,
-      { endpoint: "/v1/earn-sdk/vaults" }
-    );
-  }
-  if (options.yieldType !== void 0 && !isValidYieldType(options.yieldType)) {
-    throw new APIError(
-      `Invalid yieldType: ${options.yieldType}. Must be one of: CORE, TREASURY, FRONTIER.`,
-      { endpoint: "/v1/earn-sdk/vaults" }
-    );
-  }
-  if (options.depositTokenAddress !== void 0 && !isValidAddress(options.depositTokenAddress)) {
-    throw new APIError(
-      `Invalid depositTokenAddress: ${options.depositTokenAddress}. Must be a valid Ethereum address.`,
-      { endpoint: "/v1/earn-sdk/vaults" }
-    );
-  }
-}
-function validateAssetFilterOptions(options) {
-  if (!options) return;
-  if (options.chains !== void 0) {
-    if (!Array.isArray(options.chains) || options.chains.length === 0) {
-      throw new APIError(
-        "Invalid chains: Must be a non-empty array of chain IDs.",
-        { endpoint: "/v1/earn-sdk/supported-assets-by-chains" }
-      );
-    }
-    for (const chainId of options.chains) {
-      if (!isValidChainId(chainId)) {
-        throw new APIError(
-          `Invalid chainId in chains array: ${chainId}. Must be a positive integer.`,
-          { endpoint: "/v1/earn-sdk/supported-assets-by-chains" }
-        );
-      }
-    }
-  }
-  if (options.yieldType !== void 0 && !isValidYieldType(options.yieldType)) {
-    throw new APIError(
-      `Invalid yieldType: ${options.yieldType}. Must be one of: CORE, TREASURY, FRONTIER.`,
-      { endpoint: "/v1/earn-sdk/supported-assets-by-chains" }
-    );
-  }
-  if (options.address !== void 0 && !isValidAddress(options.address)) {
-    throw new APIError(
-      `Invalid address: ${options.address}. Must be a valid Ethereum address.`,
-      { endpoint: "/v1/earn-sdk/supported-assets-by-chains" }
-    );
-  }
-  if (options.symbol !== void 0 && typeof options.symbol !== "string") {
-    throw new APIError(`Invalid symbol: ${options.symbol}. Must be a string.`, {
-      endpoint: "/v1/earn-sdk/supported-assets-by-chains"
-    });
-  }
-}
-async function fetchVaultDataFromGraphQL() {
-  const endpoint = getGraphQLEndpoint();
-  const response = await fetchAmplifySdkConfigs(endpoint);
-  const configs = response.amplifySdkConfigs;
-  const vaults = aggregateVaultConfigs(configs);
-  const assets = extractSupportedAssetsFromConfigs(configs);
-  return { vaults, assets };
-}
-function applyVaultFilters(vaults, options) {
-  if (!options) return vaults;
-  let filtered = vaults;
-  if (options.chainId !== void 0) {
-    filtered = filtered.filter((v) => v.chainId === options.chainId);
-  }
-  if (options.yieldType) {
-    filtered = filtered.filter((v) => v.yieldType === options.yieldType);
-  }
-  if (options.depositTokenAddress) {
-    const normalized = options.depositTokenAddress.toLowerCase();
-    filtered = filtered.filter(
-      (v) => v.supportedAssets.some(
-        (a) => a.address.toLowerCase() === normalized
-      )
-    );
-  }
-  return filtered;
-}
-function applyAssetFilters(assets, options) {
-  if (!options) return assets;
-  let filtered = assets;
-  if (options.chains !== void 0 && options.chains.length > 0) {
-    filtered = filtered.filter(
-      (asset) => options.chains?.some((chainId) => asset.chains.includes(chainId))
-    );
-  }
-  if (options.address) {
-    const normalizedAddress = options.address.toLowerCase();
-    filtered = filtered.filter(
-      (asset) => asset.address.toLowerCase() === normalizedAddress
-    );
-  }
-  if (options.symbol) {
-    filtered = filtered.filter((asset) => asset.symbol === options.symbol);
-  }
-  return filtered;
-}
-async function getVaults(options) {
-  validateVaultFilterOptions(options);
-  const cache = getCache();
-  if (cache.isEmpty() || cache.isExpired()) {
-    await cache.refresh();
-  }
-  return applyVaultFilters(cache.getAllVaults(), options);
-}
-async function getSupportedAssets(options) {
-  validateAssetFilterOptions(options);
-  const cache = getCache();
-  if (cache.isEmpty() || cache.isExpired()) {
-    await cache.refresh();
-  }
-  return applyAssetFilters(cache.getAllAssets(), options);
-}
-var globalCache = null;
-function initializeCache(ttl) {
-  globalCache = new VaultCache(ttl);
-  return globalCache;
-}
-function getCache() {
-  if (!globalCache) {
-    globalCache = new VaultCache();
-  }
-  return globalCache;
-}
-async function refreshVaultCache() {
-  const cache = getCache();
-  await cache.refresh();
-}
-function clearCache() {
-  const cache = getCache();
-  cache.clear();
-}
-async function getAssetsFromCache(options) {
-  return getSupportedAssets(options);
-}
-async function findVaultByConfig(params) {
-  if (!isValidAddress(params.assetAddress)) {
-    throw new APIError(
-      `Invalid assetAddress: ${params.assetAddress}. Must be a valid Ethereum address.`,
-      { endpoint: "findVaultByConfig" }
-    );
-  }
-  if (!isValidYieldType(params.yieldType)) {
-    throw new APIError(
-      `Invalid yieldType: ${params.yieldType}. Must be one of: CORE, TREASURY, FRONTIER.`,
-      { endpoint: "findVaultByConfig" }
-    );
-  }
-  if (!isValidChainId(params.chainId)) {
-    throw new APIError(
-      `Invalid chainId: ${params.chainId}. Must be a positive integer.`,
-      { endpoint: "findVaultByConfig" }
-    );
-  }
-  const cache = getCache();
-  if (cache.isEmpty() || cache.isExpired()) {
-    await cache.refresh();
-  }
-  const normalizedAddress = params.assetAddress.toLowerCase();
-  let vaultsByToken = cache.getVault(params.assetAddress);
-  if (!vaultsByToken) {
-    vaultsByToken = cache.getVault(normalizedAddress);
-  }
-  if (!vaultsByToken) {
-    const allVaults = cache.getAllVaults();
-    const matchingVaults = allVaults.filter(
-      (vault) => vault.supportedAssets.some(
-        (a) => a.address.toLowerCase() === normalizedAddress
-      )
-    );
-    vaultsByToken = matchingVaults.length > 0 ? matchingVaults : void 0;
-  }
-  if (!vaultsByToken || vaultsByToken.length === 0) {
-    return null;
-  }
-  const matchingVault = vaultsByToken.find(
-    (vault) => vault.yieldType === params.yieldType && vault.chainId === params.chainId
-  );
-  return matchingVault || null;
-}
-async function getVaultsByConfig(params) {
-  const cache = getCache();
-  if (cache.isEmpty() || cache.isExpired()) {
-    await cache.refresh();
-  }
-  let vaults = cache.getAllVaults();
-  if (params?.yieldType) {
-    if (!isValidYieldType(params.yieldType)) {
-      throw new APIError(
-        `Invalid yieldType: ${params.yieldType}. Must be one of: CORE, TREASURY, FRONTIER.`,
-        { endpoint: "getVaultsByConfig" }
-      );
-    }
-    vaults = vaults.filter((v) => v.yieldType === params.yieldType);
-  }
-  if (params?.chainId !== void 0) {
-    if (!isValidChainId(params.chainId)) {
-      throw new APIError(
-        `Invalid chainId: ${params.chainId}. Must be a positive integer.`,
-        { endpoint: "getVaultsByConfig" }
-      );
-    }
-    vaults = vaults.filter((v) => v.chainId === params.chainId);
-  }
-  if (params?.depositAssetAddress) {
-    if (!isValidAddress(params.depositAssetAddress)) {
-      throw new APIError(
-        `Invalid depositAssetAddress: ${params.depositAssetAddress}.`,
-        { endpoint: "getVaultsByConfig" }
-      );
-    }
-    const normalized = params.depositAssetAddress.toLowerCase();
-    vaults = vaults.filter(
-      (v) => v.supportedAssets.some(
-        (a) => a.address.toLowerCase() === normalized
-      )
-    );
-  }
-  if (params?.withdrawAssetAddress) {
-    if (!isValidAddress(params.withdrawAssetAddress)) {
-      throw new APIError(
-        `Invalid withdrawAssetAddress: ${params.withdrawAssetAddress}.`,
-        { endpoint: "getVaultsByConfig" }
-      );
-    }
-    const normalized = params.withdrawAssetAddress.toLowerCase();
-    vaults = vaults.filter(
-      (v) => v.supportedAssets.some(
-        (a) => a.withdrawable !== false && a.address.toLowerCase() === normalized
-      )
-    );
-  }
-  if (params?.settlementAssetAddress) {
-    if (!isValidAddress(params.settlementAssetAddress)) {
-      throw new APIError(
-        `Invalid settlementAssetAddress: ${params.settlementAssetAddress}.`,
-        { endpoint: "getVaultsByConfig" }
-      );
-    }
-    const normalized = params.settlementAssetAddress.toLowerCase();
-    vaults = vaults.filter(
-      (v) => v.supportedAssets.some(
-        (a) => a.address.toLowerCase() === normalized
-      )
-    );
-  }
-  return vaults;
-}
-async function getWithdrawSupportedAssets() {
-  const cache = getCache();
-  if (cache.isEmpty() || cache.isExpired()) {
-    await cache.refresh();
-  }
-  const vaults = cache.getAllVaults();
-  const assets = cache.getAllAssets();
-  const result = [];
-  const assetMap = /* @__PURE__ */ new Map();
-  for (const asset of assets) {
-    assetMap.set(asset.address.toLowerCase(), asset);
-  }
-  const assetVaultMap = /* @__PURE__ */ new Map();
-  for (const vault of vaults) {
-    for (const asset of vault.supportedAssets) {
-      const assetAddress = asset.address.toLowerCase();
-      if (!assetVaultMap.has(assetAddress)) {
-        assetVaultMap.set(assetAddress, []);
-      }
-      assetVaultMap.get(assetAddress)?.push({
-        id: vault.id,
-        yieldType: vault.yieldType,
-        chainId: vault.chainId,
-        vaultId: vault.id
-      });
-    }
-  }
-  for (const [assetAddress, vaultsData] of assetVaultMap.entries()) {
-    const asset = assetMap.get(assetAddress);
-    if (asset) {
-      result.push({
-        address: asset.address,
-        symbol: asset.symbol,
-        decimals: asset.decimals,
-        vaults: vaultsData
-      });
-    }
-  }
-  return result;
-}
-var hyperEvm = viem.defineChain({
-  id: 999,
-  name: "HyperEVM",
-  nativeCurrency: {
-    decimals: 18,
-    name: "Hyperliquid",
-    symbol: "HYPE"
-  },
-  rpcUrls: {
-    default: {
-      http: ["https://rpc.hyperliquid.xyz/evm"],
-      webSocket: ["wss://hyperliquid.drpc.org"]
-    }
-  },
-  blockExplorers: {
-    default: { name: "Explorer", url: "https://purrsec.com/" }
-  },
-  contracts: {
-    multicall3: {
-      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
-      blockCreated: 13051
-    }
-  }
-});
-var stableTestnet = viem.defineChain({
-  id: 2201,
-  name: "Stable Testnet",
-  nativeCurrency: {
-    decimals: 18,
-    name: "Ether",
-    symbol: "ETH"
-  },
-  rpcUrls: {
-    default: {
-      http: ["https://rpc.testnet.stable.xyz"]
-    }
-  },
-  blockExplorers: {
-    default: { name: "Stablescan", url: "https://testnet.stablescan.xyz" }
-  },
-  contracts: {
-    multicall3: {
-      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
-      blockCreated: 0
-    }
-  },
-  testnet: true
-});
-var CHAIN_ID_TO_CHAIN_MAP = {
-  [chains.mainnet.id]: chains.mainnet,
-  [chains.sepolia.id]: chains.sepolia,
-  [chains.base.id]: chains.base,
-  [hyperEvm.id]: hyperEvm,
-  [stableTestnet.id]: stableTestnet
-};
-
-// src/utils/chain-utils.ts
-function toChainId(value) {
-  return typeof value === "number" ? value : Number(value);
-}
-var chainsCache = null;
-async function getChainFromConfig(chainId, config) {
-  if (chainsCache && !config) {
-    const chain2 = chainsCache.get(Number(chainId));
-    if (chain2) {
-      return chain2;
-    }
-  }
-  const vaults = config ?? await getVaults();
-  const numericChainId = Number(chainId);
-  const knownChain = CHAIN_ID_TO_CHAIN_MAP[numericChainId];
-  const vaultForChain = vaults.find((v) => v.chainId === numericChainId);
-  if (!knownChain && !vaultForChain) {
-    throw new Error(`Vault not found for ID: ${chainId}`);
-  }
-  if (config && !chainsCache) {
-    const cache = /* @__PURE__ */ new Map();
-    for (const v of vaults) {
-      const chainConfig = CHAIN_ID_TO_CHAIN_MAP[v.chainId];
-      if (!chainConfig) {
-        throw new Error(`Chain config not found for ID: ${v.chainId}`);
-      }
-      cache.set(v.chainId, {
-        id: v.chainId,
-        name: chainConfig.name,
-        nativeCurrency: chainConfig.nativeCurrency,
-        rpcUrls: chainConfig.rpcUrls,
-        contracts: chainConfig.contracts
-      });
-    }
-    if (knownChain && !cache.has(numericChainId)) {
-      cache.set(numericChainId, {
-        id: numericChainId,
-        name: knownChain.name,
-        nativeCurrency: knownChain.nativeCurrency,
-        rpcUrls: knownChain.rpcUrls,
-        contracts: knownChain.contracts
-      });
-    }
-    chainsCache = cache;
-  }
-  const chain = chainsCache ? chainsCache.get(numericChainId) : void 0;
-  if (!chain) {
-    throw new Error(`Chain not found for ID: ${chainId}`);
-  }
-  return chain;
-}
-function getChainNameById(chainId) {
-  return CHAIN_ID_TO_CHAIN_MAP[chainId]?.name || null;
-}
-function clearChainsCache() {
-  chainsCache = null;
-}
-
-// src/lib/viem/client.ts
-var clients = /* @__PURE__ */ new Map();
-var warnedChains = /* @__PURE__ */ new Set();
-var getClient = async (chainId) => {
-  if (!chainId) {
-    throw new Error("Chain ID is required");
-  }
-  const numericChainId = toChainId(chainId);
-  if (!clients.has(numericChainId)) {
-    const chain = await getChainFromConfig(
-      numericChainId,
-      await getVaults()
-    );
-    const customRpcUrl = getRpcUrls()[numericChainId];
-    if (!customRpcUrl && !warnedChains.has(numericChainId)) {
-      warnedChains.add(numericChainId);
-      getLogger().warn(
-        `No custom RPC URL provided for chain ${numericChainId} (${chain.name}). Using default public RPC. Public RPCs may be unreliable \u2014 pass rpcUrls in initAmplifySDK() options for better reliability.`
-      );
-    }
-    const rpcUrl = customRpcUrl ?? chain.rpcUrls.default.http[0];
-    const client2 = viem.createPublicClient({
-      chain,
-      transport: viem.http(rpcUrl)
-    });
-    clients.set(numericChainId, client2);
-  }
-  const client = clients.get(numericChainId);
-  if (!client) {
-    throw new Error(`Client not found for chain ID ${chainId}`);
-  }
-  return client;
-};
-function clearClients() {
-  clients.clear();
-  warnedChains.clear();
-}
-
-// src/lib/sdk-config.ts
-var MAX_CACHE_RETRIES = 3;
-var RETRY_DELAYS = [1e3, 2e3, 4e3];
-var sdkConfig = {
-  apiKey: null,
-  isInitialized: false,
-  initializedAt: null,
-  isInitializing: false,
-  initPromise: null,
-  telemetryEnabled: true,
-  cachePopulationPromise: null,
-  isCacheReady: false,
-  rpcUrls: {}
-};
-var ERROR_MESSAGES = {
-  INVALID_API_KEY: "Invalid API key format. Expected format: pxl_<type>_<string>",
-  EMPTY_API_KEY: "API key cannot be empty. Provide a valid API key from Paxos Labs.",
-  UNKNOWN_ERROR: "Unexpected initialization error. Contact support if issue persists."};
-function validateAPIKey(apiKey) {
-  if (!apiKey || apiKey.trim().length === 0) {
-    throw new APIError(ERROR_MESSAGES.EMPTY_API_KEY, {
-      endpoint: "initAmplifySDK",
-      statusCode: void 0
-    });
-  }
-  if (apiKey.length < 10) {
-    throw new APIError(ERROR_MESSAGES.INVALID_API_KEY, {
-      endpoint: "initAmplifySDK",
-      statusCode: void 0
-    });
-  }
-  if (!apiKey.startsWith("pxl_")) ;
-}
-function setAPIKey(apiKey) {
-  sdkConfig.apiKey = apiKey;
-}
-function getAPIKey() {
-  return sdkConfig.apiKey;
-}
-function getRpcUrls() {
-  return { ...sdkConfig.rpcUrls };
-}
-function clearConfig() {
-  sdkConfig.apiKey = null;
-  sdkConfig.isInitialized = false;
-  sdkConfig.initializedAt = null;
-  sdkConfig.isInitializing = false;
-  sdkConfig.initPromise = null;
-  sdkConfig.telemetryEnabled = true;
-  sdkConfig.cachePopulationPromise = null;
-  sdkConfig.isCacheReady = false;
-  sdkConfig.rpcUrls = {};
-  clearClients();
-  resetTelemetry();
-}
-function getRequestHeaders() {
-  const apiKey = getAPIKey();
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    headers["x-api-key"] = apiKey;
-  }
-  return headers;
-}
-async function populateCacheInBackground(cache) {
-  const logger = getLogger();
-  for (let attempt = 0; attempt < MAX_CACHE_RETRIES; attempt++) {
-    try {
-      await cache.refresh();
-      sdkConfig.isCacheReady = true;
-      logger.debug("Background cache population completed", {
-        attempt: attempt + 1
-      });
-      return;
-    } catch (error) {
-      const isLastAttempt = attempt === MAX_CACHE_RETRIES - 1;
-      if (isLastAttempt) {
-        logger.warn(
-          "Background cache population failed after all retries, falling back to on-demand fetching",
-          {
-            error: error instanceof Error ? error.message : String(error),
-            attempts: MAX_CACHE_RETRIES
-          }
-        );
-        return;
-      }
-      logger.debug(
-        `Cache population attempt ${attempt + 1} failed, retrying...`,
-        {
-          error: error instanceof Error ? error.message : String(error),
-          nextRetryIn: RETRY_DELAYS[attempt]
-        }
-      );
-      await new Promise(
-        (resolve) => setTimeout(resolve, RETRY_DELAYS[attempt])
-      );
-    }
-  }
-}
-function isCacheReady() {
-  return sdkConfig.isCacheReady;
-}
-async function waitForCacheReady() {
-  if (sdkConfig.isCacheReady) {
-    return;
-  }
-  if (sdkConfig.cachePopulationPromise) {
-    await sdkConfig.cachePopulationPromise;
-    if (sdkConfig.isCacheReady) {
-      return;
-    }
-  }
-  const cache = getCache();
-  await cache.refresh();
-  sdkConfig.isCacheReady = true;
-}
-async function initAmplifySDK(apiKey, options) {
-  validateAPIKey(apiKey);
-  if (sdkConfig.isInitialized && sdkConfig.apiKey === apiKey) {
-    const nextRpcUrls = options?.rpcUrls ?? {};
-    const hasRpcUrlChange = Object.keys(nextRpcUrls).length !== Object.keys(sdkConfig.rpcUrls).length || Object.entries(nextRpcUrls).some(
-      ([chainId, url]) => sdkConfig.rpcUrls[Number(chainId)] !== url
-    );
-    if (hasRpcUrlChange) {
-      sdkConfig.rpcUrls = { ...nextRpcUrls };
-      clearClients();
-    }
-    return;
-  }
-  if (sdkConfig.isInitializing && sdkConfig.initPromise) {
-    await sdkConfig.initPromise;
-    return;
-  }
-  if (sdkConfig.isInitialized && sdkConfig.apiKey !== apiKey) {
-    clearConfig();
-    clearCache();
-  }
-  if (options?.logger) {
-    setLogger(options.logger);
-  }
-  if (options?.logLevel !== void 0) {
-    setLogLevel(options.logLevel);
-  }
-  sdkConfig.telemetryEnabled = options?.telemetry !== false;
-  sdkConfig.rpcUrls = options?.rpcUrls ?? {};
-  sdkConfig.isInitializing = true;
-  sdkConfig.initPromise = (async () => {
-    try {
-      setAPIKey(apiKey);
-      const cache = initializeCache();
-      sdkConfig.isInitialized = true;
-      sdkConfig.initializedAt = /* @__PURE__ */ new Date();
-      sdkConfig.isCacheReady = false;
-      sdkConfig.cachePopulationPromise = populateCacheInBackground(cache);
-      if (sdkConfig.telemetryEnabled) {
-        initTelemetry(apiKey).catch(() => {
-        });
-      }
-      getLogger().info(
-        "Amplify SDK initialized (cache populating in background)"
-      );
-    } catch (error) {
-      clearConfig();
-      clearCache();
-      if (error instanceof APIError) {
-        throw error;
-      }
-      throw new APIError(ERROR_MESSAGES.UNKNOWN_ERROR, {
-        endpoint: "initAmplifySDK",
-        cause: error
-      });
-    } finally {
-      sdkConfig.isInitializing = false;
-      sdkConfig.initPromise = null;
-    }
-  })();
-  await sdkConfig.initPromise;
-}
-
-exports.APIError = APIError;
-exports.API_BASE_URL = API_BASE_URL;
-exports.CHAINLINK_ADDRESS = CHAINLINK_ADDRESS;
-exports.DEFAULT_APPROVAL_AMOUNT = DEFAULT_APPROVAL_AMOUNT;
-exports.DEFAULT_DEADLINE = DEFAULT_DEADLINE;
-exports.DEFAULT_SLIPPAGE_BPS = DEFAULT_SLIPPAGE_BPS;
-exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
-exports.LogLevel = LogLevel;
-exports.YieldType = YieldType;
-exports.clearChainsCache = clearChainsCache;
-exports.createTimeoutSignal = createTimeoutSignal;
-exports.findVaultByConfig = findVaultByConfig;
-exports.getAssetsFromCache = getAssetsFromCache;
-exports.getCache = getCache;
-exports.getChainFromConfig = getChainFromConfig;
-exports.getChainNameById = getChainNameById;
-exports.getClient = getClient;
-exports.getLogger = getLogger;
-exports.getRequestHeaders = getRequestHeaders;
-exports.getRestV2BaseURL = getRestV2BaseURL;
-exports.getSupportedAssets = getSupportedAssets;
-exports.getVaults = getVaults;
-exports.getVaultsByConfig = getVaultsByConfig;
-exports.getWithdrawSupportedAssets = getWithdrawSupportedAssets;
-exports.initAmplifySDK = initAmplifySDK;
-exports.initializeCache = initializeCache;
-exports.isCacheReady = isCacheReady;
-exports.isValidAddress = isValidAddress;
-exports.isValidChainId = isValidChainId;
-exports.refreshVaultCache = refreshVaultCache;
-exports.setLogLevel = setLogLevel;
-exports.setLogger = setLogger;
-exports.toChainId = toChainId;
-exports.waitForCacheReady = waitForCacheReady;
-//# sourceMappingURL=chunk-E5DH5YEE.js.map
-//# sourceMappingURL=chunk-E5DH5YEE.js.map