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

package/src/abi/transformer.ts

@@ -1,163 +0,0 @@
-import type { AbiFunction, AbiParameter, AbiStateMutability } from 'viem';
-
-import type { ContractFunction, ContractSchema, FunctionParameter } from '@openzeppelin/ui-types';
-import { logger } from '@openzeppelin/ui-utils';
-
-import type { AbiItem } from '../types';
-import { formatInputName, formatMethodName } from '../utils';
-
-/**
- * Transforms a standard ABI array (typically from an EVM-compatible chain)
- * into the project's internal `ContractSchema` format.
- * This schema is used by the builder app and renderer to represent contract interactions
- * in a chain-agnostic way (though this specific transformer is for EVM ABIs).
- *
- * @param abi The raw ABI array (e.g., parsed from a JSON ABI file or fetched from Etherscan).
- *            It's expected to be an array of `AbiItem` (from viem types or a compatible structure).
- * @param contractName A name to assign to the contract within the schema. This might be derived
- *                     from a file name, user input, or a default if not otherwise available.
- * @param address Optional address of the deployed contract. If provided, it's included in the schema.
- * @returns A `ContractSchema` object representing the contract's interface.
- */
-export function transformAbiToSchema(
-  abi: readonly AbiItem[],
-  contractName: string,
-  address?: string
-): ContractSchema {
-  logger.info('transformAbiToSchema', `Transforming ABI to ContractSchema for: ${contractName}`);
-  const functions: ContractFunction[] = [];
-
-  for (const item of abi) {
-    // We are only interested in 'function' type items from the ABI
-    // to map them to our ContractFunction interface.
-    if (item.type === 'function') {
-      // After confirming item.type is 'function', we can safely cast it to AbiFunction
-      // to access function-specific properties like `stateMutability`, `inputs`, `outputs`.
-      const abiFunctionItem = item as AbiFunction;
-      functions.push({
-        // Generate a unique ID for the function within the schema.
-        // This often combines name and input types to handle overloads.
-        id: `${abiFunctionItem.name}_${abiFunctionItem.inputs?.map((i) => i.type).join('_') || ''}`,
-        name: abiFunctionItem.name || '', // Fallback for unnamed functions (though rare).
-        displayName: formatMethodName(abiFunctionItem.name || ''), // Create a more readable name for UI.
-        // Recursively map ABI inputs and outputs to our FunctionParameter structure.
-        // This ensures that any non-standard properties (like 'internalType') are stripped.
-        inputs: mapAbiParametersToSchemaParameters(abiFunctionItem.inputs),
-        outputs: mapAbiParametersToSchemaParameters(abiFunctionItem.outputs),
-        type: 'function', // Explicitly set, as we filtered for this type.
-        stateMutability: abiFunctionItem.stateMutability, // Preserve EVM-specific state mutability.
-        // Determine if the function modifies blockchain state based on its `stateMutability`.
-        // This is a crucial piece of information for the UI (e.g., to differentiate read vs. write calls).
-        modifiesState:
-          !abiFunctionItem.stateMutability || // If undefined, assume it modifies state (safer default)
-          !['view', 'pure'].includes(abiFunctionItem.stateMutability),
-      });
-    }
-  }
-
-  const contractSchema: ContractSchema = {
-    ecosystem: 'evm', // This transformer is specific to EVM.
-    name: contractName,
-    address,
-    functions,
-  };
-  logger.info(
-    'transformAbiToSchema',
-    `Transformation complete. Found ${contractSchema.functions.length} functions.`
-  );
-  return contractSchema;
-}
-
-/**
- * Recursively maps an array of ABI parameters (from viem's `AbiParameter` type or compatible)
- * to an array of `FunctionParameter` objects, which is our internal representation.
- * This function is crucial for stripping any properties not defined in `FunctionParameter`
- * (e.g., `internalType` from the raw ABI) and for handling nested components (structs/tuples).
- *
- * @param abiParams An array of ABI parameter objects. Can be undefined (e.g., if a function has no inputs/outputs).
- * @returns An array of `FunctionParameter` objects, or an empty array if `abiParams` is undefined.
- */
-function mapAbiParametersToSchemaParameters(
-  abiParams: readonly AbiParameter[] | undefined
-): FunctionParameter[] {
-  if (!abiParams) {
-    return [];
-  }
-  return abiParams.map((param): FunctionParameter => {
-    // Create the base FunctionParameter object, picking only defined properties.
-    const schemaParam: FunctionParameter = {
-      name: param.name || '', // Ensure name is a string, fallback if undefined in ABI.
-      type: param.type, // The raw type string from the ABI (e.g., 'uint256', 'address', 'tuple').
-      displayName: formatInputName(param.name || '', param.type), // Generate a user-friendly name.
-      // `description` is not a standard part of an ABI parameter, so it's not mapped here.
-      // It can be added later by the user in the builder app UI.
-    };
-    // Check for nested components (structs/tuples).
-    // `param.type.startsWith('tuple')` checks if it's a tuple or tuple array.
-    // `'components' in param` is a type guard for discriminated unions.
-    // `param.components && param.components.length > 0` ensures components exist and are not empty.
-    if (
-      param.type.startsWith('tuple') &&
-      'components' in param && // Type guard for discriminated union (AbiParameter)
-      param.components &&
-      param.components.length > 0
-    ) {
-      // If components exist, recursively call this function to map them.
-      // This ensures that nested structures also conform to `FunctionParameter` and strip extra fields.
-      // Cast `param.components` because TypeScript might not fully infer its type after the `in` check within the map.
-      schemaParam.components = mapAbiParametersToSchemaParameters(
-        param.components as readonly AbiParameter[]
-      );
-    }
-    return schemaParam;
-  });
-}
-
-/**
- * Helper function to convert one of our internal `FunctionParameter` objects
- * back into a format compatible with viem's `AbiParameter` type.
- * This is primarily used by `createAbiFunctionItem` when constructing an `AbiFunction`
- * for interactions with viem or other ABI-consuming libraries.
- * It ensures that only properties expected by `AbiParameter` are included.
- *
- * @param param The internal `FunctionParameter` object.
- * @returns An `AbiParameter` object compatible with viem.
- */
-function mapSchemaParameterToAbiParameter(param: FunctionParameter): AbiParameter {
-  // Handle tuple types specifically, as `AbiParameter` for tuples requires a `components` array.
-  if (param.type.startsWith('tuple') && param.components && param.components.length > 0) {
-    return {
-      name: param.name || undefined, // ABI parameter names can be undefined (e.g., for return values).
-      type: param.type as `tuple${string}`, // Cast to satisfy viem's specific tuple type string.
-      // Recursively map nested components back to AbiParameter format.
-      components: param.components.map(mapSchemaParameterToAbiParameter),
-    };
-  }
-  // For non-tuple types, return a simpler AbiParameter structure.
-  return {
-    name: param.name || undefined,
-    type: param.type,
-    // `internalType` is not part of our `FunctionParameter` model, so it's not added back here.
-    // Other ABI-specific fields like `indexed` (for events) are also not relevant here as
-    // this function is focused on function parameters for `AbiFunction`.
-  };
-}
-
-/**
- * Private helper to convert internal `ContractFunction` details (our model)
- * back into a viem `AbiFunction` object.
- * This is useful when interacting with libraries like viem that expect a standard ABI format.
- * Ensures that the generated AbiFunction conforms to viem's type definitions.
- *
- * @param functionDetails The `ContractFunction` object from our internal schema.
- * @returns An `AbiFunction` object.
- */
-export function createAbiFunctionItem(functionDetails: ContractFunction): AbiFunction {
-  return {
-    name: functionDetails.name,
-    type: 'function',
-    inputs: functionDetails.inputs.map(mapSchemaParameterToAbiParameter),
-    outputs: functionDetails.outputs?.map(mapSchemaParameterToAbiParameter) || [],
-    stateMutability: (functionDetails.stateMutability ?? 'view') as AbiStateMutability,
-  };
-}

package/src/abi/types.ts

@@ -1,101 +0,0 @@
-/**
- * EVM-specific ABI types for comparison and validation
- * Uses viem's Abi type as the foundation for type safety
- */
-
-import type { Abi } from 'viem';
-
-/**
- * Result of comparing two ABIs
- */
-export interface AbiComparisonResult {
-  /** Whether the ABIs are identical after normalization */
-  identical: boolean;
-  /** List of differences found between the ABIs */
-  differences: AbiDifference[];
-  /** Overall severity of the changes */
-  severity: 'none' | 'minor' | 'major' | 'breaking';
-  /** Human-readable summary of the comparison */
-  summary: string;
-}
-
-/**
- * Represents a single difference between two ABIs
- */
-export interface AbiDifference {
-  /** Type of change */
-  type: 'added' | 'removed' | 'modified';
-  /** Which section of the ABI was affected */
-  section: 'function' | 'event' | 'constructor' | 'error' | 'fallback' | 'receive';
-  /** Name of the affected item (or type if no name) */
-  name: string;
-  /** Detailed description of the change */
-  details: string;
-  /** Impact level of this change */
-  impact: 'low' | 'medium' | 'high';
-  /** Signature before the change (for removed/modified) */
-  oldSignature?: string;
-  /** Signature after the change (for added/modified) */
-  newSignature?: string;
-}
-
-/**
- * Result of validating an ABI structure
- */
-export interface AbiValidationResult {
-  /** Whether the ABI is structurally valid */
-  valid: boolean;
-  /** List of validation errors found */
-  errors: string[];
-  /** List of validation warnings */
-  warnings: string[];
-  /** Normalized ABI if validation passed */
-  normalizedAbi?: Abi;
-}
-
-/**
- * Type guard to check if a value is a valid ABI array
- */
-export function isValidAbiArray(value: unknown): value is Abi {
-  return Array.isArray(value) && value.every(isValidAbiItem);
-}
-
-/**
- * Type guard to check if a value is a valid ABI item
- */
-export function isValidAbiItem(item: unknown): boolean {
-  if (typeof item !== 'object' || item === null) {
-    return false;
-  }
-
-  const abiItem = item as Record<string, unknown>;
-
-  // Must have a valid type
-  if (typeof abiItem.type !== 'string') {
-    return false;
-  }
-
-  const validTypes = ['function', 'event', 'constructor', 'error', 'fallback', 'receive'];
-  if (!validTypes.includes(abiItem.type)) {
-    return false;
-  }
-
-  // Functions and events must have a name
-  if (
-    (abiItem.type === 'function' || abiItem.type === 'event') &&
-    typeof abiItem.name !== 'string'
-  ) {
-    return false;
-  }
-
-  // Functions, events, and constructors should have inputs array
-  if (
-    (abiItem.type === 'function' || abiItem.type === 'event' || abiItem.type === 'constructor') &&
-    abiItem.inputs !== undefined &&
-    !Array.isArray(abiItem.inputs)
-  ) {
-    return false;
-  }
-
-  return true;
-}

package/src/configuration/__tests__/explorer.test.ts

@@ -1,174 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { EvmNetworkConfig, UserExplorerConfig } from '@openzeppelin/ui-types';
-
-import { testEvmExplorerConnection, validateEvmExplorerConfig } from '../../configuration/explorer';
-
-describe('validateEvmExplorerConfig', () => {
-  it('should return true for valid configuration with all fields', () => {
-    const config: UserExplorerConfig = {
-      explorerUrl: 'https://etherscan.io',
-      apiUrl: 'https://api.etherscan.io/api',
-      apiKey: 'valid-key',
-      name: 'Test',
-      isCustom: true,
-    };
-    expect(validateEvmExplorerConfig(config)).toBe(true);
-  });
-
-  it('should return false for invalid explorerUrl', () => {
-    const config: UserExplorerConfig = {
-      explorerUrl: 'invalid-url',
-      apiKey: 'valid-key',
-      isCustom: true,
-    };
-    expect(validateEvmExplorerConfig(config)).toBe(false);
-  });
-
-  it('should return false for invalid apiUrl', () => {
-    const config: UserExplorerConfig = {
-      apiUrl: 'invalid-url',
-      apiKey: 'valid-key',
-      isCustom: true,
-    };
-    expect(validateEvmExplorerConfig(config)).toBe(false);
-  });
-
-  it('should return false for empty apiKey', () => {
-    const config: UserExplorerConfig = {
-      apiKey: '',
-      isCustom: true,
-    };
-    expect(validateEvmExplorerConfig(config)).toBe(false);
-  });
-
-  it('should return true for configuration without optional fields', () => {
-    const config: UserExplorerConfig = {
-      apiKey: 'valid-key',
-      isCustom: true,
-    };
-    expect(validateEvmExplorerConfig(config)).toBe(true);
-  });
-});
-
-describe('testEvmExplorerConnection', () => {
-  const mockFetch = vi.fn();
-
-  beforeEach(() => {
-    vi.stubGlobal('fetch', mockFetch);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('should fail without apiKey', async () => {
-    const config: UserExplorerConfig = {
-      apiUrl: 'https://api.etherscan.io/api',
-      isCustom: true,
-    };
-    const result = await testEvmExplorerConnection(config);
-    expect(result.success).toBe(false);
-    expect(result.error).toBe('API key is required for testing connection to this explorer');
-  });
-
-  it('should fail without apiUrl and no networkConfig', async () => {
-    const config: UserExplorerConfig = {
-      apiKey: 'test-key',
-      isCustom: true,
-    };
-    const result = await testEvmExplorerConnection(config);
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('API URL is required');
-  });
-
-  it('should use networkConfig apiUrl if not provided', async () => {
-    const config: UserExplorerConfig = {
-      apiKey: 'test-key',
-      isCustom: true,
-    };
-    const networkConfig: EvmNetworkConfig = {
-      id: 'test',
-      name: 'Test',
-      network: 'test',
-      type: 'testnet',
-      isTestnet: true,
-      apiUrl: 'https://api.etherscan.io/api',
-    } as EvmNetworkConfig;
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({ status: '1', result: '123' }),
-    });
-
-    const result = await testEvmExplorerConnection(config, networkConfig);
-    expect(result.success).toBe(true);
-    expect(result.latency).toBeDefined();
-  });
-
-  it('should succeed with valid response', async () => {
-    const config: UserExplorerConfig = {
-      apiUrl: 'https://api.etherscan.io/api',
-      apiKey: 'test-key',
-      isCustom: true,
-    };
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({ status: '1', result: '123' }),
-    });
-
-    const result = await testEvmExplorerConnection(config);
-    expect(result.success).toBe(true);
-    expect(result.latency).toBeDefined();
-  });
-
-  it('should fail on HTTP error', async () => {
-    const config: UserExplorerConfig = {
-      apiUrl: 'https://api.etherscan.io/api',
-      apiKey: 'test-key',
-      isCustom: true,
-    };
-
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 403,
-      statusText: 'Forbidden',
-    });
-
-    const result = await testEvmExplorerConnection(config);
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('HTTP 403');
-  });
-
-  it('should fail on API error in response', async () => {
-    const config: UserExplorerConfig = {
-      apiUrl: 'https://api.etherscan.io/api',
-      apiKey: 'invalid-key',
-      isCustom: true,
-    };
-
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({ status: '0', message: 'Invalid API Key' }),
-    });
-
-    const result = await testEvmExplorerConnection(config);
-    expect(result.success).toBe(false);
-    expect(result.error).toBe('Invalid API Key');
-  });
-
-  it('should handle fetch errors', async () => {
-    const config: UserExplorerConfig = {
-      apiUrl: 'https://api.etherscan.io/api',
-      apiKey: 'test-key',
-      isCustom: true,
-    };
-
-    mockFetch.mockRejectedValueOnce(new Error('Network error'));
-
-    const result = await testEvmExplorerConnection(config);
-    expect(result.success).toBe(false);
-    expect(result.error).toBe('Network error');
-  });
-});

package/src/configuration/__tests__/rpc.test.ts

@@ -1,176 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import type { EvmNetworkConfig } from '@openzeppelin/ui-types';
-import { appConfigService } from '@openzeppelin/ui-utils';
-
-import { resolveRpcUrl } from '../rpc';
-
-// Adjust path as needed
-
-// Helper to create a mock EvmNetworkConfig
-const createMockConfig = (id: string, rpcUrl?: string, name?: string): EvmNetworkConfig => ({
-  id,
-  name: name || `Test ${id}`,
-  ecosystem: 'evm',
-  network: 'test-network',
-  type: 'testnet',
-  isTestnet: true,
-  exportConstName: id.replace(/-/g, ''),
-  chainId: 12345, // Arbitrary chainId for testing
-  rpcUrl: rpcUrl || '', // Allow undefined or empty for testing error cases
-  nativeCurrency: { name: 'TestETH', symbol: 'TETH', decimals: 18 },
-  primaryExplorerApiIdentifier: `${id}-explorer`,
-  apiUrl: `https://api.${id}.com`,
-});
-
-// Mock the appConfigService from the correct package
-vi.mock('@openzeppelin/ui-utils', async (importOriginal) => {
-  const original = await importOriginal<typeof import('@openzeppelin/ui-utils')>(); // Ensure correct type for original
-  return {
-    ...original,
-    logger: {
-      // Provide mock implementations for all logger methods used or default them
-      debug: vi.fn(),
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-      // Add other methods if your code uses them, or a more generic mock
-    },
-    appConfigService: {
-      getRpcEndpointOverride: vi.fn(),
-      // Mock other methods of appConfigService if they were to be called by resolveRpcUrl or its dependencies
-      // For resolveRpcUrl, only getRpcEndpointOverride is directly relevant.
-      getConfig: vi.fn().mockReturnValue({ rpcEndpoints: {} }), // Provide a minimal getConfig mock
-    },
-  };
-});
-
-describe('resolveRpcUrl', () => {
-  beforeEach(() => {
-    // Reset mocks before each test to ensure test isolation
-    vi.mocked(appConfigService.getRpcEndpointOverride).mockReset();
-    // Reset getConfig mock if it needs to change per test, or set a default good enough for all
-    vi.mocked(appConfigService.getConfig).mockReturnValue({ rpcEndpoints: {} });
-  });
-
-  it('should use RPC override from AppConfigService if available (string)', () => {
-    const networkId = 'mainnet-test-override';
-    const overrideRpcUrl = 'https://appconfig-override.rpc.com';
-    vi.mocked(appConfigService.getRpcEndpointOverride).mockReturnValue(overrideRpcUrl);
-
-    const config = createMockConfig(networkId, 'https://default.rpc.com');
-    expect(resolveRpcUrl(config)).toBe(overrideRpcUrl);
-  });
-
-  it('should use RPC override from AppConfigService if available (object with http)', () => {
-    const networkId = 'mainnet-test-object-override';
-    const overrideRpcUrl = 'https://appconfig-object.rpc.com';
-    vi.mocked(appConfigService.getRpcEndpointOverride).mockReturnValue({ http: overrideRpcUrl });
-
-    const config = createMockConfig(networkId, 'https://default.rpc.com');
-    expect(resolveRpcUrl(config)).toBe(overrideRpcUrl);
-  });
-
-  it('should fall back to networkConfig.rpcUrl if no override is available', () => {
-    const networkId = 'mainnet-test-fallback';
-    const defaultRpcUrl = 'https://default-from-config.rpc.com';
-    vi.mocked(appConfigService.getRpcEndpointOverride).mockReturnValue(undefined);
-
-    const config = createMockConfig(networkId, defaultRpcUrl);
-    expect(resolveRpcUrl(config)).toBe(defaultRpcUrl);
-  });
-
-  it('should fall back to networkConfig.rpcUrl if override is invalid URL', () => {
-    const networkId = 'mainnet-test-invalid-override';
-    const defaultRpcUrl = 'https://default-valid.rpc.com';
-    vi.mocked(appConfigService.getRpcEndpointOverride).mockReturnValue('invalid-url');
-
-    const config = createMockConfig(networkId, defaultRpcUrl);
-    expect(resolveRpcUrl(config)).toBe(defaultRpcUrl);
-    // Optionally, check if logger.warn was called (requires logger mock setup)
-  });
-
-  it('should throw an error if no valid RPC URL (override or default) is found', () => {
-    const networkId = 'no-valid-rpc';
-    vi.mocked(appConfigService.getRpcEndpointOverride).mockReturnValue(undefined);
-    const config = createMockConfig(networkId, undefined); // No default RPC
-
-    expect(() => resolveRpcUrl(config)).toThrowError(
-      `No valid RPC URL configured for network Test ${networkId} (ID: ${networkId}).`
-    );
-  });
-
-  it('should throw an error if default RPC is invalid and no override is found', () => {
-    const networkId = 'invalid-default-rpc';
-    vi.mocked(appConfigService.getRpcEndpointOverride).mockReturnValue(undefined);
-    const config = createMockConfig(networkId, 'not-a-url');
-
-    expect(() => resolveRpcUrl(config)).toThrowError(
-      `No valid RPC URL configured for network Test ${networkId} (ID: ${networkId}).`
-    );
-  });
-
-  it('should use override even if default is invalid', () => {
-    const networkId = 'override-wins-over-invalid-default';
-    const overrideRpcUrl = 'https://good-override.rpc.com';
-    vi.mocked(appConfigService.getRpcEndpointOverride).mockReturnValue(overrideRpcUrl);
-
-    const config = createMockConfig(networkId, 'bad-default-url');
-    expect(resolveRpcUrl(config)).toBe(overrideRpcUrl);
-  });
-
-  // The following tests are no longer valid as resolveRpcUrl does not directly access env vars.
-  // Environment variable overrides are handled by AppConfigService.
-  /*
-  it('should use VITE_RPC_URL_<NETWORK_ID> if set', () => {
-    const networkId = 'ethereum-mainnet';
-    const envRpcUrl = 'https://env-override.rpc.com';
-    vi.stubEnv(`VITE_RPC_URL_ETHEREUM_MAINNET`, envRpcUrl);
-
-    const config = createMockConfig(networkId, 'https://config.rpc.com');
-    expect(resolveRpcUrl(config)).toBe(envRpcUrl);
-  });
-
-  it('should correctly format NETWORK_ID with hyphens for env var lookup', () => {
-    const networkId = 'some-test-network';
-    const envRpcUrl = 'https://hyphen-test.rpc.com';
-    vi.stubEnv(`VITE_RPC_URL_SOME_TEST_NETWORK`, envRpcUrl);
-
-    const config = createMockConfig(networkId, 'https://config.rpc.com');
-    expect(resolveRpcUrl(config)).toBe(envRpcUrl);
-  });
-
-  it('should use networkConfig.rpcUrl if no specific environment variable is set', () => {
-    const networkId = 'ethereum-sepolia';
-    const configRpcUrl = 'https://sepolia-public.rpc.com';
-    const config = createMockConfig(networkId, configRpcUrl);
-
-    // No need to delete, unstubAllEnvs handles cleanup
-    expect(resolveRpcUrl(config)).toBe(configRpcUrl);
-  });
-
-  it('should throw an error if rpcUrl is missing in config and no env var is set', () => {
-    const networkId = 'missing-rpc-config';
-    // Create a config where rpcUrl is explicitly undefined, cast to bypass type check for test
-    const config = {
-      ...createMockConfig(networkId, 'http://dummy.com'), // provide a dummy for base object creation
-      rpcUrl: undefined as unknown as string, // Then force undefined
-    };
-
-    expect(() => resolveRpcUrl(config)).toThrowError(
-      `Could not resolve RPC URL for network: ${config.name}. Please ensure networkConfig.rpcUrl is set or provide the VITE_RPC_URL_MISSING_RPC_CONFIG environment variable.`
-    );
-  });
-
-  it('should handle network IDs with different casings for env var lookup (e.g. all caps)', () => {
-    const networkIdInConfig = 'allcapsnet-lower'; // e.g., from a file
-    const networkIdForEnv = 'ALLCAPSNET_LOWER'; // The key format
-    const envRpcUrl = 'https://allcaps.rpc.com';
-    vi.stubEnv(`VITE_RPC_URL_${networkIdForEnv}`, envRpcUrl);
-
-    // networkConfig.id is used to derive the env var key, so it should match the intended lookup pattern
-    const config = createMockConfig(networkIdInConfig, 'https://config.rpc.com');
-    expect(resolveRpcUrl(config)).toBe(envRpcUrl);
-  });
-  */
-});