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

package/src/configuration/network-services.ts

@@ -1,11 +1,52 @@
-import type { NetworkServiceForm } from '@openzeppelin/ui-types';
-import { UserExplorerConfig, UserRpcProviderConfig } from '@openzeppelin/ui-types';
+// Import from core package via barrel files
+import {
+  EvmProviderKeys,
+  resolveExplorerApiKeyFromAppConfig,
+  type TypedEvmNetworkConfig,
+} from '@openzeppelin/ui-builder-adapter-evm-core';
+import type { EvmNetworkConfig, NetworkServiceForm } from '@openzeppelin/ui-types';
 import { appConfigService, userNetworkServiceConfigService } from '@openzeppelin/ui-utils';
 
-import { TypedEvmNetworkConfig } from '../types';
-import { EvmProviderKeys, isEvmProviderKey } from '../types/providers';
-import { testEvmExplorerConnection, validateEvmExplorerConfig } from './explorer';
-import { testEvmRpcConnection, validateEvmRpcEndpoint } from './rpc';
+/**
+ * Returns the default service configuration values for a given service ID.
+ * Used for proactive health checks when no user overrides are configured.
+ *
+ * @param networkConfig The network configuration
+ * @param serviceId The service identifier (e.g., 'rpc', 'explorer', 'contract-definitions')
+ * @returns The default configuration values, or null if not available
+ */
+export function getEvmDefaultServiceConfig(
+  networkConfig: EvmNetworkConfig,
+  serviceId: string
+): Record<string, unknown> | null {
+  switch (serviceId) {
+    case 'rpc':
+      if (networkConfig.rpcUrl) {
+        return { rpcUrl: networkConfig.rpcUrl };
+      }
+      break;
+    case 'explorer': {
+      // For explorer service, we need to include the API key if available
+      // Use the shared helper from adapter-evm-core to resolve the API key
+      const typedConfig = networkConfig as TypedEvmNetworkConfig;
+      const apiKey = resolveExplorerApiKeyFromAppConfig(typedConfig);
+
+      // Return config if we have at least an explorer URL or an API key
+      if (networkConfig.explorerUrl || apiKey) {
+        return {
+          explorerUrl: networkConfig.explorerUrl,
+          apiUrl: networkConfig.apiUrl,
+          ...(apiKey ? { apiKey } : {}),
+        };
+      }
+      break;
+    }
+    case 'contract-definitions':
+      // No connection test for contract definitions service
+      return null;
+  }
+  return null;
+}
 
 /**
  * Returns the network service forms for EVM networks.
@@ -208,57 +249,3 @@ export function getEvmNetworkServiceForms(
     },
   ];
 }
-
-/**
- * Validates a network service configuration for EVM networks.
- */
-export async function validateEvmNetworkServiceConfig(
-  serviceId: string,
-  values: Record<string, unknown>
-): Promise<boolean> {
-  if (serviceId === 'rpc') {
-    const cfg = { url: String(values.rpcUrl || ''), isCustom: true } as UserRpcProviderConfig;
-    return validateEvmRpcEndpoint(cfg);
-  }
-  if (serviceId === 'explorer') {
-    const cfg = {
-      explorerUrl: values.explorerUrl ? String(values.explorerUrl) : undefined,
-      apiUrl: values.apiUrl ? String(values.apiUrl) : undefined,
-      apiKey: values.apiKey ? String(values.apiKey) : undefined,
-      isCustom: true,
-      applyToAllNetworks: Boolean(values.applyToAllNetworks),
-    } as UserExplorerConfig;
-    return validateEvmExplorerConfig(cfg);
-  }
-  if (serviceId === 'contract-definitions') {
-    const raw = values.defaultProvider;
-    if (raw === undefined || raw === null || raw === '') return true;
-    return isEvmProviderKey(raw);
-  }
-  return true;
-}
-
-/**
- * Tests a network service connection for EVM networks.
- */
-export async function testEvmNetworkServiceConnection(
-  serviceId: string,
-  values: Record<string, unknown>,
-  networkConfig: TypedEvmNetworkConfig
-): Promise<{ success: boolean; latency?: number; error?: string }> {
-  if (serviceId === 'rpc') {
-    const cfg = { url: String(values.rpcUrl || ''), isCustom: true } as UserRpcProviderConfig;
-    return testEvmRpcConnection(cfg);
-  }
-  if (serviceId === 'explorer') {
-    const cfg = {
-      explorerUrl: values.explorerUrl ? String(values.explorerUrl) : undefined,
-      apiUrl: values.apiUrl ? String(values.apiUrl) : undefined,
-      apiKey: values.apiKey ? String(values.apiKey) : undefined,
-      isCustom: true,
-      applyToAllNetworks: Boolean(values.applyToAllNetworks),
-    } as UserExplorerConfig;
-    return testEvmExplorerConnection(cfg, networkConfig);
-  }
-  return { success: true };
-}

package/src/index.ts

@@ -1,12 +1,17 @@
 // Re-export the main adapter class
 export { EvmAdapter } from './adapter';
 
-// Export RainbowKit customization types
-export * from './wallet/rainbowkit/types';
-
-// Optionally re-export types if they need to be accessible directly
-// export * from './types';
+// Export RainbowKit customization types (re-exported from core via rainbowkit/index.ts)
+export type {
+  AppInfo,
+  RainbowKitConnectButtonProps,
+  RainbowKitProviderProps,
+  RainbowKitKitConfig,
+  RainbowKitCustomizations,
+} from './wallet/rainbowkit';
+export { isRainbowKitCustomizations, extractRainbowKitCustomizations } from './wallet/rainbowkit';
 
+// Export EVM networks
 export {
   evmNetworks,
   evmMainnetNetworks,
@@ -40,12 +45,16 @@ export {
 // Export adapter configuration
 export { evmAdapterConfig } from './config';
 
-export type { TypedEvmNetworkConfig, WriteContractParameters } from './types';
-export type { EvmRelayerTransactionOptions } from './transaction/relayer';
-
-// Re-export adapter-specific types
-export type { EvmContractArtifacts } from './types/artifacts';
-export { isEvmContractArtifacts } from './types/artifacts';
+// Re-export core types for public API compatibility
+export type {
+  TypedEvmNetworkConfig,
+  WriteContractParameters,
+  EvmContractArtifacts,
+} from '@openzeppelin/ui-builder-adapter-evm-core';
+export {
+  isEvmContractArtifacts,
+  abiComparisonService,
+} from '@openzeppelin/ui-builder-adapter-evm-core';
 
-// Export abi module for comparison functionality
-export { abiComparisonService } from './abi';
+// Export adapter-specific types
+export type { EvmRelayerTransactionOptions } from '@openzeppelin/ui-builder-adapter-evm-core';

package/src/networks/index.ts

@@ -1,4 +1,5 @@
-import { TypedEvmNetworkConfig } from '../types';
+import type { TypedEvmNetworkConfig } from '@openzeppelin/ui-builder-adapter-evm-core';
+
 import {
   arbitrumMainnet,
   avalancheMainnet,

package/src/networks/mainnet.ts

@@ -24,7 +24,7 @@ import {
   zksync as viemZkSync,
 } from 'viem/chains';
 
-import { TypedEvmNetworkConfig } from '../types';
+import type { TypedEvmNetworkConfig } from '@openzeppelin/ui-builder-adapter-evm-core';
 
 export const ethereumMainnet: TypedEvmNetworkConfig = {
   id: 'ethereum-mainnet',

package/src/networks/testnet.ts

@@ -26,7 +26,7 @@ import {
   zksyncSepoliaTestnet as viemZkSyncSepoliaTestnet,
 } from 'viem/chains';
 
-import { TypedEvmNetworkConfig } from '../types';
+import type { TypedEvmNetworkConfig } from '@openzeppelin/ui-builder-adapter-evm-core';
 
 export const ethereumSepolia: TypedEvmNetworkConfig = {
   id: 'ethereum-sepolia',

package/src/query/adapter-query.ts

@@ -0,0 +1,72 @@
+/**
+ * Adapter-specific query wrapper
+ *
+ * Wraps the core queryEvmViewFunction with adapter-specific functionality:
+ * - Resolves RPC URL from network config (with user override support)
+ * - Supports loading contract schema for proxy implementations
+ */
+import {
+  queryEvmViewFunction as coreQueryEvmViewFunction,
+  resolveRpcUrl,
+  type TypedEvmNetworkConfig,
+  type WagmiWalletImplementation,
+} from '@openzeppelin/ui-builder-adapter-evm-core';
+import type { ContractSchema } from '@openzeppelin/ui-types';
+import { logger } from '@openzeppelin/ui-utils';
+
+/**
+ * Query a view function on an EVM contract.
+ *
+ * This adapter-specific version wraps the core queryEvmViewFunction to:
+ * 1. Resolve the RPC URL from network config (supporting user overrides)
+ * 2. Support optional wallet implementation for RPC context
+ * 3. Support loading proxy implementation schemas via callback
+ *
+ * @param contractAddress The contract address to query
+ * @param functionId The function ID to call
+ * @param networkConfig The network configuration
+ * @param params The parameters for the function call
+ * @param contractSchema Optional contract schema (if not provided, will use loadContractCallback)
+ * @param _walletImplementation Optional wallet implementation (reserved for future use)
+ * @param loadContractCallback Optional callback to load contract schema when not provided
+ * @returns The result of the view function call
+ */
+export async function queryEvmViewFunction(
+  contractAddress: string,
+  functionId: string,
+  networkConfig: TypedEvmNetworkConfig,
+  params: unknown[] = [],
+  contractSchema?: ContractSchema,
+  _walletImplementation?: WagmiWalletImplementation,
+  loadContractCallback?: (address: string) => Promise<ContractSchema>
+): Promise<unknown> {
+  // Use provided schema or fall back to loading via callback
+  let schema = contractSchema;
+  if (!schema) {
+    if (loadContractCallback) {
+      logger.debug('adapter-query', `Loading contract schema for ${contractAddress} via callback`);
+      schema = await loadContractCallback(contractAddress);
+    } else {
+      throw new Error(
+        'Contract schema is required for view function query. ' +
+          'Provide either a contractSchema or a loadContractCallback.'
+      );
+    }
+  }
+
+  // Resolve RPC URL from network config (supports user overrides)
+  // Note: resolveRpcUrl throws if no valid URL can be resolved
+  const rpcUrl = resolveRpcUrl(networkConfig);
+
+  logger.debug('adapter-query', `Using RPC URL for query: ${rpcUrl}`);
+
+  // Call core function with resolved RPC URL
+  return coreQueryEvmViewFunction(
+    contractAddress,
+    functionId,
+    params,
+    schema,
+    rpcUrl,
+    networkConfig
+  );
+}

package/src/query/index.ts

@@ -1,3 +1,3 @@
 // Barrel file for query module
-export * from './view-checker';
-export * from './handler';
+// Adapter-specific wrapper only - core query functionality (isEvmViewFunction) available from @openzeppelin/ui-builder-adapter-evm-core
+export { queryEvmViewFunction } from './adapter-query';

package/src/transaction/components/useEvmRelayerOptions.ts

@@ -2,9 +2,11 @@ import { useEffect, useRef } from 'react';
 import { useForm } from 'react-hook-form';
 
 import { Speed } from '@openzeppelin/relayer-sdk';
-
-import { gweiToWei, weiToGwei } from '../../utils';
-import type { EvmRelayerTransactionOptions } from '../relayer';
+import {
+  gweiToWei,
+  weiToGwei,
+  type EvmRelayerTransactionOptions,
+} from '@openzeppelin/ui-builder-adapter-evm-core';
 
 export interface EvmRelayerFormData {
   transactionOptions: EvmRelayerTransactionOptions & {

package/src/transaction/index.ts

@@ -1,7 +1,3 @@
 // Barrel file for transaction module
-export * from './execution-strategy';
-export * from './relayer';
-export * from './sender';
-export * from './formatter';
-export * from './eoa';
+// Adapter-specific UI components only - core transaction functionality available from @openzeppelin/ui-builder-adapter-evm-core
 export { EvmRelayerOptions } from './components/EvmRelayerOptions';

package/src/types/artifacts.ts

@@ -1,33 +1,8 @@
 /**
  * EVM-specific contract artifacts interface
- * Defines the structure of data needed to load EVM contracts
+ * Re-exports from core package for internal consumption
  */
-import type { EvmContractDefinitionProviderKey } from './providers';
-
-export interface EvmContractArtifacts {
-  /** The deployed contract address (required) */
-  contractAddress: string;
-
-  /** Optional manual ABI JSON string (for unverified contracts) */
-  contractDefinition?: string;
-
-  /** Optional proxy detection configuration */
-  __proxyDetectionOptions?: {
-    /** Skip automatic proxy detection */
-    skipProxyDetection?: boolean;
-  };
-
-  /** Optional forced provider for this load attempt (session-scoped override) */
-  __forcedProvider?: EvmContractDefinitionProviderKey;
-}
-
-/**
- * Type guard to check if an object matches EvmContractArtifacts structure
- */
-export function isEvmContractArtifacts(obj: unknown): obj is EvmContractArtifacts {
-  return (
-    typeof obj === 'object' &&
-    obj !== null &&
-    typeof (obj as Record<string, unknown>).contractAddress === 'string'
-  );
-}
+export {
+  type EvmContractArtifacts,
+  isEvmContractArtifacts,
+} from '@openzeppelin/ui-builder-adapter-evm-core';

package/src/types/providers.ts

@@ -1,21 +1,10 @@
 /**
  * EVM Contract Definition Provider keys and ordering
- * Avoid magic strings by using typed constants and a union type.
+ * Re-exports from core package for internal consumption
  */
-
-export const EvmProviderKeys = {
-  Etherscan: 'etherscan',
-  Sourcify: 'sourcify',
-} as const;
-
-export type EvmContractDefinitionProviderKey =
-  (typeof EvmProviderKeys)[keyof typeof EvmProviderKeys];
-
-export const EVM_PROVIDER_ORDER_DEFAULT: readonly EvmContractDefinitionProviderKey[] = [
-  EvmProviderKeys.Etherscan,
-  EvmProviderKeys.Sourcify,
-] as const;
-
-export function isEvmProviderKey(value: unknown): value is EvmContractDefinitionProviderKey {
-  return value === EvmProviderKeys.Etherscan || value === EvmProviderKeys.Sourcify;
-}
+export {
+  EvmProviderKeys,
+  type EvmContractDefinitionProviderKey,
+  EVM_PROVIDER_ORDER_DEFAULT,
+  isEvmProviderKey,
+} from '@openzeppelin/ui-builder-adapter-evm-core';

package/src/wallet/components/EvmWalletUiRoot.tsx

@@ -4,10 +4,10 @@ import { mainnet } from 'viem/chains';
 import { WagmiProvider } from 'wagmi';
 import React, { useEffect, useMemo, useState } from 'react';
 
+import { WagmiProviderInitializedContext } from '@openzeppelin/ui-builder-adapter-evm-core';
 import type { EcosystemReactUiProviderProps } from '@openzeppelin/ui-types';
 import { logger } from '@openzeppelin/ui-utils';
 
-import { WagmiProviderInitializedContext } from '../context/wagmi-context';
 import { evmUiKitManager, type EvmUiKitManagerState } from '../evmUiKitManager';
 import type { RainbowKitKitConfig, RainbowKitProviderProps } from '../rainbowkit';
 

package/src/wallet/evmUiKitManager.ts

@@ -1,132 +1,29 @@
-import type { Config as WagmiConfig } from '@wagmi/core';
-import type React from 'react';
-
-import type { UiKitConfiguration } from '@openzeppelin/ui-types';
-import { logger } from '@openzeppelin/ui-utils';
+/**
+ * EVM UI Kit Manager
+ *
+ * Manages UI kit configuration for EVM networks using the shared factory from adapter-evm-core.
+ */
+
+import {
+  createUiKitManager,
+  ensureRainbowKitAssetsLoaded,
+  type UiKitManagerState,
+} from '@openzeppelin/ui-builder-adapter-evm-core';
 
 import { getEvmWalletImplementation } from './utils/walletImplementationManager';
 
-export interface EvmUiKitManagerState {
-  currentFullUiKitConfig: UiKitConfiguration | null;
-  wagmiConfig: WagmiConfig | null;
-  kitProviderComponent: React.ComponentType<React.PropsWithChildren<unknown>> | null;
-  isKitAssetsLoaded: boolean;
-  isInitializing: boolean;
-  error: Error | null;
-}
-
-const initialState: EvmUiKitManagerState = {
-  currentFullUiKitConfig: null,
-  wagmiConfig: null,
-  kitProviderComponent: null,
-  isKitAssetsLoaded: false,
-  isInitializing: false,
-  error: null,
-};
-
-let state: EvmUiKitManagerState = { ...initialState };
-const listeners: Set<() => void> = new Set();
-
-function notifyListeners(): void {
-  listeners.forEach((listener) => {
-    try {
-      listener();
-    } catch (error) {
-      logger.error('EvmUiKitManager', 'Error in listener:', error);
-    }
-  });
-}
-
-function subscribe(listener: () => void): () => void {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-}
-
-function getState(): EvmUiKitManagerState {
-  return { ...state }; // Return a copy to prevent direct mutation
-}
-
-async function configure(newFullUiKitConfig: UiKitConfiguration): Promise<void> {
-  logger.info('EvmUiKitManager:configure', 'Configuring UI kit. New config:', newFullUiKitConfig);
-
-  const oldKitName = state.currentFullUiKitConfig?.kitName;
-  const newKitName = newFullUiKitConfig.kitName;
-  const kitChanged = oldKitName !== newKitName;
-
-  state = {
-    ...state,
-    isInitializing: true,
-    error: null,
-    currentFullUiKitConfig: newFullUiKitConfig,
-    kitProviderComponent: kitChanged ? null : state.kitProviderComponent,
-    isKitAssetsLoaded: kitChanged ? false : state.isKitAssetsLoaded,
-  };
-  notifyListeners();
-
-  let newWagmiConfigAttempt: WagmiConfig | null = null;
-  const evmImpl = await getEvmWalletImplementation();
-  try {
-    if (newKitName === 'rainbowkit') {
-      if (kitChanged || !state.kitProviderComponent || !state.isKitAssetsLoaded) {
-        logger.info('EvmUiKitManager:configure', 'Ensuring RainbowKit assets are loaded...');
-        const { ensureRainbowKitAssetsLoaded } = await import(
-          './rainbowkit/rainbowkitAssetManager'
-        );
-        const rkAssets = await ensureRainbowKitAssetsLoaded();
-        state.kitProviderComponent = rkAssets.ProviderComponent;
-        state.isKitAssetsLoaded = rkAssets.cssLoaded && !!rkAssets.ProviderComponent;
-        if (!state.isKitAssetsLoaded) {
-          throw new Error('Failed to load critical RainbowKit assets.');
-        }
-      }
-      newWagmiConfigAttempt = await evmImpl.getConfigForRainbowKit(newFullUiKitConfig);
-      logger.info('EvmUiKitManager:configure', 'WagmiConfig for RainbowKit obtained.');
-    } else if (newKitName === 'custom' || !newKitName) {
-      newWagmiConfigAttempt = await evmImpl.getActiveConfigForManager(newFullUiKitConfig);
-      logger.info('EvmUiKitManager:configure', 'ActiveConfig for custom/default obtained.');
-      if (kitChanged) {
-        state.kitProviderComponent = null;
-        state.isKitAssetsLoaded = false;
-      }
-    } else {
-      logger.warn('EvmUiKitManager:configure', `Unsupported kitName: ${newKitName}.`);
-      state.kitProviderComponent = null;
-      state.isKitAssetsLoaded = false;
-    }
-
-    state.wagmiConfig = newWagmiConfigAttempt;
-    evmImpl.setActiveWagmiConfig(state.wagmiConfig);
-    state.error = null;
-    if (!newWagmiConfigAttempt && newKitName && newKitName !== 'none' && newKitName !== 'custom') {
-      state.error = new Error(`Failed to obtain WagmiConfig for ${newKitName}`);
-      logger.error('EvmUiKitManager:configure', state.error.message);
-    }
-  } catch (err) {
-    logger.error('EvmUiKitManager:configure', 'Error during UI kit configuration process:', err);
-    state.error = err instanceof Error ? err : new Error(String(err));
-    state.wagmiConfig = null;
-    evmImpl.setActiveWagmiConfig(null);
-  } finally {
-    state.isInitializing = false;
-    logger.info(
-      'EvmUiKitManager:configure',
-      'Configuration attempt finished. Final wagmiConfig:',
-      state.wagmiConfig ? 'Set' : 'Null',
-      'Kit Provider Component:',
-      state.kitProviderComponent ? 'Set' : 'Null',
-      'Kit Assets Loaded:',
-      state.isKitAssetsLoaded,
-      'Error state:',
-      state.error ? state.error.message : 'None'
-    );
-    notifyListeners();
-  }
-}
-
-export const evmUiKitManager = {
-  getState,
-  subscribe,
-  configure,
-};
+/**
+ * State interface for EVM UI Kit Manager.
+ * This is a type alias to the shared UiKitManagerState for backwards compatibility.
+ */
+export type EvmUiKitManagerState = UiKitManagerState;
+
+/**
+ * EVM UI Kit Manager instance.
+ * Provides state management for UI kit configuration in EVM adapters.
+ */
+export const evmUiKitManager = createUiKitManager({
+  getWalletImplementation: getEvmWalletImplementation,
+  loadRainbowKitAssets: ensureRainbowKitAssetsLoaded,
+  logPrefix: 'EvmUiKitManager',
+});

package/src/wallet/hooks/index.ts

@@ -1,3 +1,2 @@
 export * from './facade-hooks';
-export * from './useIsWagmiProviderInitialized';
 export * from './useUiKitConfig';