@openzeppelin/ui-builder-adapter-evm 1.2.0 → 1.4.0

package/src/configuration/explorer.ts

@@ -1,243 +0,0 @@
-import { NetworkConfig, UserExplorerConfig } from '@openzeppelin/ui-types';
-import { appConfigService, logger, userNetworkServiceConfigService } from '@openzeppelin/ui-utils';
-
-import { shouldUseV2Api, testEtherscanV2Connection } from '../abi/etherscan-v2';
-import { TypedEvmNetworkConfig } from '../types';
-import { isValidEvmAddress } from '../utils';
-
-/**
- * Resolves the explorer configuration for a given EVM network.
- * Priority order:
- * 1. User-configured explorer (from UserExplorerConfigService)
- * 2. For V2 API networks: Global Etherscan V2 API key (from AppConfigService global service configs)
- * 3. App-configured explorer API key (from AppConfigService network service configs)
- * 4. Default network explorer (from NetworkConfig)
- *
- * @param networkConfig - The EVM network configuration.
- * @returns The resolved explorer configuration.
- */
-export function resolveExplorerConfig(networkConfig: TypedEvmNetworkConfig): UserExplorerConfig {
-  // Precompute app-level keys and defaults for merging
-  const isV2 =
-    networkConfig.supportsEtherscanV2 &&
-    networkConfig.primaryExplorerApiIdentifier === 'etherscan-v2';
-  const globalV2ApiKey = isV2
-    ? (appConfigService.getGlobalServiceConfig('etherscanv2')?.apiKey as string | undefined)
-    : undefined;
-  const appApiKey = networkConfig.primaryExplorerApiIdentifier
-    ? appConfigService.getExplorerApiKey(networkConfig.primaryExplorerApiIdentifier)
-    : undefined;
-
-  // 1. Check for user-configured explorer via new generic service
-  const rawCfg = userNetworkServiceConfigService.get(networkConfig.id, 'explorer');
-  if (rawCfg && typeof rawCfg === 'object') {
-    const userCfg = rawCfg as Record<string, unknown>;
-    logger.info('ExplorerConfig', `Using user-configured explorer for ${networkConfig.name}`);
-    return {
-      explorerUrl: (userCfg.explorerUrl as string | undefined) ?? networkConfig.explorerUrl,
-      apiUrl: (userCfg.apiUrl as string | undefined) ?? networkConfig.apiUrl,
-      apiKey: (userCfg.apiKey as string | undefined) ?? globalV2ApiKey ?? appApiKey,
-      name: `${networkConfig.name} Explorer`,
-      isCustom: true,
-    };
-  }
-
-  // 2. For V2 API networks using 'etherscan-v2' identifier, check for global Etherscan V2 API key
-  if (isV2 && globalV2ApiKey) {
-    logger.info('ExplorerConfig', `Using global Etherscan V2 API key for ${networkConfig.name}`);
-    return {
-      explorerUrl: networkConfig.explorerUrl,
-      apiUrl: networkConfig.apiUrl,
-      apiKey: globalV2ApiKey,
-      name: `${networkConfig.name} Explorer (V2 API)`,
-      isCustom: false,
-    };
-  }
-
-  // 3. Check for app-configured API key (V1 style or other identifiers)
-  if (appApiKey) {
-    logger.info('ExplorerConfig', `Using app-configured API key for ${networkConfig.name}`);
-    return {
-      explorerUrl: networkConfig.explorerUrl,
-      apiUrl: networkConfig.apiUrl,
-      apiKey: appApiKey,
-      name: `${networkConfig.name} Explorer`,
-      isCustom: false,
-    };
-  }
-
-  // 4. Use default network explorer (no API key)
-  logger.info(
-    'ExplorerConfig',
-    `Using default explorer for ${networkConfig.name} (no API key configured)`
-  );
-  return {
-    explorerUrl: networkConfig.explorerUrl,
-    apiUrl: networkConfig.apiUrl,
-    name: `${networkConfig.name} Explorer`,
-    isCustom: false,
-  };
-}
-
-/**
- * Gets a blockchain explorer URL for an EVM address.
- * Uses the resolved explorer configuration.
- */
-export function getEvmExplorerAddressUrl(
-  address: string,
-  networkConfig: NetworkConfig
-): string | null {
-  if (!isValidEvmAddress(address)) {
-    return null;
-  }
-
-  const explorerConfig = resolveExplorerConfig(networkConfig as TypedEvmNetworkConfig);
-  if (!explorerConfig.explorerUrl) {
-    return null;
-  }
-
-  // Construct the URL using the explorerUrl from the config
-  const baseUrl = explorerConfig.explorerUrl.replace(/\/+$/, '');
-  return `${baseUrl}/address/${address}`;
-}
-
-/**
- * Gets a blockchain explorer URL for an EVM transaction.
- * Uses the resolved explorer configuration.
- */
-export function getEvmExplorerTxUrl(txHash: string, networkConfig: NetworkConfig): string | null {
-  if (!txHash) {
-    return null;
-  }
-
-  const explorerConfig = resolveExplorerConfig(networkConfig as TypedEvmNetworkConfig);
-  if (!explorerConfig.explorerUrl) {
-    return null;
-  }
-
-  // Construct the URL using the explorerUrl from the config
-  const baseUrl = explorerConfig.explorerUrl.replace(/\/+$/, '');
-  return `${baseUrl}/tx/${txHash}`;
-}
-
-/**
- * Validates an EVM explorer configuration.
- * Checks URL formats and API key format.
- */
-export function validateEvmExplorerConfig(explorerConfig: UserExplorerConfig): boolean {
-  // Validate URLs if provided
-  if (explorerConfig.explorerUrl) {
-    try {
-      new URL(explorerConfig.explorerUrl);
-    } catch {
-      return false;
-    }
-  }
-
-  if (explorerConfig.apiUrl) {
-    try {
-      new URL(explorerConfig.apiUrl);
-    } catch {
-      return false;
-    }
-  }
-
-  // Basic API key validation (not empty)
-  if (explorerConfig.apiKey !== undefined && explorerConfig.apiKey.trim().length === 0) {
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * Tests the connection to an EVM explorer API.
- * Makes a test API call to verify the API key works.
- */
-export async function testEvmExplorerConnection(
-  explorerConfig: UserExplorerConfig,
-  networkConfig?: TypedEvmNetworkConfig
-): Promise<{
-  success: boolean;
-  latency?: number;
-  error?: string;
-}> {
-  // Check if API key is required for this network
-  const requiresApiKey =
-    networkConfig && 'requiresExplorerApiKey' in networkConfig
-      ? networkConfig.requiresExplorerApiKey !== false
-      : true;
-
-  if (requiresApiKey && !explorerConfig.apiKey) {
-    return {
-      success: false,
-      error: 'API key is required for testing connection to this explorer',
-    };
-  }
-
-  // Check if we should use V2 API
-  if (networkConfig && shouldUseV2Api(networkConfig)) {
-    return testEtherscanV2Connection(networkConfig, explorerConfig.apiKey);
-  }
-
-  // Use V1 API (legacy)
-  // Use provided API URL or fall back to network config if available
-  let apiUrl = explorerConfig.apiUrl;
-  if (!apiUrl && networkConfig?.apiUrl) {
-    apiUrl = networkConfig.apiUrl;
-  }
-
-  if (!apiUrl) {
-    return {
-      success: false,
-      error:
-        'API URL is required for testing connection. Please provide an API URL or ensure the network has a default API URL configured.',
-    };
-  }
-
-  const startTime = Date.now();
-
-  try {
-    // Test with a simple API call - get the latest block number
-    const url = new URL(apiUrl);
-    url.searchParams.append('module', 'proxy');
-    url.searchParams.append('action', 'eth_blockNumber');
-    if (explorerConfig.apiKey) {
-      url.searchParams.append('apikey', explorerConfig.apiKey);
-    }
-
-    const response = await fetch(url.toString());
-    const latency = Date.now() - startTime;
-
-    if (!response.ok) {
-      return {
-        success: false,
-        error: `HTTP ${response.status}: ${response.statusText}`,
-        latency,
-      };
-    }
-
-    const data = await response.json();
-
-    // Check for API errors in the response
-    if (data.status === '0' && data.message) {
-      return {
-        success: false,
-        error: data.message,
-        latency,
-      };
-    }
-
-    // Success if we got a valid response
-    return {
-      success: true,
-      latency,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Connection test failed',
-      latency: Date.now() - startTime,
-    };
-  }
-}

package/src/configuration/rpc.ts

@@ -1,257 +0,0 @@
-import type { EvmNetworkConfig, UserRpcProviderConfig } from '@openzeppelin/ui-types';
-import {
-  appConfigService,
-  isValidUrl,
-  logger,
-  userNetworkServiceConfigService,
-} from '@openzeppelin/ui-utils';
-
-/**
- * Builds a complete RPC URL from a user RPC provider configuration.
- * For simplified RPC configuration, this just returns the URL as-is since
- * users are now providing complete RPC URLs including any API keys.
- *
- * @param config The user RPC provider configuration
- * @returns The RPC URL
- */
-export function buildRpcUrl(config: UserRpcProviderConfig): string {
-  return config.url;
-}
-
-/**
- * Extracts the user-configured RPC URL from UserNetworkServiceConfigService.
- *
- * @param networkId - The network ID to get the RPC URL for
- * @returns The RPC URL string if configured, undefined otherwise
- */
-export function getUserRpcUrl(networkId: string): string | undefined {
-  const svcCfg = userNetworkServiceConfigService.get(networkId, 'rpc');
-  if (svcCfg && typeof svcCfg === 'object' && 'rpcUrl' in svcCfg) {
-    return (svcCfg as Record<string, unknown>).rpcUrl as string;
-  }
-  return undefined;
-}
-
-/**
- * Resolves the RPC URL for a given EVM network configuration.
- * Priority order:
- * 1. User-provided RPC configuration (from UserRpcConfigService)
- * 2. RPC URL override from AppConfigService
- * 3. Default rpcUrl from the network configuration
- *
- * @param networkConfig - The EVM network configuration.
- * @returns The resolved RPC URL string.
- * @throws If no RPC URL can be resolved (neither user config, override, nor default is present and valid).
- */
-export function resolveRpcUrl(networkConfig: EvmNetworkConfig): string {
-  const logSystem = 'RpcResolver';
-  const networkId = networkConfig.id;
-
-  // First priority: Check adapter-led service config (generic)
-  const userRpcUrl = getUserRpcUrl(networkId);
-  if (userRpcUrl) {
-    const userRpcUrlString = String(userRpcUrl);
-    if (isValidUrl(userRpcUrlString)) {
-      logger.info(logSystem, `Using user-configured RPC URL for network ${networkId}`);
-      return userRpcUrlString;
-    } else {
-      logger.warn(
-        logSystem,
-        `User-configured RPC URL for ${networkId} is invalid: ${userRpcUrlString}. Falling back.`
-      );
-    }
-  }
-
-  // Second priority: Check AppConfigService for an override
-  const rpcOverrideSetting = appConfigService.getRpcEndpointOverride(networkId);
-  let rpcUrlFromOverride: string | undefined;
-
-  if (typeof rpcOverrideSetting === 'string') {
-    rpcUrlFromOverride = rpcOverrideSetting;
-  } else if (typeof rpcOverrideSetting === 'object' && rpcOverrideSetting) {
-    // Check if it's a UserRpcProviderConfig
-    if ('url' in rpcOverrideSetting && 'isCustom' in rpcOverrideSetting) {
-      const userConfig = rpcOverrideSetting as UserRpcProviderConfig;
-      rpcUrlFromOverride = buildRpcUrl(userConfig);
-    } else if ('http' in rpcOverrideSetting) {
-      // It's an RpcEndpointConfig
-      rpcUrlFromOverride = rpcOverrideSetting.http;
-    }
-  }
-
-  if (rpcUrlFromOverride) {
-    logger.info(
-      logSystem,
-      `Using overridden RPC URL for network ${networkId}: ${rpcUrlFromOverride}`
-    );
-    if (isValidUrl(rpcUrlFromOverride)) {
-      return rpcUrlFromOverride;
-    } else {
-      logger.warn(
-        logSystem,
-        `Overridden RPC URL for ${networkId} is invalid: ${rpcUrlFromOverride}. Falling back.`
-      );
-    }
-  }
-
-  // Third priority: Fallback to the rpcUrl in the networkConfig
-  if (networkConfig.rpcUrl && isValidUrl(networkConfig.rpcUrl)) {
-    logger.debug(
-      logSystem,
-      `Using default RPC URL for network ${networkId}: ${networkConfig.rpcUrl}`
-    );
-    return networkConfig.rpcUrl;
-  }
-
-  logger.error(
-    logSystem,
-    `No valid RPC URL could be resolved for network ${networkId}. Checked user config, override, and networkConfig.rpcUrl.`
-  );
-  throw new Error(
-    `No valid RPC URL configured for network ${networkConfig.name} (ID: ${networkId}).`
-  );
-}
-
-/**
- * Validates an RPC endpoint configuration for EVM networks.
- * @param rpcConfig - The RPC provider configuration to validate
- * @returns True if the configuration is valid, false otherwise
- */
-export function validateEvmRpcEndpoint(rpcConfig: UserRpcProviderConfig): boolean {
-  try {
-    // Check if it's a valid URL (our validator already ensures HTTP/HTTPS)
-    if (!isValidUrl(rpcConfig.url)) {
-      logger.error('validateEvmRpcEndpoint', `Invalid RPC URL format: ${rpcConfig.url}`);
-      return false;
-    }
-
-    // Additional EVM-specific validation could be added here
-    // For example, checking if the URL follows known provider patterns
-
-    return true;
-  } catch (error) {
-    logger.error('validateEvmRpcEndpoint', 'Error validating RPC endpoint:', error);
-    return false;
-  }
-}
-
-/**
- * Tests the connection to an EVM RPC endpoint with a timeout.
- * @param rpcConfig - The RPC provider configuration to test
- * @param timeoutMs - Timeout in milliseconds (default: 5000ms)
- * @returns Connection test results including success status, latency, and any errors
- */
-export async function testEvmRpcConnection(
-  rpcConfig: UserRpcProviderConfig,
-  timeoutMs: number = 5000
-): Promise<{
-  success: boolean;
-  latency?: number;
-  error?: string;
-}> {
-  if (!rpcConfig.url) {
-    return { success: false, error: 'RPC URL is required' };
-  }
-
-  // Create an AbortController for timeout
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-
-  try {
-    const startTime = Date.now();
-
-    // Use fetch to make a JSON-RPC call to test the connection
-    const response = await fetch(rpcConfig.url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        method: 'eth_blockNumber',
-        params: [],
-        id: 1,
-      }),
-      signal: controller.signal,
-    });
-
-    if (!response.ok) {
-      return { success: false, error: `HTTP error: ${response.status}` };
-    }
-
-    const data = await response.json();
-    const latency = Date.now() - startTime;
-
-    if (data.error) {
-      return { success: false, error: data.error.message || 'RPC error' };
-    }
-
-    return { success: true, latency };
-  } catch (error) {
-    logger.error('testEvmRpcConnection', 'Connection test failed:', error);
-
-    // Check if the error was due to timeout
-    if (error instanceof Error && error.name === 'AbortError') {
-      return {
-        success: false,
-        error: `Connection timeout after ${timeoutMs}ms`,
-      };
-    }
-
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Connection failed',
-    };
-  } finally {
-    // Clear the timeout
-    clearTimeout(timeoutId);
-  }
-}
-
-/**
- * Gets the current block number from an EVM network.
- *
- * @param networkConfig - The EVM network configuration
- * @returns Promise resolving to the current block number
- * @throws Error if the RPC call fails
- */
-export async function getEvmCurrentBlock(networkConfig: EvmNetworkConfig): Promise<number> {
-  const rpcUrl = resolveRpcUrl(networkConfig);
-
-  try {
-    const response = await fetch(rpcUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        method: 'eth_blockNumber',
-        params: [],
-        id: 1,
-      }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`RPC request failed with status ${response.status}`);
-    }
-
-    const data = await response.json();
-    if (data.error) {
-      throw new Error(data.error.message || 'RPC error');
-    }
-
-    // eth_blockNumber returns a hex string
-    if (data.result === undefined || data.result === null) {
-      throw new Error('RPC response missing result field');
-    }
-    const blockNumber = parseInt(data.result, 16);
-    if (isNaN(blockNumber)) {
-      throw new Error(`Invalid block number returned: ${data.result}`);
-    }
-    return blockNumber;
-  } catch (error) {
-    logger.error('getEvmCurrentBlock', 'Failed to get current block:', error);
-    throw new Error(
-      `Failed to get current block: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}

package/src/mapping/__tests__/field-generator.test.ts

@@ -1,137 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import type { FunctionParameter } from '@openzeppelin/ui-types';
-
-import { generateEvmDefaultField } from '../field-generator';
-
-// Helper to create a mock function parameter
-const createParam = (type: string, name: string, description?: string): FunctionParameter => ({
-  name,
-  type,
-  displayName: name,
-  description,
-});
-
-describe('EVM Field Generator', () => {
-  describe('generateEvmDefaultField', () => {
-    it('should generate a number field for small integer types', () => {
-      const param = createParam('uint32', 'count');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.type).toBe('number');
-      expect(field.validation.required).toBe(true);
-      expect(field.validation.min).toBe(0);
-      expect(field.validation.max).toBe(4_294_967_295);
-      expect(field.validation.pattern).toBeUndefined();
-    });
-
-    it('should apply numeric bounds for uint8', () => {
-      const param = createParam('uint8', 'byte');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.validation.min).toBe(0);
-      expect(field.validation.max).toBe(255);
-    });
-
-    it('should apply numeric bounds for int8', () => {
-      const param = createParam('int8', 'signedByte');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.validation.min).toBe(-128);
-      expect(field.validation.max).toBe(127);
-    });
-
-    it('should apply numeric bounds for int32', () => {
-      const param = createParam('int32', 'signedInt');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.validation.min).toBe(-2_147_483_648);
-      expect(field.validation.max).toBe(2_147_483_647);
-    });
-
-    it('should generate a bigint field for uint128', () => {
-      const param = createParam('uint128', 'amount');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.type).toBe('bigint');
-      expect(field.validation.required).toBe(true);
-      // BigIntField component handles its own validation and UI guidance
-    });
-
-    it('should generate a bigint field for uint256', () => {
-      const param = createParam('uint256', 'value');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.type).toBe('bigint');
-      expect(field.validation.required).toBe(true);
-      // BigIntField component handles its own validation and UI guidance
-    });
-
-    it('should generate a bigint field for int128', () => {
-      const param = createParam('int128', 'delta');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.type).toBe('bigint');
-      expect(field.validation.required).toBe(true);
-      // BigIntField component handles its own validation and UI guidance
-    });
-
-    it('should generate a bigint field for int256', () => {
-      const param = createParam('int256', 'offset');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.type).toBe('bigint');
-      expect(field.validation.required).toBe(true);
-      // BigIntField component handles its own validation and UI guidance
-    });
-
-    it('should preserve parameter description in helper text', () => {
-      const param = createParam('uint256', 'tokenId', 'The unique identifier of the NFT');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.type).toBe('bigint');
-      expect(field.helperText).toBe('The unique identifier of the NFT');
-    });
-
-    it('should generate a blockchain-address field for address type', () => {
-      const param = createParam('address', 'recipient');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.type).toBe('blockchain-address');
-      expect(field.validation.required).toBe(true);
-      expect(field.validation.pattern).toBeUndefined();
-    });
-
-    it('should generate array field with proper element config for uint256[]', () => {
-      const param = createParam('uint256[]', 'amounts');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.type).toBe('array');
-      expect(field.elementFieldConfig).toBeDefined();
-      expect(field.elementFieldConfig?.type).toBe('bigint');
-      // Integer validation is handled by BigIntField component internally
-    });
-
-    it('should apply numeric bounds to array element fields', () => {
-      const param = createParam('uint32[]', 'counts');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.type).toBe('array');
-      expect(field.elementFieldConfig).toBeDefined();
-      expect(field.elementFieldConfig!.validation).toBeDefined();
-      expect(field.elementFieldConfig!.validation!.min).toBe(0);
-      expect(field.elementFieldConfig!.validation!.max).toBe(4_294_967_295);
-    });
-
-    it('should include proper field metadata', () => {
-      const param = createParam('uint256', 'value');
-      const field = generateEvmDefaultField(param);
-
-      expect(field.id).toBeDefined();
-      expect(field.name).toBe('value');
-      expect(field.label).toBe('Value');
-      expect(field.placeholder).toContain('value');
-      expect(field.width).toBe('full');
-    });
-  });
-});