feat: support both chains.json keys and selector names in API

Add bidirectional mapping to accept both naming conventions:
- chains.json keys: mainnet, bsc-mainnet
- selector names: ethereum-mainnet, binance_smart_chain-mainnet

This enables gradual migration to consistent naming while maintaining
backward compatibility with existing URLs.

Updated:
- LaneDataService.resolveToInternalId: accepts both formats
- RateLimitsDataService.getFilteredRateLimits: resolves identifiers before lookup

Author: aelmanaa

src/lib/ccip/services/lane-data.ts

@@ -524,21 +524,69 @@ export class LaneDataService {
   }
 
   /**
-   * Resolves a chain identifier to its internal ID
+   * Builds a mapping from selector names (e.g., "ethereum-mainnet") to chains.json keys (e.g., "mainnet")
+   * This enables the API to accept both naming conventions.
+   *
+   * @param chainsReferenceData - Chain configuration data
+   * @returns Map of selector name → chains.json key
+   */
+  private buildSelectorNameToChainKeyMap(chainsReferenceData: Record<string, ChainConfig>): Map<string, string> {
+    const map = new Map<string, string>()
+
+    for (const [chainKey, chainConfig] of Object.entries(chainsReferenceData)) {
+      try {
+        // Get the chain ID and type to look up the selector entry
+        const supportedChain = directoryToSupportedChain(chainKey)
+        const chainId = getChainId(supportedChain)
+        const { chainType } = getChainTypeAndFamily(supportedChain)
+
+        if (chainId) {
+          const selectorEntry = getSelectorEntry(chainId, chainType)
+          if (selectorEntry?.name && selectorEntry.name !== chainKey) {
+            // Map selector name to chains.json key
+            map.set(selectorEntry.name, chainKey)
+          }
+        }
+      } catch {
+        // Skip chains that can't be resolved
+      }
+    }
+
+    return map
+  }
+
+  /**
+   * Resolves a chain identifier to its internal ID (chains.json key)
+   *
+   * Accepts both:
+   * - chains.json keys (e.g., "mainnet", "bsc-mainnet")
+   * - selector names (e.g., "ethereum-mainnet", "binance_smart_chain-mainnet")
    *
    * @param identifier - Chain identifier (chainId, selector, or internalId)
    * @param inputKeyType - Type of identifier
    * @param chainsReferenceData - Chain configuration data
-   * @returns Internal ID or null if not found
+   * @returns Internal ID (chains.json key) or null if not found
    */
   resolveToInternalId(
     identifier: string,
     inputKeyType: LaneInputKeyType,
     chainsReferenceData: Record<string, ChainConfig>
   ): string | null {
-    // If already an internal_id, return it directly
+    // If already an internal_id, check both chains.json key and selector name
     if (inputKeyType === "internalId") {
-      return chainsReferenceData[identifier] ? identifier : null
+      // First, try direct lookup in chains.json keys
+      if (chainsReferenceData[identifier]) {
+        return identifier
+      }
+
+      // If not found, check if identifier is a selector name and map to chains.json key
+      const selectorNameMap = this.buildSelectorNameToChainKeyMap(chainsReferenceData)
+      const chainKey = selectorNameMap.get(identifier)
+      if (chainKey && chainsReferenceData[chainKey]) {
+        return chainKey
+      }
+
+      return null
     }
 
     // Search through chains to find matching chain_id or selector

src/lib/ccip/services/rate-limits-data.ts

@@ -60,11 +60,39 @@ export class RateLimitsDataService {
     })
 
     try {
+      // Load reference data to resolve chain identifiers
+      const { chainsReferenceData } = loadReferenceData({
+        environment,
+        version: Version.V1_2_0,
+      })
+
+      // Resolve chain identifiers to chains.json keys (handles both short names and selector names)
+      const laneDataService = new LaneDataService()
+      const resolvedSourceId =
+        laneDataService.resolveToInternalId(
+          filters.sourceInternalId,
+          "internalId",
+          chainsReferenceData as Record<string, ChainConfig>
+        ) || filters.sourceInternalId
+      const resolvedDestId =
+        laneDataService.resolveToInternalId(
+          filters.destinationInternalId,
+          "internalId",
+          chainsReferenceData as Record<string, ChainConfig>
+        ) || filters.destinationInternalId
+
+      // Create resolved filters
+      const resolvedFilters: RateLimitsFilterType = {
+        ...filters,
+        sourceInternalId: resolvedSourceId,
+        destinationInternalId: resolvedDestId,
+      }
+
       // Load the appropriate rate limits data based on environment
       const rateLimitsData = this.loadRateLimitsData(environment)
 
       // Extract rate limits for the specified lane
-      const result = this.extractLaneRateLimits(rateLimitsData, filters)
+      const result = this.extractLaneRateLimits(rateLimitsData, resolvedFilters)
 
       const tokenCount = Object.keys(result).length