@openzeppelin/ui-builder-adapter-evm 0.13.0 → 0.14.0

package/dist/index.cjs

@@ -39,25 +39,25 @@ __export(rainbowkitAssetManager_exports, {
 });
 async function ensureRainbowKitAssetsLoaded() {
   if (loadedAssets) {
-    import_ui_builder_utils12.logger.debug("RainbowKitAssetManager", "Assets already loaded, returning cached.");
+    import_ui_builder_utils17.logger.debug("RainbowKitAssetManager", "Assets already loaded, returning cached.");
     return loadedAssets;
   }
   if (!providerPromise) {
     providerPromise = import("@rainbow-me/rainbowkit").then((module2) => {
       const component = module2.RainbowKitProvider;
-      import_ui_builder_utils12.logger.info("RainbowKitAssetManager", "RainbowKitProvider module loaded.");
+      import_ui_builder_utils17.logger.info("RainbowKitAssetManager", "RainbowKitProvider module loaded.");
       return component;
     }).catch((err) => {
-      import_ui_builder_utils12.logger.error("RainbowKitAssetManager", "Failed to load RainbowKitProvider module:", err);
+      import_ui_builder_utils17.logger.error("RainbowKitAssetManager", "Failed to load RainbowKitProvider module:", err);
       return null;
     });
   }
   if (!cssPromise) {
     cssPromise = import("@rainbow-me/rainbowkit/styles.css").then(() => {
-      import_ui_builder_utils12.logger.info("RainbowKitAssetManager", "RainbowKit CSS loaded successfully.");
+      import_ui_builder_utils17.logger.info("RainbowKitAssetManager", "RainbowKit CSS loaded successfully.");
       return true;
     }).catch((err) => {
-      import_ui_builder_utils12.logger.error("RainbowKitAssetManager", "Failed to load RainbowKit CSS:", err);
+      import_ui_builder_utils17.logger.error("RainbowKitAssetManager", "Failed to load RainbowKit CSS:", err);
       return false;
     });
   }
@@ -65,7 +65,7 @@ async function ensureRainbowKitAssetsLoaded() {
     const [ProviderComponent, cssLoadedSuccess] = await Promise.all([providerPromise, cssPromise]);
     loadedAssets = { ProviderComponent, cssLoaded: cssLoadedSuccess };
     if (!ProviderComponent || !cssLoadedSuccess) {
-      import_ui_builder_utils12.logger.warn(
+      import_ui_builder_utils17.logger.warn(
         "RainbowKitAssetManager",
         "One or more RainbowKit assets failed to load.",
         loadedAssets
@@ -73,16 +73,16 @@ async function ensureRainbowKitAssetsLoaded() {
     }
     return loadedAssets;
   } catch (error) {
-    import_ui_builder_utils12.logger.error("RainbowKitAssetManager", "Error in Promise.all for asset loading:", error);
+    import_ui_builder_utils17.logger.error("RainbowKitAssetManager", "Error in Promise.all for asset loading:", error);
     loadedAssets = { ProviderComponent: null, cssLoaded: false };
     return loadedAssets;
   }
 }
-var import_ui_builder_utils12, loadedAssets, providerPromise, cssPromise;
+var import_ui_builder_utils17, loadedAssets, providerPromise, cssPromise;
 var init_rainbowkitAssetManager = __esm({
   "src/wallet/rainbowkit/rainbowkitAssetManager.ts"() {
     "use strict";
-    import_ui_builder_utils12 = require("@openzeppelin/ui-builder-utils");
+    import_ui_builder_utils17 = require("@openzeppelin/ui-builder-utils");
     loadedAssets = null;
     providerPromise = null;
     cssPromise = null;
@@ -127,7 +127,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/adapter.ts
-var import_ui_builder_utils39 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils40 = require("@openzeppelin/ui-builder-utils");
 
 // src/abi/comparison.ts
 var import_ui_builder_utils = require("@openzeppelin/ui-builder-utils");
@@ -452,6 +452,9 @@ var AbiComparisonService = class {
 };
 var abiComparisonService = new AbiComparisonService();
 
+// src/configuration/network-services.ts
+var import_ui_builder_utils6 = require("@openzeppelin/ui-builder-utils");
+
 // src/types/providers.ts
 var EvmProviderKeys = {
   Etherscan: "etherscan",
@@ -465,211 +468,1035 @@ function isEvmProviderKey(value) {
   return value === EvmProviderKeys.Etherscan || value === EvmProviderKeys.Sourcify;
 }
 
-// src/wallet/components/EvmWalletUiRoot.tsx
-var import_react_query = require("@tanstack/react-query");
-var import_core3 = require("@wagmi/core");
-var import_chains3 = require("viem/chains");
-var import_wagmi = require("wagmi");
-var import_react9 = require("react");
-var import_ui_builder_utils14 = require("@openzeppelin/ui-builder-utils");
+// src/configuration/explorer.ts
+var import_ui_builder_utils4 = require("@openzeppelin/ui-builder-utils");
 
-// src/wallet/context/wagmi-context.tsx
-var import_react = require("react");
-var WagmiProviderInitializedContext = (0, import_react.createContext)(false);
+// src/abi/etherscan-v2.ts
+var import_ui_builder_utils3 = require("@openzeppelin/ui-builder-utils");
 
-// src/wallet/evmUiKitManager.ts
-var import_ui_builder_utils13 = require("@openzeppelin/ui-builder-utils");
+// src/abi/transformer.ts
+var import_ui_builder_utils2 = require("@openzeppelin/ui-builder-utils");
 
-// src/wallet/utils/walletImplementationManager.ts
-var import_ui_builder_utils11 = require("@openzeppelin/ui-builder-utils");
+// src/types/artifacts.ts
+function isEvmContractArtifacts(obj) {
+  return typeof obj === "object" && obj !== null && typeof obj.contractAddress === "string";
+}
 
-// src/wallet/implementation/wagmi-implementation.ts
-var import_connectors = require("@wagmi/connectors");
-var import_core2 = require("@wagmi/core");
+// src/utils/artifacts.ts
+function validateAndConvertEvmArtifacts(source) {
+  if (typeof source === "string") {
+    return { contractAddress: source };
+  }
+  if (!isEvmContractArtifacts(source)) {
+    throw new Error(
+      "Invalid contract artifacts provided. Expected an object with contractAddress property."
+    );
+  }
+  return source;
+}
+
+// src/utils/json.ts
+function stringifyWithBigInt(value, space) {
+  const replacer = (_key, val) => {
+    if (typeof val === "bigint") {
+      return val.toString();
+    }
+    return val;
+  };
+  return JSON.stringify(value, replacer, space);
+}
+
+// src/utils/formatting.ts
+function formatMethodName(name) {
+  if (!name) return "";
+  return name.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase()).trim();
+}
+function formatInputName(name, type) {
+  if (!name || name === "") {
+    return `Parameter (${type})`;
+  }
+  return name.replace(/([A-Z])/g, " $1").replace(/_/g, " ").replace(/^./, (str) => str.toUpperCase()).trim();
+}
+
+// src/utils/validation.ts
 var import_viem = require("viem");
-var import_ui_builder_utils10 = require("@openzeppelin/ui-builder-utils");
+function isValidEvmAddress(address) {
+  return (0, import_viem.isAddress)(address);
+}
 
-// src/networks/mainnet.ts
-var import_react2 = require("@web3icons/react");
-var import_chains = require("viem/chains");
-var ethereumMainnet = {
-  id: "ethereum-mainnet",
-  exportConstName: "ethereumMainnet",
-  name: "Ethereum",
-  ecosystem: "evm",
-  network: "ethereum",
-  type: "mainnet",
-  isTestnet: false,
-  chainId: 1,
-  rpcUrl: import_chains.mainnet.rpcUrls.default.http[0],
-  explorerUrl: "https://etherscan.io",
-  apiUrl: "https://api.etherscan.io/v2/api",
-  primaryExplorerApiIdentifier: "etherscan-v2",
-  supportsEtherscanV2: true,
-  iconComponent: import_react2.NetworkEthereum,
-  nativeCurrency: {
-    name: "Ether",
-    symbol: "ETH",
-    decimals: 18
-  },
-  viemChain: import_chains.mainnet
-};
-var arbitrumMainnet = {
-  id: "arbitrum-mainnet",
-  exportConstName: "arbitrumMainnet",
-  name: "Arbitrum One",
-  ecosystem: "evm",
-  network: "arbitrum",
-  type: "mainnet",
-  isTestnet: false,
-  chainId: 42161,
-  rpcUrl: import_chains.arbitrum.rpcUrls.default.http[0],
-  explorerUrl: "https://arbiscan.io",
-  apiUrl: "https://api.etherscan.io/v2/api",
-  primaryExplorerApiIdentifier: "etherscan-v2",
-  supportsEtherscanV2: true,
-  iconComponent: import_react2.NetworkArbitrumOne,
-  nativeCurrency: {
-    name: "Ether",
-    symbol: "ETH",
-    decimals: 18
-  },
-  viemChain: import_chains.arbitrum
-};
-var polygonMainnet = {
-  id: "polygon-mainnet",
-  exportConstName: "polygonMainnet",
-  name: "Polygon",
-  ecosystem: "evm",
-  network: "polygon",
-  type: "mainnet",
-  isTestnet: false,
-  chainId: 137,
-  rpcUrl: import_chains.polygon.rpcUrls.default.http[0],
-  explorerUrl: "https://polygonscan.com",
-  apiUrl: "https://api.etherscan.io/v2/api",
-  primaryExplorerApiIdentifier: "etherscan-v2",
-  supportsEtherscanV2: true,
-  iconComponent: import_react2.NetworkPolygon,
-  nativeCurrency: {
-    name: "MATIC",
-    symbol: "MATIC",
-    decimals: 18
-  },
-  viemChain: import_chains.polygon
-};
-var polygonZkEvmMainnet = {
-  id: "polygon-zkevm-mainnet",
-  exportConstName: "polygonZkEvmMainnet",
-  name: "Polygon zkEVM",
-  ecosystem: "evm",
-  network: "polygon-zkevm",
-  type: "mainnet",
-  isTestnet: false,
-  chainId: 1101,
-  rpcUrl: import_chains.polygonZkEvm.rpcUrls.default.http[0],
-  explorerUrl: "https://zkevm.polygonscan.com",
-  apiUrl: "https://api.etherscan.io/v2/api",
-  primaryExplorerApiIdentifier: "etherscan-v2",
-  supportsEtherscanV2: true,
-  iconComponent: import_react2.NetworkPolygon,
-  nativeCurrency: {
-    name: "Ether",
-    symbol: "ETH",
-    decimals: 18
-  },
-  viemChain: import_chains.polygonZkEvm
-};
-var baseMainnet = {
-  id: "base-mainnet",
-  exportConstName: "baseMainnet",
-  name: "Base",
-  ecosystem: "evm",
-  network: "base",
-  type: "mainnet",
-  isTestnet: false,
-  chainId: 8453,
-  rpcUrl: import_chains.base.rpcUrls.default.http[0],
-  explorerUrl: "https://basescan.org",
-  apiUrl: "https://api.etherscan.io/v2/api",
-  primaryExplorerApiIdentifier: "etherscan-v2",
-  supportsEtherscanV2: true,
-  iconComponent: import_react2.NetworkBase,
-  nativeCurrency: {
-    name: "Ether",
-    symbol: "ETH",
-    decimals: 18
-  },
-  viemChain: import_chains.base
-};
-var bscMainnet = {
-  id: "bsc-mainnet",
-  exportConstName: "bscMainnet",
-  name: "BNB Smart Chain",
-  ecosystem: "evm",
-  network: "bsc",
-  type: "mainnet",
-  isTestnet: false,
-  chainId: 56,
-  rpcUrl: import_chains.bsc.rpcUrls.default.http[0],
-  explorerUrl: "https://bscscan.com",
-  apiUrl: "https://api.etherscan.io/v2/api",
-  primaryExplorerApiIdentifier: "etherscan-v2",
-  supportsEtherscanV2: true,
-  iconComponent: import_react2.NetworkBinanceSmartChain,
-  nativeCurrency: {
-    name: "BNB",
-    symbol: "BNB",
-    decimals: 18
-  },
-  viemChain: import_chains.bsc
-};
-var optimismMainnet = {
-  id: "optimism-mainnet",
-  exportConstName: "optimismMainnet",
-  name: "OP Mainnet",
-  ecosystem: "evm",
-  network: "optimism",
-  type: "mainnet",
-  isTestnet: false,
-  chainId: 10,
-  rpcUrl: import_chains.optimism.rpcUrls.default.http[0],
-  explorerUrl: "https://optimistic.etherscan.io",
-  apiUrl: "https://api.etherscan.io/v2/api",
-  primaryExplorerApiIdentifier: "etherscan-v2",
-  supportsEtherscanV2: true,
-  iconComponent: import_react2.NetworkOptimism,
-  nativeCurrency: {
-    name: "Ether",
-    symbol: "ETH",
-    decimals: 18
-  },
-  viemChain: import_chains.optimism
+// src/utils/gas.ts
+var import_viem2 = require("viem");
+var weiToGwei = (wei) => {
+  if (!wei) return void 0;
+  return parseFloat((0, import_viem2.formatGwei)(BigInt(wei)));
 };
-var avalancheMainnet = {
-  id: "avalanche-mainnet",
-  exportConstName: "avalancheMainnet",
-  name: "Avalanche C-Chain",
-  ecosystem: "evm",
-  network: "avalanche",
-  type: "mainnet",
-  isTestnet: false,
-  chainId: 43114,
-  rpcUrl: import_chains.avalanche.rpcUrls.default.http[0],
-  explorerUrl: "https://snowscan.xyz",
-  apiUrl: "https://api.etherscan.io/v2/api",
-  primaryExplorerApiIdentifier: "etherscan-v2",
-  supportsEtherscanV2: true,
-  iconComponent: import_react2.NetworkAvalanche,
-  nativeCurrency: {
-    name: "Avalanche",
-    symbol: "AVAX",
-    decimals: 18
-  },
-  viemChain: import_chains.avalanche
+var gweiToWei = (gwei) => {
+  if (!gwei) return void 0;
+  return Number((0, import_viem2.parseGwei)(gwei.toString()));
 };
-var zkSyncEraMainnet = {
-  id: "zksync-era-mainnet",
+
+// src/abi/transformer.ts
+function transformAbiToSchema(abi, contractName, address) {
+  import_ui_builder_utils2.logger.info("transformAbiToSchema", `Transforming ABI to ContractSchema for: ${contractName}`);
+  const functions = [];
+  for (const item of abi) {
+    if (item.type === "function") {
+      const abiFunctionItem = item;
+      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 = {
+    ecosystem: "evm",
+    // This transformer is specific to EVM.
+    name: contractName,
+    address,
+    functions
+  };
+  import_ui_builder_utils2.logger.info(
+    "transformAbiToSchema",
+    `Transformation complete. Found ${contractSchema.functions.length} functions.`
+  );
+  return contractSchema;
+}
+function mapAbiParametersToSchemaParameters(abiParams) {
+  if (!abiParams) {
+    return [];
+  }
+  return abiParams.map((param) => {
+    const schemaParam = {
+      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.
+    };
+    if (param.type.startsWith("tuple") && "components" in param && // Type guard for discriminated union (AbiParameter)
+    param.components && param.components.length > 0) {
+      schemaParam.components = mapAbiParametersToSchemaParameters(
+        param.components
+      );
+    }
+    return schemaParam;
+  });
+}
+function mapSchemaParameterToAbiParameter(param) {
+  if (param.type.startsWith("tuple") && param.components && param.components.length > 0) {
+    return {
+      name: param.name || void 0,
+      // ABI parameter names can be undefined (e.g., for return values).
+      type: param.type,
+      // Cast to satisfy viem's specific tuple type string.
+      // Recursively map nested components back to AbiParameter format.
+      components: param.components.map(mapSchemaParameterToAbiParameter)
+    };
+  }
+  return {
+    name: param.name || void 0,
+    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`.
+  };
+}
+function createAbiFunctionItem(functionDetails) {
+  return {
+    name: functionDetails.name,
+    type: "function",
+    inputs: functionDetails.inputs.map(mapSchemaParameterToAbiParameter),
+    outputs: functionDetails.outputs?.map(mapSchemaParameterToAbiParameter) || [],
+    stateMutability: functionDetails.stateMutability ?? "view"
+  };
+}
+
+// src/abi/etherscan-v2.ts
+var ETHERSCAN_V2_BASE_URL = "https://api.etherscan.io/v2/api";
+function buildV2ApiUrl(chainId, module2, action, params, apiKey) {
+  const url = new URL(ETHERSCAN_V2_BASE_URL);
+  url.searchParams.append("chainid", chainId.toString());
+  url.searchParams.append("module", module2);
+  url.searchParams.append("action", action);
+  Object.entries(params).forEach(([key, value]) => {
+    url.searchParams.append(key, value);
+  });
+  if (apiKey) {
+    url.searchParams.append("apikey", apiKey);
+  }
+  return url.toString();
+}
+function shouldUseV2Api(networkConfig) {
+  if (!networkConfig.supportsEtherscanV2) {
+    return false;
+  }
+  return true;
+}
+async function loadAbiFromEtherscanV2(address, networkConfig) {
+  const explorerConfig = resolveExplorerConfig(networkConfig);
+  const url = buildV2ApiUrl(
+    networkConfig.chainId,
+    "contract",
+    "getabi",
+    { address },
+    explorerConfig.apiKey
+  );
+  let response;
+  try {
+    import_ui_builder_utils3.logger.info(
+      "loadAbiFromEtherscanV2",
+      `Fetching ABI from Etherscan V2 API for address: ${address} on chain ${networkConfig.chainId}`
+    );
+    response = await fetch(url);
+  } catch (networkError) {
+    import_ui_builder_utils3.logger.error(
+      "loadAbiFromEtherscanV2",
+      `Network error fetching ABI from Explorer V2 API: ${networkError}`
+    );
+    throw new Error(`Network error fetching ABI: ${networkError.message}`);
+  }
+  if (!response.ok) {
+    import_ui_builder_utils3.logger.error(
+      "loadAbiFromEtherscanV2",
+      `Explorer V2 API request failed with status: ${response.status}`
+    );
+    throw new Error(`Explorer V2 API request failed: ${response.status} ${response.statusText}`);
+  }
+  let apiResult;
+  try {
+    apiResult = await response.json();
+  } catch (jsonError) {
+    import_ui_builder_utils3.logger.error(
+      "loadAbiFromEtherscanV2",
+      `Failed to parse Explorer V2 API response as JSON: ${jsonError}`
+    );
+    throw new Error("Invalid JSON response received from Explorer V2 API.");
+  }
+  if (apiResult.status !== "1") {
+    import_ui_builder_utils3.logger.warn(
+      "loadAbiFromEtherscanV2",
+      `Explorer V2 API error: Status ${apiResult.status}, Message: ${apiResult.message}, Result: ${apiResult.result}`
+    );
+    if (apiResult.message?.includes("NOTOK")) {
+      if (apiResult.result?.includes("Invalid API Key")) {
+        throw new Error(
+          `Invalid API key for Etherscan V2. Please check your API key configuration.`
+        );
+      }
+      if (apiResult.result?.includes("Contract source code not verified")) {
+        throw new Error(
+          `Contract not verified on ${networkConfig.name} explorer (address: ${address}). ABI not available. You can provide the contract's ABI manually.`
+        );
+      }
+      if (apiResult.result?.includes("Invalid chain")) {
+        throw new Error(
+          `Chain ID ${networkConfig.chainId} is not supported by Etherscan V2 API. Please check if this chain is available.`
+        );
+      }
+    }
+    throw new Error(`Explorer V2 API Error: ${apiResult.result || apiResult.message}`);
+  }
+  const originalAbiString = apiResult.result;
+  let abi;
+  try {
+    abi = JSON.parse(originalAbiString);
+    if (!Array.isArray(abi)) {
+      throw new Error("Parsed ABI from Explorer V2 API is not an array.");
+    }
+  } catch (error) {
+    import_ui_builder_utils3.logger.error(
+      "loadAbiFromEtherscanV2",
+      `Failed to parse ABI JSON string from Explorer V2 API result: ${error}`
+    );
+    throw new Error(`Invalid ABI JSON received from Explorer V2 API: ${error.message}`);
+  }
+  import_ui_builder_utils3.logger.info(
+    "loadAbiFromEtherscanV2",
+    `Successfully parsed ABI for ${networkConfig.name} with ${abi.length} items using V2 API.`
+  );
+  const contractName = `Contract_${address.substring(0, 6)}`;
+  const schema = transformAbiToSchema(abi, contractName, address);
+  return {
+    schema,
+    originalAbi: originalAbiString
+  };
+}
+async function testEtherscanV2Connection(networkConfig, apiKey) {
+  const startTime = Date.now();
+  const requiresApiKey = networkConfig.requiresExplorerApiKey ?? true;
+  if (requiresApiKey && !apiKey) {
+    return {
+      success: false,
+      error: "API key is required for testing connection to this explorer"
+    };
+  }
+  try {
+    const url = buildV2ApiUrl(networkConfig.chainId, "proxy", "eth_blockNumber", {}, apiKey);
+    const response = await fetch(url);
+    const latency = Date.now() - startTime;
+    if (!response.ok) {
+      return {
+        success: false,
+        error: `HTTP ${response.status}: ${response.statusText}`,
+        latency
+      };
+    }
+    const data = await response.json();
+    if (data.status === "0" && data.message) {
+      if (data.result?.includes("Invalid API Key")) {
+        return {
+          success: false,
+          error: "Invalid API key. Please check your Etherscan API key.",
+          latency
+        };
+      }
+      if (data.result?.includes("Invalid chain")) {
+        return {
+          success: false,
+          error: `Chain ID ${networkConfig.chainId} is not supported by Etherscan V2 API.`,
+          latency
+        };
+      }
+      return {
+        success: false,
+        error: data.result || data.message,
+        latency
+      };
+    }
+    return {
+      success: true,
+      latency
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Connection test failed",
+      latency: Date.now() - startTime
+    };
+  }
+}
+
+// src/configuration/explorer.ts
+function resolveExplorerConfig(networkConfig) {
+  const isV2 = networkConfig.supportsEtherscanV2 && networkConfig.primaryExplorerApiIdentifier === "etherscan-v2";
+  const globalV2ApiKey = isV2 ? import_ui_builder_utils4.appConfigService.getGlobalServiceConfig("etherscanv2")?.apiKey : void 0;
+  const appApiKey = networkConfig.primaryExplorerApiIdentifier ? import_ui_builder_utils4.appConfigService.getExplorerApiKey(networkConfig.primaryExplorerApiIdentifier) : void 0;
+  const rawCfg = import_ui_builder_utils4.userNetworkServiceConfigService.get(networkConfig.id, "explorer");
+  if (rawCfg && typeof rawCfg === "object") {
+    const userCfg = rawCfg;
+    import_ui_builder_utils4.logger.info("ExplorerConfig", `Using user-configured explorer for ${networkConfig.name}`);
+    return {
+      explorerUrl: userCfg.explorerUrl ?? networkConfig.explorerUrl,
+      apiUrl: userCfg.apiUrl ?? networkConfig.apiUrl,
+      apiKey: userCfg.apiKey ?? globalV2ApiKey ?? appApiKey,
+      name: `${networkConfig.name} Explorer`,
+      isCustom: true
+    };
+  }
+  if (isV2 && globalV2ApiKey) {
+    import_ui_builder_utils4.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
+    };
+  }
+  if (appApiKey) {
+    import_ui_builder_utils4.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
+    };
+  }
+  import_ui_builder_utils4.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
+  };
+}
+function getEvmExplorerAddressUrl(address, networkConfig) {
+  if (!isValidEvmAddress(address)) {
+    return null;
+  }
+  const explorerConfig = resolveExplorerConfig(networkConfig);
+  if (!explorerConfig.explorerUrl) {
+    return null;
+  }
+  const baseUrl = explorerConfig.explorerUrl.replace(/\/+$/, "");
+  return `${baseUrl}/address/${address}`;
+}
+function getEvmExplorerTxUrl(txHash, networkConfig) {
+  if (!txHash) {
+    return null;
+  }
+  const explorerConfig = resolveExplorerConfig(networkConfig);
+  if (!explorerConfig.explorerUrl) {
+    return null;
+  }
+  const baseUrl = explorerConfig.explorerUrl.replace(/\/+$/, "");
+  return `${baseUrl}/tx/${txHash}`;
+}
+function validateEvmExplorerConfig(explorerConfig) {
+  if (explorerConfig.explorerUrl) {
+    try {
+      new URL(explorerConfig.explorerUrl);
+    } catch {
+      return false;
+    }
+  }
+  if (explorerConfig.apiUrl) {
+    try {
+      new URL(explorerConfig.apiUrl);
+    } catch {
+      return false;
+    }
+  }
+  if (explorerConfig.apiKey !== void 0 && explorerConfig.apiKey.trim().length === 0) {
+    return false;
+  }
+  return true;
+}
+async function testEvmExplorerConnection(explorerConfig, networkConfig) {
+  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"
+    };
+  }
+  if (networkConfig && shouldUseV2Api(networkConfig)) {
+    return testEtherscanV2Connection(networkConfig, explorerConfig.apiKey);
+  }
+  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 {
+    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();
+    if (data.status === "0" && data.message) {
+      return {
+        success: false,
+        error: data.message,
+        latency
+      };
+    }
+    return {
+      success: true,
+      latency
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Connection test failed",
+      latency: Date.now() - startTime
+    };
+  }
+}
+
+// src/configuration/rpc.ts
+var import_ui_builder_utils5 = require("@openzeppelin/ui-builder-utils");
+function buildRpcUrl(config) {
+  return config.url;
+}
+function getUserRpcUrl(networkId) {
+  const svcCfg = import_ui_builder_utils5.userNetworkServiceConfigService.get(networkId, "rpc");
+  if (svcCfg && typeof svcCfg === "object" && "rpcUrl" in svcCfg) {
+    return svcCfg.rpcUrl;
+  }
+  return void 0;
+}
+function resolveRpcUrl(networkConfig) {
+  const logSystem = "RpcResolver";
+  const networkId = networkConfig.id;
+  const userRpcUrl = getUserRpcUrl(networkId);
+  if (userRpcUrl) {
+    const userRpcUrlString = String(userRpcUrl);
+    if ((0, import_ui_builder_utils5.isValidUrl)(userRpcUrlString)) {
+      import_ui_builder_utils5.logger.info(logSystem, `Using user-configured RPC URL for network ${networkId}`);
+      return userRpcUrlString;
+    } else {
+      import_ui_builder_utils5.logger.warn(
+        logSystem,
+        `User-configured RPC URL for ${networkId} is invalid: ${userRpcUrlString}. Falling back.`
+      );
+    }
+  }
+  const rpcOverrideSetting = import_ui_builder_utils5.appConfigService.getRpcEndpointOverride(networkId);
+  let rpcUrlFromOverride;
+  if (typeof rpcOverrideSetting === "string") {
+    rpcUrlFromOverride = rpcOverrideSetting;
+  } else if (typeof rpcOverrideSetting === "object" && rpcOverrideSetting) {
+    if ("url" in rpcOverrideSetting && "isCustom" in rpcOverrideSetting) {
+      const userConfig = rpcOverrideSetting;
+      rpcUrlFromOverride = buildRpcUrl(userConfig);
+    } else if ("http" in rpcOverrideSetting) {
+      rpcUrlFromOverride = rpcOverrideSetting.http;
+    }
+  }
+  if (rpcUrlFromOverride) {
+    import_ui_builder_utils5.logger.info(
+      logSystem,
+      `Using overridden RPC URL for network ${networkId}: ${rpcUrlFromOverride}`
+    );
+    if ((0, import_ui_builder_utils5.isValidUrl)(rpcUrlFromOverride)) {
+      return rpcUrlFromOverride;
+    } else {
+      import_ui_builder_utils5.logger.warn(
+        logSystem,
+        `Overridden RPC URL for ${networkId} is invalid: ${rpcUrlFromOverride}. Falling back.`
+      );
+    }
+  }
+  if (networkConfig.rpcUrl && (0, import_ui_builder_utils5.isValidUrl)(networkConfig.rpcUrl)) {
+    import_ui_builder_utils5.logger.debug(
+      logSystem,
+      `Using default RPC URL for network ${networkId}: ${networkConfig.rpcUrl}`
+    );
+    return networkConfig.rpcUrl;
+  }
+  import_ui_builder_utils5.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}).`
+  );
+}
+function validateEvmRpcEndpoint(rpcConfig) {
+  try {
+    if (!(0, import_ui_builder_utils5.isValidUrl)(rpcConfig.url)) {
+      import_ui_builder_utils5.logger.error("validateEvmRpcEndpoint", `Invalid RPC URL format: ${rpcConfig.url}`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    import_ui_builder_utils5.logger.error("validateEvmRpcEndpoint", "Error validating RPC endpoint:", error);
+    return false;
+  }
+}
+async function testEvmRpcConnection(rpcConfig, timeoutMs = 5e3) {
+  if (!rpcConfig.url) {
+    return { success: false, error: "RPC URL is required" };
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const startTime = Date.now();
+    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) {
+    import_ui_builder_utils5.logger.error("testEvmRpcConnection", "Connection test failed:", error);
+    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 {
+    clearTimeout(timeoutId);
+  }
+}
+
+// src/configuration/network-services.ts
+function getEvmNetworkServiceForms(networkConfig) {
+  const globalV2ApiKey = import_ui_builder_utils6.appConfigService.getGlobalServiceConfig("etherscanv2")?.apiKey;
+  const v2DefaultEnabled = Boolean(globalV2ApiKey);
+  const savedContractDefCfg = import_ui_builder_utils6.userNetworkServiceConfigService.get(
+    networkConfig.id,
+    "contract-definitions"
+  );
+  const savedDefaultProvider = savedContractDefCfg && typeof savedContractDefCfg.defaultProvider === "string" ? savedContractDefCfg.defaultProvider : void 0;
+  return [
+    {
+      id: "rpc",
+      label: "RPC Provider",
+      description: "Setting your own RPC endpoint ensures better reliability, faster response times, and higher rate limits. Public endpoints may be rate-limited or experience congestion during high traffic periods.",
+      fields: [
+        {
+          id: "evm-rpc-url",
+          name: "rpcUrl",
+          type: "text",
+          label: "RPC URL",
+          placeholder: "https://mainnet.infura.io/v3/your-key",
+          validation: { required: true, pattern: "^https?://.+" },
+          width: "full"
+        }
+      ]
+    },
+    {
+      id: "explorer",
+      label: "Block Explorer",
+      description: "Public API keys are rate-limited and may be exhausted quickly. Using your own key ensures reliable access to explorer services.",
+      fields: [
+        // Adapter-led informational notes (rendered generically by the panel)
+        {
+          id: "evm-explorer-note-etherscan",
+          name: "_note_etherscan",
+          type: "hidden",
+          label: "",
+          validation: {},
+          isHidden: true,
+          metadata: {
+            note: {
+              variant: "warning",
+              title: "Etherscan API Support",
+              html: true,
+              lines: [
+                "<strong>V2 API (Recommended):</strong> Supports all Etherscan-compatible explorers across multiple chains with a single API key.",
+                "<strong>V1 API (Legacy):</strong> Requires chain-specific API endpoints. Some explorers may not be supported.",
+                "<strong>Note:</strong> Non-Etherscan explorers (Blockscout, Routescan, etc.) are not supported."
+              ]
+            }
+          }
+        },
+        {
+          id: "evm-explorer-api-key",
+          name: "apiKey",
+          type: "password",
+          label: "API Key",
+          placeholder: "Your explorer API key",
+          helperText: "Required for fetching contract ABIs and other API operations",
+          validation: {},
+          width: "full"
+        },
+        {
+          id: "evm-explorer-use-v2",
+          name: "useV2Api",
+          type: "checkbox",
+          label: "Use Etherscan V2 API",
+          helperText: "Enable the new V2 API for all Etherscan-compatible networks. V2 provides unified access across all chains.",
+          validation: {},
+          defaultValue: v2DefaultEnabled,
+          metadata: {
+            section: "api-config",
+            sectionLabel: "API Configuration",
+            sectionHelp: "Configure API version and network application settings."
+          }
+        },
+        {
+          id: "evm-explorer-apply-all",
+          name: "applyToAllNetworks",
+          type: "checkbox",
+          label: "Apply to all compatible networks",
+          helperText: "Apply these settings to all Etherscan-compatible networks in your project.",
+          validation: {},
+          defaultValue: v2DefaultEnabled,
+          // UI hinting for generic renderer to indent under and disable when V2 is off
+          metadata: {
+            section: "api-config",
+            nestUnder: "useV2Api",
+            disabledWhen: { field: "useV2Api", equals: false }
+          }
+        },
+        {
+          id: "evm-explorer-url",
+          name: "explorerUrl",
+          type: "text",
+          label: "Explorer Base URL (optional)",
+          placeholder: "https://etherscan.io",
+          validation: {},
+          helperText: "Base URL for viewing transactions and addresses. If not provided, defaults from the network will be used.",
+          width: "full",
+          metadata: {
+            section: "custom-endpoints",
+            sectionLabel: "Custom Endpoints",
+            sectionHelp: "Override default URLs for explorer and API endpoints."
+          }
+        },
+        {
+          id: "evm-explorer-api-url",
+          name: "apiUrl",
+          type: "text",
+          label: "Explorer API URL (legacy / V1)",
+          placeholder: "https://api.etherscan.io/api",
+          validation: {},
+          helperText: "API endpoint for fetching contract data. If not provided, defaults from the network will be used.",
+          width: "full",
+          metadata: { section: "custom-endpoints" }
+        }
+      ]
+    },
+    {
+      id: "contract-definitions",
+      label: "Contract Definitions",
+      description: void 0,
+      supportsConnectionTest: false,
+      fields: [
+        // Informational note
+        {
+          id: "evm-contract-def-note",
+          name: "_note_contract_def",
+          type: "hidden",
+          label: "",
+          validation: {},
+          isHidden: true,
+          metadata: {
+            hideTestConnection: true,
+            note: {
+              variant: "info",
+              title: "Contract Definition Provider",
+              lines: [
+                "Select which provider the builder should try first when loading verified contract definitions. Deep links can override this preference temporarily."
+              ]
+            }
+          }
+        },
+        // Default provider select
+        {
+          id: "evm-contract-def-provider",
+          name: "defaultProvider",
+          type: "select",
+          label: "Default Contract Definition Provider",
+          placeholder: "Select a provider",
+          helperText: "Used as the first provider to query for contract definitions.",
+          validation: {},
+          options: [
+            { label: "Etherscan", value: EvmProviderKeys.Etherscan },
+            { label: "Sourcify", value: EvmProviderKeys.Sourcify }
+          ],
+          // Seed from saved user config or app-config default if present; otherwise empty
+          defaultValue: savedDefaultProvider || import_ui_builder_utils6.appConfigService.getGlobalServiceParam("contractdefinition", "defaultProvider") || "",
+          width: "full"
+        },
+        // Apply to all networks
+        {
+          id: "evm-contract-def-apply-all",
+          name: "applyToAllNetworks",
+          type: "checkbox",
+          label: "Apply to all compatible networks",
+          helperText: "Apply this default provider setting to all compatible networks in your project.",
+          validation: {},
+          defaultValue: false,
+          metadata: {
+            nestUnder: "defaultProvider",
+            disabledWhen: { field: "defaultProvider", equals: "" }
+          }
+        }
+      ]
+    }
+  ];
+}
+async function validateEvmNetworkServiceConfig(serviceId, values) {
+  if (serviceId === "rpc") {
+    const cfg = { url: String(values.rpcUrl || ""), isCustom: true };
+    return validateEvmRpcEndpoint(cfg);
+  }
+  if (serviceId === "explorer") {
+    const cfg = {
+      explorerUrl: values.explorerUrl ? String(values.explorerUrl) : void 0,
+      apiUrl: values.apiUrl ? String(values.apiUrl) : void 0,
+      apiKey: values.apiKey ? String(values.apiKey) : void 0,
+      isCustom: true,
+      applyToAllNetworks: Boolean(values.applyToAllNetworks)
+    };
+    return validateEvmExplorerConfig(cfg);
+  }
+  if (serviceId === "contract-definitions") {
+    const raw = values.defaultProvider;
+    if (raw === void 0 || raw === null || raw === "") return true;
+    return isEvmProviderKey(raw);
+  }
+  return true;
+}
+async function testEvmNetworkServiceConnection(serviceId, values, networkConfig) {
+  if (serviceId === "rpc") {
+    const cfg = { url: String(values.rpcUrl || ""), isCustom: true };
+    return testEvmRpcConnection(cfg);
+  }
+  if (serviceId === "explorer") {
+    const cfg = {
+      explorerUrl: values.explorerUrl ? String(values.explorerUrl) : void 0,
+      apiUrl: values.apiUrl ? String(values.apiUrl) : void 0,
+      apiKey: values.apiKey ? String(values.apiKey) : void 0,
+      isCustom: true,
+      applyToAllNetworks: Boolean(values.applyToAllNetworks)
+    };
+    return testEvmExplorerConnection(cfg, networkConfig);
+  }
+  return { success: true };
+}
+
+// src/wallet/components/EvmWalletUiRoot.tsx
+var import_react_query = require("@tanstack/react-query");
+var import_core3 = require("@wagmi/core");
+var import_chains3 = require("viem/chains");
+var import_wagmi = require("wagmi");
+var import_react9 = require("react");
+var import_ui_builder_utils19 = require("@openzeppelin/ui-builder-utils");
+
+// src/wallet/context/wagmi-context.tsx
+var import_react = require("react");
+var WagmiProviderInitializedContext = (0, import_react.createContext)(false);
+
+// src/wallet/evmUiKitManager.ts
+var import_ui_builder_utils18 = require("@openzeppelin/ui-builder-utils");
+
+// src/wallet/utils/walletImplementationManager.ts
+var import_ui_builder_utils16 = require("@openzeppelin/ui-builder-utils");
+
+// src/wallet/implementation/wagmi-implementation.ts
+var import_connectors = require("@wagmi/connectors");
+var import_core2 = require("@wagmi/core");
+var import_viem3 = require("viem");
+var import_ui_builder_utils15 = require("@openzeppelin/ui-builder-utils");
+
+// src/networks/mainnet.ts
+var import_react2 = require("@web3icons/react");
+var import_chains = require("viem/chains");
+var ethereumMainnet = {
+  id: "ethereum-mainnet",
+  exportConstName: "ethereumMainnet",
+  name: "Ethereum",
+  ecosystem: "evm",
+  network: "ethereum",
+  type: "mainnet",
+  isTestnet: false,
+  chainId: 1,
+  rpcUrl: import_chains.mainnet.rpcUrls.default.http[0],
+  explorerUrl: "https://etherscan.io",
+  apiUrl: "https://api.etherscan.io/v2/api",
+  primaryExplorerApiIdentifier: "etherscan-v2",
+  supportsEtherscanV2: true,
+  iconComponent: import_react2.NetworkEthereum,
+  nativeCurrency: {
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18
+  },
+  viemChain: import_chains.mainnet
+};
+var arbitrumMainnet = {
+  id: "arbitrum-mainnet",
+  exportConstName: "arbitrumMainnet",
+  name: "Arbitrum One",
+  ecosystem: "evm",
+  network: "arbitrum",
+  type: "mainnet",
+  isTestnet: false,
+  chainId: 42161,
+  rpcUrl: import_chains.arbitrum.rpcUrls.default.http[0],
+  explorerUrl: "https://arbiscan.io",
+  apiUrl: "https://api.etherscan.io/v2/api",
+  primaryExplorerApiIdentifier: "etherscan-v2",
+  supportsEtherscanV2: true,
+  iconComponent: import_react2.NetworkArbitrumOne,
+  nativeCurrency: {
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18
+  },
+  viemChain: import_chains.arbitrum
+};
+var polygonMainnet = {
+  id: "polygon-mainnet",
+  exportConstName: "polygonMainnet",
+  name: "Polygon",
+  ecosystem: "evm",
+  network: "polygon",
+  type: "mainnet",
+  isTestnet: false,
+  chainId: 137,
+  rpcUrl: import_chains.polygon.rpcUrls.default.http[0],
+  explorerUrl: "https://polygonscan.com",
+  apiUrl: "https://api.etherscan.io/v2/api",
+  primaryExplorerApiIdentifier: "etherscan-v2",
+  supportsEtherscanV2: true,
+  iconComponent: import_react2.NetworkPolygon,
+  nativeCurrency: {
+    name: "MATIC",
+    symbol: "MATIC",
+    decimals: 18
+  },
+  viemChain: import_chains.polygon
+};
+var polygonZkEvmMainnet = {
+  id: "polygon-zkevm-mainnet",
+  exportConstName: "polygonZkEvmMainnet",
+  name: "Polygon zkEVM",
+  ecosystem: "evm",
+  network: "polygon-zkevm",
+  type: "mainnet",
+  isTestnet: false,
+  chainId: 1101,
+  rpcUrl: import_chains.polygonZkEvm.rpcUrls.default.http[0],
+  explorerUrl: "https://zkevm.polygonscan.com",
+  apiUrl: "https://api.etherscan.io/v2/api",
+  primaryExplorerApiIdentifier: "etherscan-v2",
+  supportsEtherscanV2: true,
+  iconComponent: import_react2.NetworkPolygon,
+  nativeCurrency: {
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18
+  },
+  viemChain: import_chains.polygonZkEvm
+};
+var baseMainnet = {
+  id: "base-mainnet",
+  exportConstName: "baseMainnet",
+  name: "Base",
+  ecosystem: "evm",
+  network: "base",
+  type: "mainnet",
+  isTestnet: false,
+  chainId: 8453,
+  rpcUrl: import_chains.base.rpcUrls.default.http[0],
+  explorerUrl: "https://basescan.org",
+  apiUrl: "https://api.etherscan.io/v2/api",
+  primaryExplorerApiIdentifier: "etherscan-v2",
+  supportsEtherscanV2: true,
+  iconComponent: import_react2.NetworkBase,
+  nativeCurrency: {
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18
+  },
+  viemChain: import_chains.base
+};
+var bscMainnet = {
+  id: "bsc-mainnet",
+  exportConstName: "bscMainnet",
+  name: "BNB Smart Chain",
+  ecosystem: "evm",
+  network: "bsc",
+  type: "mainnet",
+  isTestnet: false,
+  chainId: 56,
+  rpcUrl: import_chains.bsc.rpcUrls.default.http[0],
+  explorerUrl: "https://bscscan.com",
+  apiUrl: "https://api.etherscan.io/v2/api",
+  primaryExplorerApiIdentifier: "etherscan-v2",
+  supportsEtherscanV2: true,
+  iconComponent: import_react2.NetworkBinanceSmartChain,
+  nativeCurrency: {
+    name: "BNB",
+    symbol: "BNB",
+    decimals: 18
+  },
+  viemChain: import_chains.bsc
+};
+var optimismMainnet = {
+  id: "optimism-mainnet",
+  exportConstName: "optimismMainnet",
+  name: "OP Mainnet",
+  ecosystem: "evm",
+  network: "optimism",
+  type: "mainnet",
+  isTestnet: false,
+  chainId: 10,
+  rpcUrl: import_chains.optimism.rpcUrls.default.http[0],
+  explorerUrl: "https://optimistic.etherscan.io",
+  apiUrl: "https://api.etherscan.io/v2/api",
+  primaryExplorerApiIdentifier: "etherscan-v2",
+  supportsEtherscanV2: true,
+  iconComponent: import_react2.NetworkOptimism,
+  nativeCurrency: {
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18
+  },
+  viemChain: import_chains.optimism
+};
+var avalancheMainnet = {
+  id: "avalanche-mainnet",
+  exportConstName: "avalancheMainnet",
+  name: "Avalanche C-Chain",
+  ecosystem: "evm",
+  network: "avalanche",
+  type: "mainnet",
+  isTestnet: false,
+  chainId: 43114,
+  rpcUrl: import_chains.avalanche.rpcUrls.default.http[0],
+  explorerUrl: "https://snowscan.xyz",
+  apiUrl: "https://api.etherscan.io/v2/api",
+  primaryExplorerApiIdentifier: "etherscan-v2",
+  supportsEtherscanV2: true,
+  iconComponent: import_react2.NetworkAvalanche,
+  nativeCurrency: {
+    name: "Avalanche",
+    symbol: "AVAX",
+    decimals: 18
+  },
+  viemChain: import_chains.avalanche
+};
+var zkSyncEraMainnet = {
+  id: "zksync-era-mainnet",
   exportConstName: "zkSyncEraMainnet",
   name: "ZkSync Era",
   ecosystem: "evm",
@@ -1042,18 +1869,18 @@ var evmNetworks = [...evmMainnetNetworks, ...evmTestnetNetworks];
 var import_lucide_react4 = require("lucide-react");
 var import_react8 = require("react");
 var import_ui_builder_ui5 = require("@openzeppelin/ui-builder-ui");
-var import_ui_builder_utils7 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils12 = require("@openzeppelin/ui-builder-utils");
 
 // src/wallet/components/connect/ConnectButton.tsx
 var import_lucide_react = require("lucide-react");
 var import_react7 = require("react");
 var import_ui_builder_react_core2 = require("@openzeppelin/ui-builder-react-core");
 var import_ui_builder_ui2 = require("@openzeppelin/ui-builder-ui");
-var import_ui_builder_utils4 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils9 = require("@openzeppelin/ui-builder-utils");
 
 // src/wallet/utils/SafeWagmiComponent.tsx
 var import_react5 = require("react");
-var import_ui_builder_utils2 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils7 = require("@openzeppelin/ui-builder-utils");
 
 // src/wallet/hooks/useIsWagmiProviderInitialized.ts
 var import_react4 = require("react");
@@ -1077,7 +1904,7 @@ var SafeWagmiComponent = ({
   (0, import_react5.useEffect)(() => {
     const handleError = (event) => {
       if (event.error?.message?.includes("useConfig") || event.error?.message?.includes("WagmiProvider")) {
-        import_ui_builder_utils2.logger.debug(
+        import_ui_builder_utils7.logger.debug(
           "SafeWagmiComponent",
           "Caught wagmi error via window error event:",
           event.error
@@ -1098,7 +1925,7 @@ var SafeWagmiComponent = ({
     return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
   } catch (error) {
     if (error instanceof Error && (error.message.includes("useConfig") || error.message.includes("WagmiProvider"))) {
-      import_ui_builder_utils2.logger.debug("SafeWagmiComponent", "Caught wagmi error:", error);
+      import_ui_builder_utils7.logger.debug("SafeWagmiComponent", "Caught wagmi error:", error);
       setHasError(true);
       return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: fallback });
     }
@@ -1112,7 +1939,7 @@ var import_ui_builder_react_core = require("@openzeppelin/ui-builder-react-core"
 var import_ui_builder_ui = require("@openzeppelin/ui-builder-ui");
 
 // src/wallet/hooks/useUiKitConfig.ts
-var import_ui_builder_utils3 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils8 = require("@openzeppelin/ui-builder-utils");
 var defaultConfig = {
   kitName: "custom",
   // Default to using our custom implementation for EVM
@@ -1123,10 +1950,10 @@ var defaultConfig = {
 };
 var uiKitConfig = { ...defaultConfig };
 function loadInitialConfigFromAppService() {
-  import_ui_builder_utils3.logger.debug("useUiKitConfig", "Attempting to load initial config from AppConfigService...");
-  const configObj = import_ui_builder_utils3.appConfigService.getWalletUIConfig("evm");
+  import_ui_builder_utils8.logger.debug("useUiKitConfig", "Attempting to load initial config from AppConfigService...");
+  const configObj = import_ui_builder_utils8.appConfigService.getWalletUIConfig("evm");
   if (configObj && configObj.kitName) {
-    import_ui_builder_utils3.logger.info(
+    import_ui_builder_utils8.logger.info(
       "useUiKitConfig",
       `Loaded initial config from AppConfigService: kitName=${configObj.kitName}`,
       configObj.kitConfig
@@ -1136,7 +1963,7 @@ function loadInitialConfigFromAppService() {
       kitConfig: { ...defaultConfig.kitConfig, ...configObj.kitConfig || {} }
     };
   }
-  import_ui_builder_utils3.logger.debug(
+  import_ui_builder_utils8.logger.debug(
     "useUiKitConfig",
     "No initial config found in AppConfigService, using module default."
   );
@@ -1222,7 +2049,7 @@ var CustomConnectButton = ({
   hideWhenConnected = true
 }) => {
   const [dialogOpen, setDialogOpen] = (0, import_react7.useState)(false);
-  const unavailableButton = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: (0, import_ui_builder_utils4.cn)("flex items-center", className), children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ui_builder_ui2.Button, { disabled: true, variant: "outline", size: "sm", className: "h-8 px-2 text-xs", children: [
+  const unavailableButton = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: (0, import_ui_builder_utils9.cn)("flex items-center", className), children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ui_builder_ui2.Button, { disabled: true, variant: "outline", size: "sm", className: "h-8 px-2 text-xs", children: [
     /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_lucide_react.Wallet, { className: "size-3.5 mr-1" }),
     "Wallet Unavailable"
   ] }) });
@@ -1266,7 +2093,7 @@ var ConnectButtonContent = ({ className, dialogOpen, setDialogOpen, hideWhenConn
     return null;
   }
   const showButtonLoading = isHookConnecting || isManuallyInitiated;
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: (0, import_ui_builder_utils4.cn)("flex items-center", className), children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: (0, import_ui_builder_utils9.cn)("flex items-center", className), children: [
     /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
       import_ui_builder_ui2.Button,
       {
@@ -1301,7 +2128,7 @@ var ConnectButtonContent = ({ className, dialogOpen, setDialogOpen, hideWhenConn
 var import_lucide_react2 = require("lucide-react");
 var import_ui_builder_react_core3 = require("@openzeppelin/ui-builder-react-core");
 var import_ui_builder_ui3 = require("@openzeppelin/ui-builder-ui");
-var import_ui_builder_utils5 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils10 = require("@openzeppelin/ui-builder-utils");
 var import_jsx_runtime4 = require("react/jsx-runtime");
 var CustomAccountDisplay = ({ className }) => {
   return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(SafeWagmiComponent, { fallback: null, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(AccountDisplayContent, { className }) });
@@ -1312,9 +2139,9 @@ var AccountDisplayContent = ({ className }) => {
   if (!isConnected || !address || !disconnect2) {
     return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: (0, import_ui_builder_utils5.cn)("flex items-center gap-2", className), children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: (0, import_ui_builder_utils10.cn)("flex items-center gap-2", className), children: [
     /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "flex flex-col", children: [
-      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "text-xs font-medium", children: (0, import_ui_builder_utils5.truncateMiddle)(address, 4, 4) }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "text-xs font-medium", children: (0, import_ui_builder_utils10.truncateMiddle)(address, 4, 4) }),
       /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "text-[9px] text-muted-foreground -mt-0.5", children: chainId ? `Chain ID: ${chainId}` : "Chain ID: N/A" })
     ] }),
     /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
@@ -1335,7 +2162,7 @@ var AccountDisplayContent = ({ className }) => {
 var import_lucide_react3 = require("lucide-react");
 var import_ui_builder_react_core4 = require("@openzeppelin/ui-builder-react-core");
 var import_ui_builder_ui4 = require("@openzeppelin/ui-builder-ui");
-var import_ui_builder_utils6 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils11 = require("@openzeppelin/ui-builder-utils");
 var import_jsx_runtime5 = require("react/jsx-runtime");
 var CustomNetworkSwitcher = ({ className }) => {
   return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(SafeWagmiComponent, { fallback: null, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(NetworkSwitcherContent, { className }) });
@@ -1355,7 +2182,7 @@ var NetworkSwitcherContent = ({ className }) => {
   };
   const currentChain = typedAvailableChains.find((chain) => chain.id === currentChainId);
   const currentChainName = currentChain?.name || "Network";
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: (0, import_ui_builder_utils6.cn)("flex items-center", className), children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: (0, import_ui_builder_utils11.cn)("flex items-center", className), children: [
     /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
       import_ui_builder_ui4.Select,
       {
@@ -1435,7 +2262,7 @@ var RainbowKitConnectButton = (props) => {
         if (isMounted) {
           setError(err instanceof Error ? err : new Error(String(err)));
           setIsLoadingComponent(false);
-          import_ui_builder_utils7.logger.error("RainbowKitConnectButton", "Failed to load RainbowKit ConnectButton:", err);
+          import_ui_builder_utils12.logger.error("RainbowKitConnectButton", "Failed to load RainbowKit ConnectButton:", err);
         }
       }
     };
@@ -1453,7 +2280,7 @@ var RainbowKitConnectButton = (props) => {
       disabled: true,
       variant: "outline",
       size: "sm",
-      className: (0, import_ui_builder_utils7.cn)("h-8 px-2 text-xs", props.className),
+      className: (0, import_ui_builder_utils12.cn)("h-8 px-2 text-xs", props.className),
       children: [
         /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_lucide_react4.Loader2, { className: "h-3.5 w-3.5 animate-spin mr-1.5" }),
         message
@@ -1461,7 +2288,7 @@ var RainbowKitConnectButton = (props) => {
     }
   );
   if (error) {
-    import_ui_builder_utils7.logger.warn(
+    import_ui_builder_utils12.logger.warn(
       "RainbowKitConnectButton",
       "Error loading RainbowKit ConnectButton. Displaying fallback CustomConnectButton."
     );
@@ -1474,7 +2301,7 @@ var RainbowKitConnectButton = (props) => {
     return renderLoadingPlaceholder("Initializing Provider...");
   }
   if (!Component) {
-    import_ui_builder_utils7.logger.warn("RainbowKitConnectButton", "Component is null after loading phase, falling back.");
+    import_ui_builder_utils12.logger.warn("RainbowKitConnectButton", "Component is null after loading phase, falling back.");
     return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(CustomConnectButton, { ...props });
   }
   const kitConfig = managerState.currentFullUiKitConfig?.kitConfig;
@@ -1486,7 +2313,7 @@ var RainbowKitConnectButton = (props) => {
     ...props
     // Allow props to override configuration
   };
-  import_ui_builder_utils7.logger.debug("RainbowKitConnectButton", "Rendering with configuration:", {
+  import_ui_builder_utils12.logger.debug("RainbowKitConnectButton", "Rendering with configuration:", {
     configFromFile: connectButtonConfig,
     finalProps
   });
@@ -1494,20 +2321,20 @@ var RainbowKitConnectButton = (props) => {
 };
 
 // src/wallet/rainbowkit/utils.ts
-var import_ui_builder_utils8 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils13 = require("@openzeppelin/ui-builder-utils");
 function validateRainbowKitConfig(kitConfig) {
-  import_ui_builder_utils8.logger.debug(
+  import_ui_builder_utils13.logger.debug(
     "validateRainbowKitConfig",
     "Received kitConfig for validation:",
     JSON.stringify(kitConfig)
   );
   if (!kitConfig) {
-    import_ui_builder_utils8.logger.warn("validateRainbowKitConfig", "Validation failed: No kitConfig provided.");
+    import_ui_builder_utils13.logger.warn("validateRainbowKitConfig", "Validation failed: No kitConfig provided.");
     return { isValid: false, error: "No kitConfig provided for RainbowKit" };
   }
   const wagmiParamsFromKitConfig = kitConfig.wagmiParams;
   if (!wagmiParamsFromKitConfig || typeof wagmiParamsFromKitConfig !== "object" || wagmiParamsFromKitConfig === null) {
-    import_ui_builder_utils8.logger.warn(
+    import_ui_builder_utils13.logger.warn(
       "validateRainbowKitConfig",
       "Validation failed: kitConfig.wagmiParams is missing or invalid.",
       { wagmiParamsFromKitConfig }
@@ -1523,14 +2350,14 @@ function validateRainbowKitConfig(kitConfig) {
   }
   if (missingFields.length > 0) {
     const errorMsg = `Missing or invalid required fields in wagmiParams: ${missingFields.join(", ")}`;
-    import_ui_builder_utils8.logger.warn("validateRainbowKitConfig", "Validation failed:", errorMsg, { missingFields });
+    import_ui_builder_utils13.logger.warn("validateRainbowKitConfig", "Validation failed:", errorMsg, { missingFields });
     return {
       isValid: false,
       missingFields,
       error: errorMsg
     };
   }
-  import_ui_builder_utils8.logger.debug("validateRainbowKitConfig", "Validation successful.");
+  import_ui_builder_utils13.logger.debug("validateRainbowKitConfig", "Validation successful.");
   return { isValid: true };
 }
 
@@ -1545,63 +2372,12 @@ function createRainbowKitComponents() {
 
 // src/wallet/rainbowkit/config-service.ts
 var import_core = require("@wagmi/core");
-var import_ui_builder_utils9 = require("@openzeppelin/ui-builder-utils");
-var cacheInstanceId = Math.random().toString(36).substring(7);
-var configCache = /* @__PURE__ */ new Map();
-import_ui_builder_utils9.logger.debug("rainbowkit/config-service", "NEW configCache INSTANCE CREATED", cacheInstanceId);
-function createConfigCacheKey(userFullNativeConfig, chains) {
-  const wagmiParamsContent = userFullNativeConfig?.wagmiParams;
-  const chainIds = chains.map((c) => c.id).sort();
-  const keyObject = {
-    wagmiParams: wagmiParamsContent,
-    chainIds
-  };
-  const configHash = JSON.stringify(keyObject);
-  import_ui_builder_utils9.logger.debug(
-    "rainbowkit/config-service:createConfigCacheKey",
-    "Key generation input - userFullNativeConfig.wagmiParams:",
-    wagmiParamsContent,
-    "Key generation input - chainIds:",
-    chainIds,
-    "Generated Key Object for stringify:",
-    keyObject,
-    "Generated Hash:",
-    configHash
-  );
-  return configHash;
-}
+var import_ui_builder_utils14 = require("@openzeppelin/ui-builder-utils");
 async function createRainbowKitWagmiConfig(userFullNativeConfig, chains, chainIdToNetworkIdMap, getRpcEndpointOverride) {
   try {
-    const cacheKey = createConfigCacheKey(userFullNativeConfig, chains);
-    import_ui_builder_utils9.logger.info(
-      "rainbowkit/config-service:createRainbowKitWagmiConfig",
-      "Attempting to get/create config. Cache Key:",
-      cacheKey,
-      "Using cache instance ID:",
-      cacheInstanceId
-    );
-    const cachedConfig = configCache.get(cacheKey);
-    if (cachedConfig) {
-      import_ui_builder_utils9.logger.info(
-        "rainbowkit/config-service:createRainbowKitWagmiConfig",
-        "CACHE HIT. Returning cached RainbowKit Wagmi config.",
-        {
-          cacheKey,
-          cacheInstanceId,
-          cachedConfigObjectId: typeof cachedConfig?.storage === "object" && cachedConfig.storage !== null ? "WagmiStorageObject" : String(cachedConfig?.storage)
-        }
-      );
-      return cachedConfig;
-    } else {
-      import_ui_builder_utils9.logger.warn(
-        "rainbowkit/config-service:createRainbowKitWagmiConfig",
-        "CACHE MISS. Proceeding to create new RainbowKit Wagmi config.",
-        { cacheKey, cacheSize: configCache.size, cacheInstanceId }
-      );
-    }
     const { getDefaultConfig } = await import("@rainbow-me/rainbowkit");
     if (!getDefaultConfig) {
-      import_ui_builder_utils9.logger.error(
+      import_ui_builder_utils14.logger.error(
         "rainbowkit/config-service",
         "Failed to import getDefaultConfig from RainbowKit"
       );
@@ -1609,21 +2385,21 @@ async function createRainbowKitWagmiConfig(userFullNativeConfig, chains, chainId
     }
     const wagmiParams = userFullNativeConfig?.wagmiParams;
     if (!wagmiParams) {
-      import_ui_builder_utils9.logger.warn(
+      import_ui_builder_utils14.logger.warn(
         "rainbowkit/config-service",
         "Resolved kitConfig does not contain a `wagmiParams` object. Cannot create RainbowKit Wagmi config."
       );
       return null;
     }
     if (typeof wagmiParams.appName !== "string" || !wagmiParams.appName) {
-      import_ui_builder_utils9.logger.warn(
+      import_ui_builder_utils14.logger.warn(
         "rainbowkit/config-service",
         "kitConfig.wagmiParams is missing or has invalid `appName`."
       );
       return null;
     }
     if (typeof wagmiParams.projectId !== "string" || !wagmiParams.projectId) {
-      import_ui_builder_utils9.logger.warn(
+      import_ui_builder_utils14.logger.warn(
         "rainbowkit/config-service",
         "kitConfig.wagmiParams is missing or has invalid `projectId`."
       );
@@ -1638,15 +2414,15 @@ async function createRainbowKitWagmiConfig(userFullNativeConfig, chains, chainId
           let httpRpcOverride;
           if (typeof rpcOverrideSetting === "string") {
             httpRpcOverride = rpcOverrideSetting;
-          } else if (typeof rpcOverrideSetting === "object") {
-            if (rpcOverrideSetting?.http) {
+          } else if (typeof rpcOverrideSetting === "object" && rpcOverrideSetting) {
+            if ("http" in rpcOverrideSetting && rpcOverrideSetting.http) {
               httpRpcOverride = rpcOverrideSetting.http;
             } else if ("url" in rpcOverrideSetting && rpcOverrideSetting.url) {
               httpRpcOverride = rpcOverrideSetting.url;
             }
           }
           if (httpRpcOverride) {
-            import_ui_builder_utils9.logger.info(
+            import_ui_builder_utils14.logger.info(
               "rainbowkit/config-service",
               `Using overridden RPC for chain ${chainDefinition.name}: ${httpRpcOverride}`
             );
@@ -1667,30 +2443,20 @@ async function createRainbowKitWagmiConfig(userFullNativeConfig, chains, chainId
       // Adapter controls this
     };
     const config = getDefaultConfig(finalConfigOptions);
-    configCache.set(cacheKey, config);
-    import_ui_builder_utils9.logger.info(
-      "rainbowkit/config-service:createRainbowKitWagmiConfig",
-      "New config created and cached. Cache Size now:",
-      configCache.size,
-      {
-        cacheKey,
-        cacheInstanceId
-      }
-    );
-    import_ui_builder_utils9.logger.info(
+    import_ui_builder_utils14.logger.info(
       "rainbowkit/config-service",
       "Successfully created RainbowKit Wagmi config object.",
       config
     );
     return config;
   } catch (error) {
-    import_ui_builder_utils9.logger.error("rainbowkit/config-service", "Error creating RainbowKit Wagmi config:", error);
+    import_ui_builder_utils14.logger.error("rainbowkit/config-service", "Error creating RainbowKit Wagmi config:", error);
     return null;
   }
 }
 async function getWagmiConfigForRainbowKit(uiKitConfiguration, chains, chainIdToNetworkIdMap, getRpcEndpointOverride) {
   if (!uiKitConfiguration || uiKitConfiguration.kitName !== "rainbowkit" || !uiKitConfiguration.kitConfig) {
-    import_ui_builder_utils9.logger.debug(
+    import_ui_builder_utils14.logger.debug(
       "rainbowkit/config-service",
       "Not configured for RainbowKit or kitConfig (resolved native + programmatic) is missing."
     );
@@ -1710,7 +2476,7 @@ async function getWagmiConfigForRainbowKit(uiKitConfiguration, chains, chainIdTo
 var LOG_SYSTEM = "WagmiWalletImplementation";
 var getSupportedChainsFromNetworks = () => {
   const chains = evmNetworks.filter((network) => network.viemChain).map((network) => network.viemChain).filter((chain, index, self) => self.findIndex((c) => c.id === chain.id) === index);
-  import_ui_builder_utils10.logger.info(
+  import_ui_builder_utils15.logger.info(
     LOG_SYSTEM,
     `Generated supported chains from network configurations: ${chains.length} chains`,
     chains.map((c) => ({ id: c.id, name: c.name }))
@@ -1725,7 +2491,7 @@ var getChainIdToNetworkIdMapping = () => {
     },
     {}
   );
-  import_ui_builder_utils10.logger.info(
+  import_ui_builder_utils15.logger.info(
     LOG_SYSTEM,
     "Generated chain ID to network ID mapping from network configurations:",
     mapping
@@ -1747,1375 +2513,897 @@ var WagmiWalletImplementation = class {
     // To be set by EvmUiKitManager
     __publicField(this, "unsubscribe");
     __publicField(this, "initialized", false);
-    __publicField(this, "walletConnectProjectId");
-    this.walletConnectProjectId = walletConnectProjectIdFromAppConfig;
-    import_ui_builder_utils10.logger.info(
-      LOG_SYSTEM,
-      "Constructor called. Initial anticipated kitName:",
-      initialUiKitConfig?.kitName
-    );
-    this.initialized = true;
-    import_ui_builder_utils10.logger.info(
-      LOG_SYSTEM,
-      "WagmiWalletImplementation instance initialized (Wagmi config creation deferred)."
-    );
-  }
-  /**
-   * Sets the externally determined, currently active WagmiConfig instance.
-   * This is typically called by EvmUiKitManager after it has resolved the appropriate
-   * config for the selected UI kit (e.g., RainbowKit's config or a default custom config).
-   * @param config - The Wagmi Config object to set as active, or null to clear it.
-   */
-  setActiveWagmiConfig(config) {
-    import_ui_builder_utils10.logger.info(
-      LOG_SYSTEM,
-      "setActiveWagmiConfig called with config:",
-      config ? "Valid Config" : "Null"
-    );
-    this.activeWagmiConfig = config;
-    if (this.unsubscribe) {
-      import_ui_builder_utils10.logger.warn(
-        LOG_SYSTEM,
-        "setActiveWagmiConfig: Active WagmiConfig instance has changed. Existing direct watchAccount subscription (via onWalletConnectionChange) may be stale and operating on an old config instance."
-      );
-    }
-  }
-  /**
-   * Creates a default WagmiConfig instance on demand.
-   * This configuration includes standard connectors (injected, MetaMask, Safe)
-   * and WalletConnect if a project ID is available.
-   * Used as a fallback or for 'custom' UI kit mode.
-   * @returns A Wagmi Config object.
-   */
-  createDefaultConfig() {
-    const baseConnectors = [(0, import_connectors.injected)(), (0, import_connectors.metaMask)(), (0, import_connectors.safe)()];
-    if (this.walletConnectProjectId?.trim()) {
-      baseConnectors.push((0, import_connectors.walletConnect)({ projectId: this.walletConnectProjectId }));
-      import_ui_builder_utils10.logger.info(LOG_SYSTEM, "WalletConnect connector added to DEFAULT config.");
-    } else {
-      import_ui_builder_utils10.logger.warn(
-        LOG_SYSTEM,
-        "WalletConnect Project ID not provided; WC connector unavailable for DEFAULT config."
-      );
-    }
-    const transportsConfig = defaultSupportedChains.reduce(
-      (acc, chainDefinition) => {
-        let rpcUrlToUse = chainDefinition.rpcUrls.default?.http?.[0];
-        const appNetworkIdString = viemChainIdToAppNetworkId[chainDefinition.id];
-        if (appNetworkIdString) {
-          const rpcOverrideSetting = import_ui_builder_utils10.appConfigService.getRpcEndpointOverride(appNetworkIdString);
-          let httpRpcOverride;
-          if (typeof rpcOverrideSetting === "string") {
-            httpRpcOverride = rpcOverrideSetting;
-          } else if (typeof rpcOverrideSetting === "object") {
-            if ("http" in rpcOverrideSetting && rpcOverrideSetting.http) {
-              httpRpcOverride = rpcOverrideSetting.http;
-            } else if ("url" in rpcOverrideSetting && rpcOverrideSetting.url) {
-              httpRpcOverride = rpcOverrideSetting.url;
-            }
-          }
-          if (httpRpcOverride) {
-            import_ui_builder_utils10.logger.info(
-              LOG_SYSTEM,
-              `Using overridden RPC for chain ${chainDefinition.name} (default config): ${httpRpcOverride}`
-            );
-            rpcUrlToUse = httpRpcOverride;
-          }
-        }
-        acc[chainDefinition.id] = (0, import_viem.http)(rpcUrlToUse);
-        return acc;
-      },
-      {}
-    );
-    try {
-      const defaultConfig2 = (0, import_core2.createConfig)({
-        chains: defaultSupportedChains,
-        connectors: baseConnectors,
-        transports: transportsConfig
-      });
-      import_ui_builder_utils10.logger.info(LOG_SYSTEM, "Default Wagmi config created successfully on demand.");
-      return defaultConfig2;
-    } catch (error) {
-      import_ui_builder_utils10.logger.error(LOG_SYSTEM, "Error creating default Wagmi config on demand:", error);
-      return (0, import_core2.createConfig)({
-        chains: [defaultSupportedChains[0]],
-        connectors: [(0, import_connectors.injected)()],
-        transports: { [defaultSupportedChains[0].id]: (0, import_viem.http)() }
-      });
-    }
-  }
-  /**
-   * Wrapper function to convert AppConfigService RPC overrides to the format expected by RainbowKit.
-   * @param networkId - The network ID to get RPC override for
-   * @returns RPC configuration in the format expected by RainbowKit
-   */
-  getRpcOverrideForRainbowKit(networkId) {
-    const rpcOverrideSetting = import_ui_builder_utils10.appConfigService.getRpcEndpointOverride(networkId);
-    if (typeof rpcOverrideSetting === "string") {
-      return rpcOverrideSetting;
-    } else if (typeof rpcOverrideSetting === "object" && rpcOverrideSetting !== null) {
-      if ("url" in rpcOverrideSetting && typeof rpcOverrideSetting.url === "string") {
-        return {
-          http: rpcOverrideSetting.url
-        };
-      } else if ("http" in rpcOverrideSetting || "ws" in rpcOverrideSetting) {
-        const config = rpcOverrideSetting;
-        return {
-          http: config.http,
-          ws: config.ws
-        };
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Retrieves or creates the WagmiConfig specifically for RainbowKit.
-   * This delegates to `getWagmiConfigForRainbowKit` service which handles caching
-   * and uses RainbowKit's `getDefaultConfig`.
-   * @param currentAdapterUiKitConfig - The fully resolved UI kit configuration for the adapter.
-   * @returns A Promise resolving to the RainbowKit-specific Wagmi Config object, or null if creation fails or not RainbowKit.
-   */
-  async getConfigForRainbowKit(currentAdapterUiKitConfig) {
-    if (!this.initialized) {
-      import_ui_builder_utils10.logger.error(
-        LOG_SYSTEM,
-        "getConfigForRainbowKit called before implementation initialization."
-      );
-      return null;
-    }
-    if (currentAdapterUiKitConfig?.kitName !== "rainbowkit") {
-      import_ui_builder_utils10.logger.warn(
-        LOG_SYSTEM,
-        "getConfigForRainbowKit called, but kitName is not rainbowkit. Returning null."
-      );
-      return null;
-    }
-    import_ui_builder_utils10.logger.info(
-      LOG_SYSTEM,
-      "getConfigForRainbowKit: Kit is RainbowKit. Proceeding to create/get config. CurrentAdapterUiKitConfig:",
-      currentAdapterUiKitConfig
-    );
-    const rainbowKitWagmiConfig = await getWagmiConfigForRainbowKit(
-      currentAdapterUiKitConfig,
-      defaultSupportedChains,
-      viemChainIdToAppNetworkId,
-      this.getRpcOverrideForRainbowKit.bind(this)
-    );
-    if (rainbowKitWagmiConfig) {
-      import_ui_builder_utils10.logger.info(LOG_SYSTEM, "Returning RainbowKit-specific Wagmi config for provider.");
-      return rainbowKitWagmiConfig;
-    }
-    import_ui_builder_utils10.logger.warn(LOG_SYSTEM, "RainbowKit specific Wagmi config creation failed.");
-    return null;
-  }
-  /**
-   * Determines and returns the WagmiConfig to be used by EvmUiKitManager during its configuration process.
-   * If RainbowKit is specified in the passed uiKitConfig, it attempts to get its specific config.
-   * Otherwise, it falls back to creating/returning a default instance config.
-   * @param uiKitConfig - The fully resolved UiKitConfiguration that the manager is currently processing.
-   * @returns A Promise resolving to the determined Wagmi Config object.
-   */
-  async getActiveConfigForManager(uiKitConfig2) {
-    if (!this.initialized) {
-      import_ui_builder_utils10.logger.error(
-        LOG_SYSTEM,
-        "getActiveConfigForManager called before initialization! Creating fallback."
-      );
-      return (0, import_core2.createConfig)({
-        chains: [defaultSupportedChains[0]],
-        transports: { [defaultSupportedChains[0].id]: (0, import_viem.http)() }
-      });
-    }
-    if (uiKitConfig2?.kitName === "rainbowkit") {
-      const rkConfig = await this.getConfigForRainbowKit(uiKitConfig2);
-      if (rkConfig) return rkConfig;
-      import_ui_builder_utils10.logger.warn(
-        LOG_SYSTEM,
-        "getActiveConfigForManager: RainbowKit config failed, falling back to default."
-      );
-    }
-    if (!this.defaultInstanceConfig) {
-      this.defaultInstanceConfig = this.createDefaultConfig();
-    }
-    return this.defaultInstanceConfig;
-  }
-  /**
-   * @deprecated Prefer using methods that rely on the externally set `activeWagmiConfig`
-   * or methods that determine contextually appropriate config like `getActiveConfigForManager` (for manager use)
-   * or ensure `activeWagmiConfig` is set before calling wagmi actions.
-   * This method returns the internally cached default config or the active one if set.
-   * @returns The current default or active Wagmi Config object.
-   */
-  getConfig() {
-    import_ui_builder_utils10.logger.warn(
-      LOG_SYSTEM,
-      "getConfig() is deprecated. Internal calls should use activeWagmiConfig if set, or ensure default is created."
-    );
-    if (this.activeWagmiConfig) return this.activeWagmiConfig;
-    if (!this.defaultInstanceConfig) {
-      this.defaultInstanceConfig = this.createDefaultConfig();
-    }
-    return this.defaultInstanceConfig;
-  }
-  /**
-   * Gets the current wallet connection status (isConnected, address, chainId, etc.).
-   * This is a synchronous operation and uses the `activeWagmiConfig` if set by `EvmUiKitManager`,
-   * otherwise falls back to the default instance config (created on demand).
-   * For UI reactivity to connection changes, `onWalletConnectionChange` or derived hooks are preferred.
-   * @returns The current account status from Wagmi.
-   */
-  getWalletConnectionStatus() {
-    import_ui_builder_utils10.logger.debug(LOG_SYSTEM, "getWalletConnectionStatus called.");
-    const configToUse = this.activeWagmiConfig || this.defaultInstanceConfig || (this.defaultInstanceConfig = this.createDefaultConfig());
-    if (!configToUse) {
-      import_ui_builder_utils10.logger.error(LOG_SYSTEM, "No config available for getWalletConnectionStatus!");
-      return {
-        isConnected: false,
-        isConnecting: false,
-        isDisconnected: true,
-        isReconnecting: false,
-        status: "disconnected",
-        address: void 0,
-        addresses: void 0,
-        chainId: void 0,
-        chain: void 0,
-        connector: void 0
-      };
-    }
-    return (0, import_core2.getAccount)(configToUse);
-  }
-  /**
-   * Subscribes to account and connection status changes from Wagmi.
-   * The subscription is bound to the `activeWagmiConfig` if available at the time of call,
-   * otherwise to the default instance config. If `activeWagmiConfig` changes later,
-   * this specific subscription might become stale (see warning in `setActiveWagmiConfig`).
-   * @param callback - Function to call when connection status changes.
-   * @returns A function to unsubscribe from the changes.
-   */
-  onWalletConnectionChange(callback) {
-    if (!this.initialized) {
-      import_ui_builder_utils10.logger.warn(LOG_SYSTEM, "onWalletConnectionChange called before initialization. No-op.");
-      return () => {
-      };
-    }
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      import_ui_builder_utils10.logger.debug(LOG_SYSTEM, "Previous watchAccount unsubscribed.");
-    }
-    const configToUse = this.activeWagmiConfig || this.defaultInstanceConfig || (this.defaultInstanceConfig = this.createDefaultConfig());
-    if (!configToUse) {
-      import_ui_builder_utils10.logger.error(
-        LOG_SYSTEM,
-        "No config available for onWalletConnectionChange! Subscription not set."
-      );
-      return () => {
-      };
-    }
-    this.unsubscribe = (0, import_core2.watchAccount)(configToUse, { onChange: callback });
-    import_ui_builder_utils10.logger.info(
+    __publicField(this, "walletConnectProjectId");
+    this.walletConnectProjectId = walletConnectProjectIdFromAppConfig;
+    import_ui_builder_utils15.logger.info(
       LOG_SYSTEM,
-      "watchAccount subscription established/re-established using config:",
-      configToUse === this.activeWagmiConfig ? "activeExternal" : "defaultInstance"
+      "Constructor called. Initial anticipated kitName:",
+      initialUiKitConfig?.kitName
+    );
+    this.initialized = true;
+    import_ui_builder_utils15.logger.info(
+      LOG_SYSTEM,
+      "WagmiWalletImplementation instance initialized (Wagmi config creation deferred)."
     );
-    return this.unsubscribe;
   }
-  // Methods that perform actions should use the most current activeWagmiConfig
   /**
-   * Gets the Viem Wallet Client for the currently connected account and chain, using the active Wagmi config.
-   * @returns A Promise resolving to the Viem WalletClient or null if not connected or config not active.
+   * Sets the externally determined, currently active WagmiConfig instance.
+   * This is typically called by EvmUiKitManager after it has resolved the appropriate
+   * config for the selected UI kit (e.g., RainbowKit's config or a default custom config).
+   * @param config - The Wagmi Config object to set as active, or null to clear it.
    */
-  async getWalletClient() {
-    if (!this.initialized || !this.activeWagmiConfig) {
-      import_ui_builder_utils10.logger.warn(
+  setActiveWagmiConfig(config) {
+    import_ui_builder_utils15.logger.info(
+      LOG_SYSTEM,
+      "setActiveWagmiConfig called with config:",
+      config ? "Valid Config" : "Null"
+    );
+    this.activeWagmiConfig = config;
+    if (this.unsubscribe) {
+      import_ui_builder_utils15.logger.warn(
         LOG_SYSTEM,
-        "getWalletClient: Not initialized or no activeWagmiConfig. Returning null."
+        "setActiveWagmiConfig: Active WagmiConfig instance has changed. Existing direct watchAccount subscription (via onWalletConnectionChange) may be stale and operating on an old config instance."
       );
-      return null;
     }
-    const accountStatus = (0, import_core2.getAccount)(this.activeWagmiConfig);
-    if (!accountStatus.isConnected || !accountStatus.chainId || !accountStatus.address) return null;
-    return (0, import_core2.getWalletClient)(this.activeWagmiConfig, {
-      chainId: accountStatus.chainId,
-      account: accountStatus.address
-    });
   }
   /**
-   * Gets the Viem Public Client for the currently connected chain, using the active Wagmi config.
-   * Note: Direct public client retrieval from WagmiConfig is complex in v2. This is a placeholder.
-   * Prefer using Wagmi actions like readContract, simulateContract which use the public client internally.
-   * @returns A Promise resolving to the Viem PublicClient or null.
+   * Creates a default WagmiConfig instance on demand.
+   * This configuration includes standard connectors (injected, MetaMask, Safe)
+   * and WalletConnect if a project ID is available.
+   * Used as a fallback or for 'custom' UI kit mode.
+   * @returns A Wagmi Config object.
    */
-  async getPublicClient() {
-    if (!this.initialized || !this.activeWagmiConfig) {
-      import_ui_builder_utils10.logger.warn(
-        LOG_SYSTEM,
-        "getPublicClient: Not initialized or no activeWagmiConfig. Returning null."
-      );
-      return null;
-    }
-    const accountStatus = (0, import_core2.getAccount)(this.activeWagmiConfig);
-    const currentChainId = accountStatus.chainId;
-    if (!currentChainId) {
-      import_ui_builder_utils10.logger.warn(
+  createDefaultConfig() {
+    const baseConnectors = [(0, import_connectors.injected)(), (0, import_connectors.metaMask)(), (0, import_connectors.safe)()];
+    if (this.walletConnectProjectId?.trim()) {
+      baseConnectors.push((0, import_connectors.walletConnect)({ projectId: this.walletConnectProjectId }));
+      import_ui_builder_utils15.logger.info(LOG_SYSTEM, "WalletConnect connector added to DEFAULT config.");
+    } else {
+      import_ui_builder_utils15.logger.warn(
         LOG_SYSTEM,
-        "getPublicClient: No connected chainId available from accountStatus. Returning null."
+        "WalletConnect Project ID not provided; WC connector unavailable for DEFAULT config."
       );
-      return null;
     }
+    const transportsConfig = defaultSupportedChains.reduce(
+      (acc, chainDefinition) => {
+        let rpcUrlToUse = chainDefinition.rpcUrls.default?.http?.[0];
+        const appNetworkIdString = viemChainIdToAppNetworkId[chainDefinition.id];
+        if (appNetworkIdString) {
+          let httpRpcOverride = getUserRpcUrl(appNetworkIdString);
+          if (!httpRpcOverride) {
+            const rpcOverrideSetting = import_ui_builder_utils15.appConfigService.getRpcEndpointOverride(appNetworkIdString);
+            if (typeof rpcOverrideSetting === "string") {
+              httpRpcOverride = rpcOverrideSetting;
+            } else if (typeof rpcOverrideSetting === "object") {
+              if ("http" in rpcOverrideSetting && rpcOverrideSetting.http) {
+                httpRpcOverride = rpcOverrideSetting.http;
+              } else if ("url" in rpcOverrideSetting && rpcOverrideSetting.url) {
+                httpRpcOverride = rpcOverrideSetting.url;
+              }
+            }
+          }
+          if (httpRpcOverride) {
+            import_ui_builder_utils15.logger.info(
+              LOG_SYSTEM,
+              `Using overridden RPC for chain ${chainDefinition.name} (default config): ${httpRpcOverride}`
+            );
+            rpcUrlToUse = httpRpcOverride;
+          }
+        }
+        acc[chainDefinition.id] = (0, import_viem3.http)(rpcUrlToUse);
+        return acc;
+      },
+      {}
+    );
     try {
-      const publicClient = (0, import_core2.getPublicClient)(this.activeWagmiConfig, {
-        chainId: currentChainId
+      const defaultConfig2 = (0, import_core2.createConfig)({
+        chains: defaultSupportedChains,
+        connectors: baseConnectors,
+        transports: transportsConfig
       });
-      if (publicClient) {
-        import_ui_builder_utils10.logger.info(
-          LOG_SYSTEM,
-          `getPublicClient: Successfully retrieved public client for chainId ${currentChainId}.`
-        );
-        return publicClient;
-      }
-      import_ui_builder_utils10.logger.warn(
-        LOG_SYSTEM,
-        `getPublicClient: getWagmiCorePublicClient returned undefined/null for chainId ${currentChainId}.`
-      );
-      return null;
+      import_ui_builder_utils15.logger.info(LOG_SYSTEM, "Default Wagmi config created successfully on demand.");
+      return defaultConfig2;
     } catch (error) {
-      import_ui_builder_utils10.logger.error(LOG_SYSTEM, "Error getting public client from wagmi/core:", error);
-      return null;
+      import_ui_builder_utils15.logger.error(LOG_SYSTEM, "Error creating default Wagmi config on demand:", error);
+      return (0, import_core2.createConfig)({
+        chains: [defaultSupportedChains[0]],
+        connectors: [(0, import_connectors.injected)()],
+        transports: { [defaultSupportedChains[0].id]: (0, import_viem3.http)() }
+      });
     }
   }
   /**
-   * Gets the list of available wallet connectors from the active Wagmi config.
-   * @returns A Promise resolving to an array of available connectors.
-   */
-  async getAvailableConnectors() {
-    if (!this.initialized || !this.activeWagmiConfig) return [];
-    return this.activeWagmiConfig.connectors.map((co) => ({ id: co.uid, name: co.name }));
-  }
-  /**
-   * Initiates the connection process for a specific connector using the active Wagmi config.
-   * @param connectorId - The ID of the connector to use.
-   * @returns A Promise with connection result including address and chainId if successful.
-   */
-  async connect(connectorId) {
-    if (!this.initialized || !this.activeWagmiConfig)
-      throw new Error("Wallet not initialized or no active config");
-    const connectorToUse = this.activeWagmiConfig.connectors.find(
-      (cn6) => cn6.id === connectorId || cn6.uid === connectorId
-    );
-    if (!connectorToUse) throw new Error(`Connector ${connectorId} not found`);
-    const res = await (0, import_core2.connect)(this.activeWagmiConfig, { connector: connectorToUse });
-    return { connected: true, address: res.accounts[0], chainId: res.chainId };
-  }
-  /**
-   * Disconnects the currently connected wallet using the active Wagmi config.
-   * @returns A Promise with disconnection result.
-   */
-  async disconnect() {
-    if (!this.initialized || !this.activeWagmiConfig)
-      return { disconnected: false, error: "Wallet not initialized or no active config" };
-    await (0, import_core2.disconnect)(this.activeWagmiConfig);
-    return { disconnected: true };
-  }
-  /**
-   * Prompts the user to switch to the specified network using the active Wagmi config.
-   * @param chainId - The target chain ID to switch to.
-   * @returns A Promise that resolves if the switch is successful, or rejects with an error.
+   * Wrapper function to convert AppConfigService RPC overrides to the format expected by RainbowKit.
+   * @param networkId - The network ID to get RPC override for
+   * @returns RPC configuration in the format expected by RainbowKit
    */
-  async switchNetwork(chainId) {
-    if (!this.initialized || !this.activeWagmiConfig)
-      throw new Error("Wallet not initialized or no active config");
-    await (0, import_core2.switchChain)(this.activeWagmiConfig, { chainId });
-  }
-  // ... (rest of class, ensure all wagmi/core actions use this.activeWagmiConfig if available and appropriate)
-};
-
-// src/wallet/utils/walletImplementationManager.ts
-var walletImplementationInstance;
-var walletImplementationPromise;
-var LOG_SYSTEM2 = "EvmWalletImplementationManager";
-async function getEvmWalletImplementation() {
-  if (walletImplementationInstance) {
-    return walletImplementationInstance;
-  }
-  if (walletImplementationPromise) {
-    return walletImplementationPromise;
-  }
-  walletImplementationPromise = (async () => {
-    try {
-      import_ui_builder_utils11.logger.info(LOG_SYSTEM2, "Initializing WagmiWalletImplementation singleton (async)... ");
-      const initialUiKitConfig = import_ui_builder_utils11.appConfigService.getTypedNestedConfig(
-        "walletui",
-        "config"
-      );
-      const wcProjectId = import_ui_builder_utils11.appConfigService.getGlobalServiceParam("walletconnect", "projectId");
-      const instance = new WagmiWalletImplementation(wcProjectId, initialUiKitConfig);
-      import_ui_builder_utils11.logger.info(LOG_SYSTEM2, "WagmiWalletImplementation singleton created (async).");
-      walletImplementationInstance = instance;
-      return instance;
-    } catch (error) {
-      import_ui_builder_utils11.logger.error(LOG_SYSTEM2, "Failed to initialize WagmiWalletImplementation (async):", error);
-      const fallbackInstance = new WagmiWalletImplementation();
-      walletImplementationInstance = fallbackInstance;
-      return fallbackInstance;
-    }
-  })();
-  return walletImplementationPromise;
-}
-function getInitializedEvmWalletImplementation() {
-  if (!walletImplementationInstance) {
-    import_ui_builder_utils11.logger.warn(
-      LOG_SYSTEM2,
-      "getInitializedEvmWalletImplementation called before instance was ready."
-    );
-  }
-  return walletImplementationInstance;
-}
-
-// src/wallet/evmUiKitManager.ts
-var initialState = {
-  currentFullUiKitConfig: null,
-  wagmiConfig: null,
-  kitProviderComponent: null,
-  isKitAssetsLoaded: false,
-  isInitializing: false,
-  error: null
-};
-var state = { ...initialState };
-var listeners = /* @__PURE__ */ new Set();
-function notifyListeners() {
-  listeners.forEach((listener) => {
-    try {
-      listener();
-    } catch (error) {
-      import_ui_builder_utils13.logger.error("EvmUiKitManager", "Error in listener:", error);
+  getRpcOverrideForRainbowKit(networkId) {
+    const userRpcUrl = getUserRpcUrl(networkId);
+    if (userRpcUrl) {
+      return { http: userRpcUrl };
     }
-  });
-}
-function subscribe(listener) {
-  listeners.add(listener);
-  return () => {
-    listeners.delete(listener);
-  };
-}
-function getState() {
-  return { ...state };
-}
-async function configure(newFullUiKitConfig) {
-  import_ui_builder_utils13.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 = null;
-  const evmImpl = await getEvmWalletImplementation();
-  try {
-    if (newKitName === "rainbowkit") {
-      if (kitChanged || !state.kitProviderComponent || !state.isKitAssetsLoaded) {
-        import_ui_builder_utils13.logger.info("EvmUiKitManager:configure", "Ensuring RainbowKit assets are loaded...");
-        const { ensureRainbowKitAssetsLoaded: ensureRainbowKitAssetsLoaded2 } = await Promise.resolve().then(() => (init_rainbowkitAssetManager(), rainbowkitAssetManager_exports));
-        const rkAssets = await ensureRainbowKitAssetsLoaded2();
-        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);
-      import_ui_builder_utils13.logger.info("EvmUiKitManager:configure", "WagmiConfig for RainbowKit obtained.");
-    } else if (newKitName === "custom" || !newKitName) {
-      newWagmiConfigAttempt = await evmImpl.getActiveConfigForManager(newFullUiKitConfig);
-      import_ui_builder_utils13.logger.info("EvmUiKitManager:configure", "ActiveConfig for custom/default obtained.");
-      if (kitChanged) {
-        state.kitProviderComponent = null;
-        state.isKitAssetsLoaded = false;
+    const rpcOverrideSetting = import_ui_builder_utils15.appConfigService.getRpcEndpointOverride(networkId);
+    if (typeof rpcOverrideSetting === "string") {
+      return rpcOverrideSetting;
+    } else if (typeof rpcOverrideSetting === "object" && rpcOverrideSetting !== null) {
+      if ("url" in rpcOverrideSetting && typeof rpcOverrideSetting.url === "string") {
+        return {
+          http: rpcOverrideSetting.url
+        };
+      } else if ("http" in rpcOverrideSetting || "ws" in rpcOverrideSetting) {
+        const config = rpcOverrideSetting;
+        return {
+          http: config.http,
+          ws: config.ws
+        };
       }
-    } else {
-      import_ui_builder_utils13.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}`);
-      import_ui_builder_utils13.logger.error("EvmUiKitManager:configure", state.error.message);
     }
-  } catch (err) {
-    import_ui_builder_utils13.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;
-    import_ui_builder_utils13.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();
-  }
-}
-var evmUiKitManager = {
-  getState,
-  subscribe,
-  configure
-};
-
-// src/wallet/components/EvmWalletUiRoot.tsx
-var import_jsx_runtime7 = require("react/jsx-runtime");
-var stableQueryClient = new import_react_query.QueryClient();
-var minimalDefaultWagmiConfig = (0, import_core3.createConfig)({
-  chains: [import_chains3.mainnet],
-  // At least one chain is required in wagmi v2.20+
-  connectors: [],
-  // Empty connectors array
-  transports: {
-    [import_chains3.mainnet.id]: (0, import_core3.http)()
-    // Basic HTTP transport for the default chain
+    return void 0;
   }
-});
-var EvmWalletUiRoot = ({ children }) => {
-  const [managerState, setManagerState] = (0, import_react9.useState)(
-    evmUiKitManager.getState()
-  );
-  (0, import_react9.useEffect)(() => {
-    const handleStateChange = () => {
-      setManagerState(evmUiKitManager.getState());
-    };
-    const unsubscribe = evmUiKitManager.subscribe(handleStateChange);
-    handleStateChange();
-    return unsubscribe;
-  }, []);
-  const queryClient = (0, import_react9.useMemo)(() => stableQueryClient, []);
-  const {
-    wagmiConfig,
-    kitProviderComponent,
-    isKitAssetsLoaded,
-    currentFullUiKitConfig,
-    isInitializing,
-    error
-  } = managerState;
-  const configForWagmiProvider = wagmiConfig || minimalDefaultWagmiConfig;
-  const isWagmiContextEffectivelyReady = !!wagmiConfig && !error;
-  let finalChildren = children;
-  if (isWagmiContextEffectivelyReady && currentFullUiKitConfig?.kitName === "rainbowkit" && kitProviderComponent && isKitAssetsLoaded) {
-    const DynKitProvider = kitProviderComponent;
-    const kitConfig = currentFullUiKitConfig.kitConfig || {};
-    const providerProps = kitConfig.providerProps || {};
-    import_ui_builder_utils14.logger.info(
-      "EvmWalletUiRoot",
-      "Wrapping children with dynamically loaded KitProvider (RainbowKit)."
+  /**
+   * Retrieves or creates the WagmiConfig specifically for RainbowKit.
+   * This delegates to `getWagmiConfigForRainbowKit` service which handles caching
+   * and uses RainbowKit's `getDefaultConfig`.
+   * @param currentAdapterUiKitConfig - The fully resolved UI kit configuration for the adapter.
+   * @returns A Promise resolving to the RainbowKit-specific Wagmi Config object, or null if creation fails or not RainbowKit.
+   */
+  async getConfigForRainbowKit(currentAdapterUiKitConfig) {
+    if (!this.initialized) {
+      import_ui_builder_utils15.logger.error(
+        LOG_SYSTEM,
+        "getConfigForRainbowKit called before implementation initialization."
+      );
+      return null;
+    }
+    if (currentAdapterUiKitConfig?.kitName !== "rainbowkit") {
+      import_ui_builder_utils15.logger.warn(
+        LOG_SYSTEM,
+        "getConfigForRainbowKit called, but kitName is not rainbowkit. Returning null."
+      );
+      return null;
+    }
+    import_ui_builder_utils15.logger.info(
+      LOG_SYSTEM,
+      "getConfigForRainbowKit: Kit is RainbowKit. Proceeding to create/get config. CurrentAdapterUiKitConfig:",
+      currentAdapterUiKitConfig
     );
-    finalChildren = /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(DynKitProvider, { ...providerProps, children });
-  } else if (currentFullUiKitConfig?.kitName === "rainbowkit" && !isWagmiContextEffectivelyReady) {
-    import_ui_builder_utils14.logger.info(
-      "EvmWalletUiRoot",
-      "RainbowKit configured, but context or assets not ready. Button may show its loading/error state."
+    const rainbowKitWagmiConfig = await getWagmiConfigForRainbowKit(
+      currentAdapterUiKitConfig,
+      defaultSupportedChains,
+      viemChainIdToAppNetworkId,
+      this.getRpcOverrideForRainbowKit.bind(this)
     );
+    if (rainbowKitWagmiConfig) {
+      import_ui_builder_utils15.logger.info(LOG_SYSTEM, "Returning RainbowKit-specific Wagmi config for provider.");
+      return rainbowKitWagmiConfig;
+    }
+    import_ui_builder_utils15.logger.warn(LOG_SYSTEM, "RainbowKit specific Wagmi config creation failed.");
+    return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_wagmi.WagmiProvider, { config: configForWagmiProvider, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_query.QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(WagmiProviderInitializedContext.Provider, { value: isWagmiContextEffectivelyReady, children: [
-    finalChildren,
-    isInitializing && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
-      "div",
-      {
-        style: {
-          position: "fixed",
-          top: "10px",
-          right: "10px",
-          background: "rgba(0,0,0,0.1)",
-          padding: "5px",
-          borderRadius: "3px",
-          fontSize: "0.8em"
-        },
-        children: "Updating network..."
-      }
-    ),
-    error && !wagmiConfig && /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
-      "div",
-      {
-        style: {
-          position: "fixed",
-          bottom: "10px",
-          left: "10px",
-          background: "red",
-          color: "white",
-          padding: "10px"
-        },
-        children: [
-          "Error initializing wallet provider: ",
-          error.message
-        ]
-      }
-    )
-  ] }) }) });
-};
-
-// src/wallet/hooks/facade-hooks.ts
-var import_wagmi2 = require("wagmi");
-var evmFacadeHooks = {
-  useAccount: import_wagmi2.useAccount,
-  useConnect: import_wagmi2.useConnect,
-  useDisconnect: import_wagmi2.useDisconnect,
-  useSwitchChain: import_wagmi2.useSwitchChain,
-  useChainId: import_wagmi2.useChainId,
-  useChains: import_wagmi2.useChains,
-  useBalance: import_wagmi2.useBalance,
-  useSendTransaction: import_wagmi2.useSendTransaction,
-  useWaitForTransactionReceipt: import_wagmi2.useWaitForTransactionReceipt,
-  useSignMessage: import_wagmi2.useSignMessage,
-  useSignTypedData: import_wagmi2.useSignTypedData
-};
-
-// src/wallet/rainbowkit/config-generator.ts
-function generateRainbowKitConfigFile(userConfig) {
-  const config = userConfig || {};
-  const appName = config.appName || "My RainbowKit App";
-  const learnMoreUrl = config.learnMoreUrl || "https://openzeppelin.com";
-  const projectId = config.projectId || "YOUR_PROJECT_ID";
-  const appInfoLines = [`appName: '${appName}'`];
-  if (learnMoreUrl) {
-    appInfoLines.push(`learnMoreUrl: '${learnMoreUrl}'`);
-  }
-  const appInfoContent = appInfoLines.join(",\n      ");
-  const fileContent = `// RainbowKit configuration for your exported application
-// This file is used ONLY in the exported app, not in the builder app preview
-
-// Uncomment imports as needed:
-// import { darkTheme, lightTheme } from '@rainbow-me/rainbowkit';
-
-const rainbowKitAppConfig = {
-  wagmiParams: {
-    appName: '${appName}',
-    projectId: '${projectId}', // Get yours at https://cloud.walletconnect.com
-    
-    // Additional options:
-    // ssr: true,
-    // wallets: [...],
-  },
-  providerProps: {
-    appInfo: {
-      ${appInfoContent}
-    },
-    
-    // UI customization - all features work in exported apps:
-    // theme: darkTheme(),
-    // modalSize: 'compact',
-    // showRecentTransactions: true,
-    // coolMode: true,
-  },
-};
-
-export default rainbowKitAppConfig;`;
-  return fileContent;
-}
-
-// src/wallet/rainbowkit/export-service.ts
-function generateRainbowKitExportables(uiKitConfig2) {
-  const filePath = "src/config/wallet/rainbowkit.config.ts";
-  const content = uiKitConfig2.customCode || generateRainbowKitConfigFile(uiKitConfig2.kitConfig);
-  return { [filePath]: content };
-}
-
-// src/wallet/services/configResolutionService.ts
-var import_ui_builder_utils18 = require("@openzeppelin/ui-builder-utils");
-
-// src/wallet/utils.ts
-var import_ui_builder_utils17 = require("@openzeppelin/ui-builder-utils");
-
-// src/wallet/utils/uiKitService.ts
-var import_ui_builder_utils16 = require("@openzeppelin/ui-builder-utils");
-
-// src/wallet/utils/filterWalletComponents.ts
-var import_ui_builder_types = require("@openzeppelin/ui-builder-types");
-var import_ui_builder_utils15 = require("@openzeppelin/ui-builder-utils");
-function filterWalletComponents(allPossibleComponents, exclusions, kitName = "custom") {
-  import_ui_builder_utils15.logger.debug(
-    "filterWalletComponents",
-    `Filtering components for kit: ${kitName}. Exclusions: ${exclusions.join(", ")}.`
-  );
-  if (!allPossibleComponents || Object.keys(allPossibleComponents).length === 0) {
-    import_ui_builder_utils15.logger.debug("filterWalletComponents", `No components provided to filter for kit: ${kitName}.`);
-    return void 0;
+  /**
+   * Determines and returns the WagmiConfig to be used by EvmUiKitManager during its configuration process.
+   * If RainbowKit is specified in the passed uiKitConfig, it attempts to get its specific config.
+   * Otherwise, it falls back to creating/returning a default instance config.
+   * @param uiKitConfig - The fully resolved UiKitConfiguration that the manager is currently processing.
+   * @returns A Promise resolving to the determined Wagmi Config object.
+   */
+  async getActiveConfigForManager(uiKitConfig2) {
+    if (!this.initialized) {
+      import_ui_builder_utils15.logger.error(
+        LOG_SYSTEM,
+        "getActiveConfigForManager called before initialization! Creating fallback."
+      );
+      return (0, import_core2.createConfig)({
+        chains: [defaultSupportedChains[0]],
+        transports: { [defaultSupportedChains[0].id]: (0, import_viem3.http)() }
+      });
+    }
+    if (uiKitConfig2?.kitName === "rainbowkit") {
+      const rkConfig = await this.getConfigForRainbowKit(uiKitConfig2);
+      if (rkConfig) return rkConfig;
+      import_ui_builder_utils15.logger.warn(
+        LOG_SYSTEM,
+        "getActiveConfigForManager: RainbowKit config failed, falling back to default."
+      );
+    }
+    this.defaultInstanceConfig = this.createDefaultConfig();
+    return this.defaultInstanceConfig;
   }
-  if (exclusions.length === 0) {
-    import_ui_builder_utils15.logger.debug(
-      "filterWalletComponents",
-      `Providing all components for kit: ${kitName}.`,
-      allPossibleComponents
+  /**
+   * @deprecated Prefer using methods that rely on the externally set `activeWagmiConfig`
+   * or methods that determine contextually appropriate config like `getActiveConfigForManager` (for manager use)
+   * or ensure `activeWagmiConfig` is set before calling wagmi actions.
+   * This method returns the internally cached default config or the active one if set.
+   * @returns The current default or active Wagmi Config object.
+   */
+  getConfig() {
+    import_ui_builder_utils15.logger.warn(
+      LOG_SYSTEM,
+      "getConfig() is deprecated. Internal calls should use activeWagmiConfig if set, or ensure default is created."
     );
-    return allPossibleComponents;
+    if (this.activeWagmiConfig) return this.activeWagmiConfig;
+    if (!this.defaultInstanceConfig) {
+      this.defaultInstanceConfig = this.createDefaultConfig();
+    }
+    return this.defaultInstanceConfig;
   }
-  const filteredComponents = {};
-  let componentCount = 0;
-  for (const key in allPossibleComponents) {
-    const componentKey = key;
-    if (!exclusions.includes(componentKey)) {
-      if (allPossibleComponents[componentKey]) {
-        filteredComponents[componentKey] = allPossibleComponents[componentKey];
-        componentCount++;
-      }
+  /**
+   * Gets the current wallet connection status (isConnected, address, chainId, etc.).
+   * This is a synchronous operation and uses the `activeWagmiConfig` if set by `EvmUiKitManager`,
+   * otherwise falls back to the default instance config (created on demand).
+   * For UI reactivity to connection changes, `onWalletConnectionChange` or derived hooks are preferred.
+   * @returns The current account status from Wagmi.
+   */
+  getWalletConnectionStatus() {
+    import_ui_builder_utils15.logger.debug(LOG_SYSTEM, "getWalletConnectionStatus called.");
+    const configToUse = this.activeWagmiConfig || this.defaultInstanceConfig || (this.defaultInstanceConfig = this.createDefaultConfig());
+    if (!configToUse) {
+      import_ui_builder_utils15.logger.error(LOG_SYSTEM, "No config available for getWalletConnectionStatus!");
+      return {
+        isConnected: false,
+        isConnecting: false,
+        isDisconnected: true,
+        isReconnecting: false,
+        status: "disconnected",
+        address: void 0,
+        addresses: void 0,
+        chainId: void 0,
+        chain: void 0,
+        connector: void 0
+      };
     }
+    return (0, import_core2.getAccount)(configToUse);
   }
-  if (componentCount > 0) {
-    import_ui_builder_utils15.logger.debug(
-      "filterWalletComponents",
-      `Providing filtered components for kit: ${kitName} after exclusions (${exclusions.join(", ")}).`,
-      filteredComponents
+  /**
+   * Subscribes to account and connection status changes from Wagmi.
+   * The subscription is bound to the `activeWagmiConfig` if available at the time of call,
+   * otherwise to the default instance config. If `activeWagmiConfig` changes later,
+   * this specific subscription might become stale (see warning in `setActiveWagmiConfig`).
+   * @param callback - Function to call when connection status changes.
+   * @returns A function to unsubscribe from the changes.
+   */
+  onWalletConnectionChange(callback) {
+    if (!this.initialized) {
+      import_ui_builder_utils15.logger.warn(LOG_SYSTEM, "onWalletConnectionChange called before initialization. No-op.");
+      return () => {
+      };
+    }
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      import_ui_builder_utils15.logger.debug(LOG_SYSTEM, "Previous watchAccount unsubscribed.");
+    }
+    const configToUse = this.activeWagmiConfig || this.defaultInstanceConfig || (this.defaultInstanceConfig = this.createDefaultConfig());
+    if (!configToUse) {
+      import_ui_builder_utils15.logger.error(
+        LOG_SYSTEM,
+        "No config available for onWalletConnectionChange! Subscription not set."
+      );
+      return () => {
+      };
+    }
+    this.unsubscribe = (0, import_core2.watchAccount)(configToUse, { onChange: callback });
+    import_ui_builder_utils15.logger.info(
+      LOG_SYSTEM,
+      "watchAccount subscription established/re-established using config:",
+      configToUse === this.activeWagmiConfig ? "activeExternal" : "defaultInstance"
     );
-    return filteredComponents;
+    return this.unsubscribe;
   }
-  import_ui_builder_utils15.logger.debug("filterWalletComponents", `All components were excluded for kit: ${kitName}.`);
-  return void 0;
-}
-function getComponentExclusionsFromConfig(kitConfig) {
-  if (kitConfig && typeof kitConfig === "object" && "components" in kitConfig) {
-    const componentsCfg = kitConfig.components;
-    if (componentsCfg && typeof componentsCfg === "object" && "exclude" in componentsCfg && Array.isArray(componentsCfg.exclude)) {
-      return componentsCfg.exclude.filter(
-        (key) => typeof key === "string" && import_ui_builder_types.ECOSYSTEM_WALLET_COMPONENT_KEYS.includes(key)
+  // Methods that perform actions should use the most current activeWagmiConfig
+  /**
+   * Gets the Viem Wallet Client for the currently connected account and chain, using the active Wagmi config.
+   * @returns A Promise resolving to the Viem WalletClient or null if not connected or config not active.
+   */
+  async getWalletClient() {
+    if (!this.initialized || !this.activeWagmiConfig) {
+      import_ui_builder_utils15.logger.warn(
+        LOG_SYSTEM,
+        "getWalletClient: Not initialized or no activeWagmiConfig. Returning null."
       );
+      return null;
     }
+    const accountStatus = (0, import_core2.getAccount)(this.activeWagmiConfig);
+    if (!accountStatus.isConnected || !accountStatus.chainId || !accountStatus.address) return null;
+    return (0, import_core2.getWalletClient)(this.activeWagmiConfig, {
+      chainId: accountStatus.chainId,
+      account: accountStatus.address
+    });
   }
-  return [];
-}
-
-// src/wallet/utils/uiKitService.ts
-function getResolvedWalletComponents(uiKitConfiguration) {
-  import_ui_builder_utils16.logger.debug(
-    "uiKitService:getResolvedWalletComponents",
-    "Received uiKitConfiguration:",
-    JSON.stringify(uiKitConfiguration)
-  );
-  const currentKitName = uiKitConfiguration.kitName || "custom";
-  if (currentKitName === "none") {
-    import_ui_builder_utils16.logger.info(
-      "uiKitService",
-      'UI Kit set to "none" for getResolvedWalletComponents, not providing wallet components.'
+  /**
+   * Gets the Viem Public Client for the currently connected chain, using the active Wagmi config.
+   * Note: Direct public client retrieval from WagmiConfig is complex in v2. This is a placeholder.
+   * Prefer using Wagmi actions like readContract, simulateContract which use the public client internally.
+   * @returns A Promise resolving to the Viem PublicClient or null.
+   */
+  async getPublicClient() {
+    if (!this.initialized || !this.activeWagmiConfig) {
+      import_ui_builder_utils15.logger.warn(
+        LOG_SYSTEM,
+        "getPublicClient: Not initialized or no activeWagmiConfig. Returning null."
+      );
+      return null;
+    }
+    const accountStatus = (0, import_core2.getAccount)(this.activeWagmiConfig);
+    const currentChainId = accountStatus.chainId;
+    if (!currentChainId) {
+      import_ui_builder_utils15.logger.warn(
+        LOG_SYSTEM,
+        "getPublicClient: No connected chainId available from accountStatus. Returning null."
+      );
+      return null;
+    }
+    try {
+      const publicClient = (0, import_core2.getPublicClient)(this.activeWagmiConfig, {
+        chainId: currentChainId
+      });
+      if (publicClient) {
+        import_ui_builder_utils15.logger.info(
+          LOG_SYSTEM,
+          `getPublicClient: Successfully retrieved public client for chainId ${currentChainId}.`
+        );
+        return publicClient;
+      }
+      import_ui_builder_utils15.logger.warn(
+        LOG_SYSTEM,
+        `getPublicClient: getWagmiCorePublicClient returned undefined/null for chainId ${currentChainId}.`
+      );
+      return null;
+    } catch (error) {
+      import_ui_builder_utils15.logger.error(LOG_SYSTEM, "Error getting public client from wagmi/core:", error);
+      return null;
+    }
+  }
+  /**
+   * Gets the list of available wallet connectors from the active Wagmi config.
+   * @returns A Promise resolving to an array of available connectors.
+   */
+  async getAvailableConnectors() {
+    if (!this.initialized || !this.activeWagmiConfig) return [];
+    return this.activeWagmiConfig.connectors.map((co) => ({ id: co.uid, name: co.name }));
+  }
+  /**
+   * Initiates the connection process for a specific connector using the active Wagmi config.
+   * @param connectorId - The ID of the connector to use.
+   * @returns A Promise with connection result including address and chainId if successful.
+   */
+  async connect(connectorId) {
+    if (!this.initialized || !this.activeWagmiConfig)
+      throw new Error("Wallet not initialized or no active config");
+    const connectorToUse = this.activeWagmiConfig.connectors.find(
+      (cn6) => cn6.id === connectorId || cn6.uid === connectorId
     );
-    return void 0;
+    if (!connectorToUse) throw new Error(`Connector ${connectorId} not found`);
+    const res = await (0, import_core2.connect)(this.activeWagmiConfig, { connector: connectorToUse });
+    return { connected: true, address: res.accounts[0], chainId: res.chainId };
   }
-  const exclusions = getComponentExclusionsFromConfig(uiKitConfiguration.kitConfig);
-  import_ui_builder_utils16.logger.debug(
-    "uiKitService",
-    `Extracted component exclusions for ${currentKitName}: ${exclusions.join(", ") || "none"}.`
-  );
-  if (currentKitName === "custom") {
-    const allCustomComponents = {
-      ConnectButton: CustomConnectButton,
-      AccountDisplay: CustomAccountDisplay,
-      NetworkSwitcher: CustomNetworkSwitcher
-    };
-    return filterWalletComponents(allCustomComponents, exclusions, currentKitName);
+  /**
+   * Disconnects the currently connected wallet using the active Wagmi config.
+   * @returns A Promise with disconnection result.
+   */
+  async disconnect() {
+    if (!this.initialized || !this.activeWagmiConfig)
+      return { disconnected: false, error: "Wallet not initialized or no active config" };
+    await (0, import_core2.disconnect)(this.activeWagmiConfig);
+    return { disconnected: true };
   }
-  if (currentKitName === "rainbowkit") {
-    const validation = validateRainbowKitConfig(uiKitConfiguration.kitConfig);
-    if (!validation.isValid) {
-      import_ui_builder_utils16.logger.warn(
-        "uiKitService",
-        `Invalid RainbowKit configuration for components: ${validation.error}. No components provided.`
-      );
-      return void 0;
-    }
-    const rainbowKitComponents = createRainbowKitComponents();
-    import_ui_builder_utils16.logger.info("uiKitService", "Providing RainbowKit components.");
-    return filterWalletComponents(rainbowKitComponents, exclusions, currentKitName);
+  /**
+   * Prompts the user to switch to the specified network using the active Wagmi config.
+   * @param chainId - The target chain ID to switch to.
+   * @returns A Promise that resolves if the switch is successful, or rejects with an error.
+   */
+  async switchNetwork(chainId) {
+    if (!this.initialized || !this.activeWagmiConfig)
+      throw new Error("Wallet not initialized or no active config");
+    await (0, import_core2.switchChain)(this.activeWagmiConfig, { chainId });
   }
-  import_ui_builder_utils16.logger.warn(
-    "uiKitService",
-    `UI Kit "${currentKitName}" for getResolvedWalletComponents not explicitly supported. No components provided.`
-  );
-  return void 0;
-}
+  // ... (rest of class, ensure all wagmi/core actions use this.activeWagmiConfig if available and appropriate)
+};
 
-// src/wallet/utils.ts
-function getResolvedWalletComponents2(uiKitConfig2) {
-  return getResolvedWalletComponents(uiKitConfig2);
-}
-async function resolveAndInitializeKitConfig(kitName, programmaticKitConfig, loadConfigModule) {
-  import_ui_builder_utils17.logger.debug(
-    "resolveAndInitializeKitConfig",
-    `Resolving native config for kit: ${kitName || "none"}`,
-    {
-      hasProgrammaticKitConfig: !!programmaticKitConfig,
-      hasLoadConfigModule: !!loadConfigModule
-    }
-  );
-  let userNativeConfig = null;
-  if (kitName && kitName !== "custom" && kitName !== "none" && loadConfigModule) {
-    const conventionalConfigPath = `./config/wallet/${kitName}.config.ts`;
+// src/wallet/utils/walletImplementationManager.ts
+var walletImplementationInstance;
+var walletImplementationPromise;
+var LOG_SYSTEM2 = "EvmWalletImplementationManager";
+async function getEvmWalletImplementation() {
+  if (walletImplementationInstance) {
+    return walletImplementationInstance;
+  }
+  if (walletImplementationPromise) {
+    return walletImplementationPromise;
+  }
+  walletImplementationPromise = (async () => {
     try {
-      userNativeConfig = await loadConfigModule(conventionalConfigPath);
-    } catch (error) {
-      import_ui_builder_utils17.logger.warn(
-        "resolveAndInitializeKitConfig",
-        `Call to load native config for ${kitName} from ${conventionalConfigPath} failed. Error:`,
-        error
+      import_ui_builder_utils16.logger.info(LOG_SYSTEM2, "Initializing WagmiWalletImplementation singleton (async)... ");
+      const initialUiKitConfig = import_ui_builder_utils16.appConfigService.getTypedNestedConfig(
+        "walletui",
+        "config"
       );
+      const wcProjectId = import_ui_builder_utils16.appConfigService.getGlobalServiceParam("walletconnect", "projectId");
+      const instance = new WagmiWalletImplementation(wcProjectId, initialUiKitConfig);
+      import_ui_builder_utils16.logger.info(LOG_SYSTEM2, "WagmiWalletImplementation singleton created (async).");
+      walletImplementationInstance = instance;
+      return instance;
+    } catch (error) {
+      import_ui_builder_utils16.logger.error(LOG_SYSTEM2, "Failed to initialize WagmiWalletImplementation (async):", error);
+      const fallbackInstance = new WagmiWalletImplementation();
+      walletImplementationInstance = fallbackInstance;
+      return fallbackInstance;
     }
+  })();
+  return walletImplementationPromise;
+}
+function getInitializedEvmWalletImplementation() {
+  if (!walletImplementationInstance) {
+    import_ui_builder_utils16.logger.warn(
+      LOG_SYSTEM2,
+      "getInitializedEvmWalletImplementation called before instance was ready."
+    );
   }
-  if (userNativeConfig && programmaticKitConfig) {
-    const mergedConfig = { ...userNativeConfig, ...programmaticKitConfig };
-    return mergedConfig;
-  } else if (userNativeConfig) {
-    return userNativeConfig;
-  } else if (programmaticKitConfig) {
-    return programmaticKitConfig;
-  }
-  import_ui_builder_utils17.logger.debug(
-    "resolveAndInitializeKitConfig",
-    `No native or programmatic kitConfig provided for ${kitName || "none"}. Returning null.`
-  );
-  return null;
+  return walletImplementationInstance;
 }
 
-// src/wallet/services/configResolutionService.ts
-async function resolveFullUiKitConfiguration(programmaticOverrides, initialAppServiceKitName, currentAppServiceConfig, options) {
-  import_ui_builder_utils18.logger.debug(
-    "configResolutionService:resolveFullUiKitConfiguration",
-    "Starting resolution with:",
-    {
-      programmaticOverrides,
-      initialAppServiceKitName,
-      currentAppServiceConfig,
-      hasLoadNativeCallback: !!options?.loadUiKitNativeConfig,
-      hasCustomCode: !!programmaticOverrides.customCode
+// src/wallet/evmUiKitManager.ts
+var initialState = {
+  currentFullUiKitConfig: null,
+  wagmiConfig: null,
+  kitProviderComponent: null,
+  isKitAssetsLoaded: false,
+  isInitializing: false,
+  error: null
+};
+var state = { ...initialState };
+var listeners = /* @__PURE__ */ new Set();
+function notifyListeners() {
+  listeners.forEach((listener) => {
+    try {
+      listener();
+    } catch (error) {
+      import_ui_builder_utils18.logger.error("EvmUiKitManager", "Error in listener:", error);
     }
-  );
-  const effectiveKitName = programmaticOverrides.kitName || initialAppServiceKitName || currentAppServiceConfig.kitName || "custom";
-  const resolvedUserNativeAndProgrammaticKitConfig = await resolveAndInitializeKitConfig(
-    effectiveKitName,
-    programmaticOverrides.kitConfig,
-    options?.loadUiKitNativeConfig
-  );
-  const finalFullConfig = {
-    kitName: effectiveKitName,
-    kitConfig: {
-      ...currentAppServiceConfig.kitConfig || {},
-      ...resolvedUserNativeAndProgrammaticKitConfig || {}
-      // customCode is NOT applied to runtime config
-    },
-    // Pass through customCode for export purposes only
-    customCode: programmaticOverrides.customCode
+  });
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
   };
-  import_ui_builder_utils18.logger.debug(
-    "configResolutionService:resolveFullUiKitConfiguration",
-    "Resolved finalFullConfig:",
-    finalFullConfig
-  );
-  return finalFullConfig;
 }
-
-// src/abi/transformer.ts
-var import_ui_builder_utils19 = require("@openzeppelin/ui-builder-utils");
-
-// src/types/artifacts.ts
-function isEvmContractArtifacts(obj) {
-  return typeof obj === "object" && obj !== null && typeof obj.contractAddress === "string";
+function getState() {
+  return { ...state };
+}
+async function configure(newFullUiKitConfig) {
+  import_ui_builder_utils18.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 = null;
+  const evmImpl = await getEvmWalletImplementation();
+  try {
+    if (newKitName === "rainbowkit") {
+      if (kitChanged || !state.kitProviderComponent || !state.isKitAssetsLoaded) {
+        import_ui_builder_utils18.logger.info("EvmUiKitManager:configure", "Ensuring RainbowKit assets are loaded...");
+        const { ensureRainbowKitAssetsLoaded: ensureRainbowKitAssetsLoaded2 } = await Promise.resolve().then(() => (init_rainbowkitAssetManager(), rainbowkitAssetManager_exports));
+        const rkAssets = await ensureRainbowKitAssetsLoaded2();
+        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);
+      import_ui_builder_utils18.logger.info("EvmUiKitManager:configure", "WagmiConfig for RainbowKit obtained.");
+    } else if (newKitName === "custom" || !newKitName) {
+      newWagmiConfigAttempt = await evmImpl.getActiveConfigForManager(newFullUiKitConfig);
+      import_ui_builder_utils18.logger.info("EvmUiKitManager:configure", "ActiveConfig for custom/default obtained.");
+      if (kitChanged) {
+        state.kitProviderComponent = null;
+        state.isKitAssetsLoaded = false;
+      }
+    } else {
+      import_ui_builder_utils18.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}`);
+      import_ui_builder_utils18.logger.error("EvmUiKitManager:configure", state.error.message);
+    }
+  } catch (err) {
+    import_ui_builder_utils18.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;
+    import_ui_builder_utils18.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();
+  }
 }
+var evmUiKitManager = {
+  getState,
+  subscribe,
+  configure
+};
 
-// src/utils/artifacts.ts
-function validateAndConvertEvmArtifacts(source) {
-  if (typeof source === "string") {
-    return { contractAddress: source };
+// src/wallet/components/EvmWalletUiRoot.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var stableQueryClient = new import_react_query.QueryClient();
+var minimalDefaultWagmiConfig = (0, import_core3.createConfig)({
+  chains: [import_chains3.mainnet],
+  // At least one chain is required in wagmi v2.20+
+  connectors: [],
+  // Empty connectors array
+  transports: {
+    [import_chains3.mainnet.id]: (0, import_core3.http)()
+    // Basic HTTP transport for the default chain
   }
-  if (!isEvmContractArtifacts(source)) {
-    throw new Error(
-      "Invalid contract artifacts provided. Expected an object with contractAddress property."
+});
+var EvmWalletUiRoot = ({ children }) => {
+  const [managerState, setManagerState] = (0, import_react9.useState)(
+    evmUiKitManager.getState()
+  );
+  (0, import_react9.useEffect)(() => {
+    const handleStateChange = () => {
+      setManagerState(evmUiKitManager.getState());
+    };
+    const unsubscribe = evmUiKitManager.subscribe(handleStateChange);
+    handleStateChange();
+    return unsubscribe;
+  }, []);
+  const queryClient = (0, import_react9.useMemo)(() => stableQueryClient, []);
+  const {
+    wagmiConfig,
+    kitProviderComponent,
+    isKitAssetsLoaded,
+    currentFullUiKitConfig,
+    isInitializing,
+    error
+  } = managerState;
+  const configForWagmiProvider = wagmiConfig || minimalDefaultWagmiConfig;
+  const isWagmiContextEffectivelyReady = !!wagmiConfig && !error;
+  let finalChildren = children;
+  if (isWagmiContextEffectivelyReady && currentFullUiKitConfig?.kitName === "rainbowkit" && kitProviderComponent && isKitAssetsLoaded) {
+    const DynKitProvider = kitProviderComponent;
+    const kitConfig = currentFullUiKitConfig.kitConfig || {};
+    const providerProps = kitConfig.providerProps || {};
+    import_ui_builder_utils19.logger.info(
+      "EvmWalletUiRoot",
+      "Wrapping children with dynamically loaded KitProvider (RainbowKit)."
+    );
+    finalChildren = /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(DynKitProvider, { ...providerProps, children });
+  } else if (currentFullUiKitConfig?.kitName === "rainbowkit" && !isWagmiContextEffectivelyReady) {
+    import_ui_builder_utils19.logger.info(
+      "EvmWalletUiRoot",
+      "RainbowKit configured, but context or assets not ready. Button may show its loading/error state."
     );
   }
-  return source;
-}
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_wagmi.WagmiProvider, { config: configForWagmiProvider, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_query.QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(WagmiProviderInitializedContext.Provider, { value: isWagmiContextEffectivelyReady, children: [
+    finalChildren,
+    isInitializing && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+      "div",
+      {
+        style: {
+          position: "fixed",
+          top: "10px",
+          right: "10px",
+          background: "rgba(0,0,0,0.1)",
+          padding: "5px",
+          borderRadius: "3px",
+          fontSize: "0.8em"
+        },
+        children: "Updating network..."
+      }
+    ),
+    error && !wagmiConfig && /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+      "div",
+      {
+        style: {
+          position: "fixed",
+          bottom: "10px",
+          left: "10px",
+          background: "red",
+          color: "white",
+          padding: "10px"
+        },
+        children: [
+          "Error initializing wallet provider: ",
+          error.message
+        ]
+      }
+    )
+  ] }) }) });
+};
 
-// src/utils/json.ts
-function stringifyWithBigInt(value, space) {
-  const replacer = (_key, val) => {
-    if (typeof val === "bigint") {
-      return val.toString();
-    }
-    return val;
-  };
-  return JSON.stringify(value, replacer, space);
-}
+// src/wallet/hooks/facade-hooks.ts
+var import_wagmi2 = require("wagmi");
+var evmFacadeHooks = {
+  useAccount: import_wagmi2.useAccount,
+  useConnect: import_wagmi2.useConnect,
+  useDisconnect: import_wagmi2.useDisconnect,
+  useSwitchChain: import_wagmi2.useSwitchChain,
+  useChainId: import_wagmi2.useChainId,
+  useChains: import_wagmi2.useChains,
+  useBalance: import_wagmi2.useBalance,
+  useSendTransaction: import_wagmi2.useSendTransaction,
+  useWaitForTransactionReceipt: import_wagmi2.useWaitForTransactionReceipt,
+  useSignMessage: import_wagmi2.useSignMessage,
+  useSignTypedData: import_wagmi2.useSignTypedData
+};
 
-// src/utils/formatting.ts
-function formatMethodName(name) {
-  if (!name) return "";
-  return name.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase()).trim();
-}
-function formatInputName(name, type) {
-  if (!name || name === "") {
-    return `Parameter (${type})`;
+// src/wallet/rainbowkit/config-generator.ts
+function generateRainbowKitConfigFile(userConfig) {
+  const config = userConfig || {};
+  const appName = config.appName || "My RainbowKit App";
+  const learnMoreUrl = config.learnMoreUrl || "https://openzeppelin.com";
+  const projectId = config.projectId || "YOUR_PROJECT_ID";
+  const appInfoLines = [`appName: '${appName}'`];
+  if (learnMoreUrl) {
+    appInfoLines.push(`learnMoreUrl: '${learnMoreUrl}'`);
   }
-  return name.replace(/([A-Z])/g, " $1").replace(/_/g, " ").replace(/^./, (str) => str.toUpperCase()).trim();
-}
+  const appInfoContent = appInfoLines.join(",\n      ");
+  const fileContent = `// RainbowKit configuration for your exported application
+// This file is used ONLY in the exported app, not in the builder app preview
 
-// src/utils/validation.ts
-var import_viem2 = require("viem");
-function isValidEvmAddress(address) {
-  return (0, import_viem2.isAddress)(address);
-}
+// Uncomment imports as needed:
+// import { darkTheme, lightTheme } from '@rainbow-me/rainbowkit';
 
-// src/utils/gas.ts
-var import_viem3 = require("viem");
-var weiToGwei = (wei) => {
-  if (!wei) return void 0;
-  return parseFloat((0, import_viem3.formatGwei)(BigInt(wei)));
-};
-var gweiToWei = (gwei) => {
-  if (!gwei) return void 0;
-  return Number((0, import_viem3.parseGwei)(gwei.toString()));
+const rainbowKitAppConfig = {
+  wagmiParams: {
+    appName: '${appName}',
+    projectId: '${projectId}', // Get yours at https://cloud.walletconnect.com
+    
+    // Additional options:
+    // ssr: true,
+    // wallets: [...],
+  },
+  providerProps: {
+    appInfo: {
+      ${appInfoContent}
+    },
+    
+    // UI customization - all features work in exported apps:
+    // theme: darkTheme(),
+    // modalSize: 'compact',
+    // showRecentTransactions: true,
+    // coolMode: true,
+  },
 };
 
-// src/abi/transformer.ts
-function transformAbiToSchema(abi, contractName, address) {
-  import_ui_builder_utils19.logger.info("transformAbiToSchema", `Transforming ABI to ContractSchema for: ${contractName}`);
-  const functions = [];
-  for (const item of abi) {
-    if (item.type === "function") {
-      const abiFunctionItem = item;
-      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 = {
-    ecosystem: "evm",
-    // This transformer is specific to EVM.
-    name: contractName,
-    address,
-    functions
-  };
-  import_ui_builder_utils19.logger.info(
-    "transformAbiToSchema",
-    `Transformation complete. Found ${contractSchema.functions.length} functions.`
-  );
-  return contractSchema;
-}
-function mapAbiParametersToSchemaParameters(abiParams) {
-  if (!abiParams) {
-    return [];
-  }
-  return abiParams.map((param) => {
-    const schemaParam = {
-      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.
-    };
-    if (param.type.startsWith("tuple") && "components" in param && // Type guard for discriminated union (AbiParameter)
-    param.components && param.components.length > 0) {
-      schemaParam.components = mapAbiParametersToSchemaParameters(
-        param.components
-      );
-    }
-    return schemaParam;
-  });
-}
-function mapSchemaParameterToAbiParameter(param) {
-  if (param.type.startsWith("tuple") && param.components && param.components.length > 0) {
-    return {
-      name: param.name || void 0,
-      // ABI parameter names can be undefined (e.g., for return values).
-      type: param.type,
-      // Cast to satisfy viem's specific tuple type string.
-      // Recursively map nested components back to AbiParameter format.
-      components: param.components.map(mapSchemaParameterToAbiParameter)
-    };
-  }
-  return {
-    name: param.name || void 0,
-    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`.
-  };
+export default rainbowKitAppConfig;`;
+  return fileContent;
 }
-function createAbiFunctionItem(functionDetails) {
-  return {
-    name: functionDetails.name,
-    type: "function",
-    inputs: functionDetails.inputs.map(mapSchemaParameterToAbiParameter),
-    outputs: functionDetails.outputs?.map(mapSchemaParameterToAbiParameter) || [],
-    stateMutability: functionDetails.stateMutability ?? "view"
-  };
+
+// src/wallet/rainbowkit/export-service.ts
+function generateRainbowKitExportables(uiKitConfig2) {
+  const filePath = "src/config/wallet/rainbowkit.config.ts";
+  const content = uiKitConfig2.customCode || generateRainbowKitConfigFile(uiKitConfig2.kitConfig);
+  return { [filePath]: content };
 }
 
-// src/abi/etherscan.ts
+// src/wallet/services/configResolutionService.ts
+var import_ui_builder_utils23 = require("@openzeppelin/ui-builder-utils");
+
+// src/wallet/utils.ts
 var import_ui_builder_utils22 = require("@openzeppelin/ui-builder-utils");
 
-// src/configuration/explorer.ts
+// src/wallet/utils/uiKitService.ts
 var import_ui_builder_utils21 = require("@openzeppelin/ui-builder-utils");
 
-// src/abi/etherscan-v2.ts
+// src/wallet/utils/filterWalletComponents.ts
+var import_ui_builder_types = require("@openzeppelin/ui-builder-types");
 var import_ui_builder_utils20 = require("@openzeppelin/ui-builder-utils");
-var ETHERSCAN_V2_BASE_URL = "https://api.etherscan.io/v2/api";
-function buildV2ApiUrl(chainId, module2, action, params, apiKey) {
-  const url = new URL(ETHERSCAN_V2_BASE_URL);
-  url.searchParams.append("chainid", chainId.toString());
-  url.searchParams.append("module", module2);
-  url.searchParams.append("action", action);
-  Object.entries(params).forEach(([key, value]) => {
-    url.searchParams.append(key, value);
-  });
-  if (apiKey) {
-    url.searchParams.append("apikey", apiKey);
-  }
-  return url.toString();
-}
-function shouldUseV2Api(networkConfig) {
-  if (!networkConfig.supportsEtherscanV2) {
-    return false;
-  }
-  return true;
-}
-async function loadAbiFromEtherscanV2(address, networkConfig) {
-  const explorerConfig = resolveExplorerConfig(networkConfig);
-  const url = buildV2ApiUrl(
-    networkConfig.chainId,
-    "contract",
-    "getabi",
-    { address },
-    explorerConfig.apiKey
+function filterWalletComponents(allPossibleComponents, exclusions, kitName = "custom") {
+  import_ui_builder_utils20.logger.debug(
+    "filterWalletComponents",
+    `Filtering components for kit: ${kitName}. Exclusions: ${exclusions.join(", ")}.`
   );
-  let response;
-  try {
-    import_ui_builder_utils20.logger.info(
-      "loadAbiFromEtherscanV2",
-      `Fetching ABI from Etherscan V2 API for address: ${address} on chain ${networkConfig.chainId}`
-    );
-    response = await fetch(url);
-  } catch (networkError) {
-    import_ui_builder_utils20.logger.error(
-      "loadAbiFromEtherscanV2",
-      `Network error fetching ABI from Explorer V2 API: ${networkError}`
-    );
-    throw new Error(`Network error fetching ABI: ${networkError.message}`);
-  }
-  if (!response.ok) {
-    import_ui_builder_utils20.logger.error(
-      "loadAbiFromEtherscanV2",
-      `Explorer V2 API request failed with status: ${response.status}`
-    );
-    throw new Error(`Explorer V2 API request failed: ${response.status} ${response.statusText}`);
+  if (!allPossibleComponents || Object.keys(allPossibleComponents).length === 0) {
+    import_ui_builder_utils20.logger.debug("filterWalletComponents", `No components provided to filter for kit: ${kitName}.`);
+    return void 0;
   }
-  let apiResult;
-  try {
-    apiResult = await response.json();
-  } catch (jsonError) {
-    import_ui_builder_utils20.logger.error(
-      "loadAbiFromEtherscanV2",
-      `Failed to parse Explorer V2 API response as JSON: ${jsonError}`
+  if (exclusions.length === 0) {
+    import_ui_builder_utils20.logger.debug(
+      "filterWalletComponents",
+      `Providing all components for kit: ${kitName}.`,
+      allPossibleComponents
     );
-    throw new Error("Invalid JSON response received from Explorer V2 API.");
+    return allPossibleComponents;
   }
-  if (apiResult.status !== "1") {
-    import_ui_builder_utils20.logger.warn(
-      "loadAbiFromEtherscanV2",
-      `Explorer V2 API error: Status ${apiResult.status}, Message: ${apiResult.message}, Result: ${apiResult.result}`
-    );
-    if (apiResult.message?.includes("NOTOK")) {
-      if (apiResult.result?.includes("Invalid API Key")) {
-        throw new Error(
-          `Invalid API key for Etherscan V2. Please check your API key configuration.`
-        );
-      }
-      if (apiResult.result?.includes("Contract source code not verified")) {
-        throw new Error(
-          `Contract not verified on ${networkConfig.name} explorer (address: ${address}). ABI not available. You can provide the contract's ABI manually.`
-        );
-      }
-      if (apiResult.result?.includes("Invalid chain")) {
-        throw new Error(
-          `Chain ID ${networkConfig.chainId} is not supported by Etherscan V2 API. Please check if this chain is available.`
-        );
+  const filteredComponents = {};
+  let componentCount = 0;
+  for (const key in allPossibleComponents) {
+    const componentKey = key;
+    if (!exclusions.includes(componentKey)) {
+      if (allPossibleComponents[componentKey]) {
+        filteredComponents[componentKey] = allPossibleComponents[componentKey];
+        componentCount++;
       }
     }
-    throw new Error(`Explorer V2 API Error: ${apiResult.result || apiResult.message}`);
   }
-  const originalAbiString = apiResult.result;
-  let abi;
-  try {
-    abi = JSON.parse(originalAbiString);
-    if (!Array.isArray(abi)) {
-      throw new Error("Parsed ABI from Explorer V2 API is not an array.");
-    }
-  } catch (error) {
-    import_ui_builder_utils20.logger.error(
-      "loadAbiFromEtherscanV2",
-      `Failed to parse ABI JSON string from Explorer V2 API result: ${error}`
+  if (componentCount > 0) {
+    import_ui_builder_utils20.logger.debug(
+      "filterWalletComponents",
+      `Providing filtered components for kit: ${kitName} after exclusions (${exclusions.join(", ")}).`,
+      filteredComponents
     );
-    throw new Error(`Invalid ABI JSON received from Explorer V2 API: ${error.message}`);
+    return filteredComponents;
   }
-  import_ui_builder_utils20.logger.info(
-    "loadAbiFromEtherscanV2",
-    `Successfully parsed ABI for ${networkConfig.name} with ${abi.length} items using V2 API.`
-  );
-  const contractName = `Contract_${address.substring(0, 6)}`;
-  const schema = transformAbiToSchema(abi, contractName, address);
-  return {
-    schema,
-    originalAbi: originalAbiString
-  };
+  import_ui_builder_utils20.logger.debug("filterWalletComponents", `All components were excluded for kit: ${kitName}.`);
+  return void 0;
 }
-async function testEtherscanV2Connection(networkConfig, apiKey) {
-  const startTime = Date.now();
-  const requiresApiKey = networkConfig.requiresExplorerApiKey ?? true;
-  if (requiresApiKey && !apiKey) {
-    return {
-      success: false,
-      error: "API key is required for testing connection to this explorer"
-    };
-  }
-  try {
-    const url = buildV2ApiUrl(networkConfig.chainId, "proxy", "eth_blockNumber", {}, apiKey);
-    const response = await fetch(url);
-    const latency = Date.now() - startTime;
-    if (!response.ok) {
-      return {
-        success: false,
-        error: `HTTP ${response.status}: ${response.statusText}`,
-        latency
-      };
-    }
-    const data = await response.json();
-    if (data.status === "0" && data.message) {
-      if (data.result?.includes("Invalid API Key")) {
-        return {
-          success: false,
-          error: "Invalid API key. Please check your Etherscan API key.",
-          latency
-        };
-      }
-      if (data.result?.includes("Invalid chain")) {
-        return {
-          success: false,
-          error: `Chain ID ${networkConfig.chainId} is not supported by Etherscan V2 API.`,
-          latency
-        };
-      }
-      return {
-        success: false,
-        error: data.result || data.message,
-        latency
-      };
+function getComponentExclusionsFromConfig(kitConfig) {
+  if (kitConfig && typeof kitConfig === "object" && "components" in kitConfig) {
+    const componentsCfg = kitConfig.components;
+    if (componentsCfg && typeof componentsCfg === "object" && "exclude" in componentsCfg && Array.isArray(componentsCfg.exclude)) {
+      return componentsCfg.exclude.filter(
+        (key) => typeof key === "string" && import_ui_builder_types.ECOSYSTEM_WALLET_COMPONENT_KEYS.includes(key)
+      );
     }
-    return {
-      success: true,
-      latency
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Connection test failed",
-      latency: Date.now() - startTime
-    };
   }
+  return [];
 }
 
-// src/configuration/explorer.ts
-function resolveExplorerConfig(networkConfig) {
-  const isV2 = networkConfig.supportsEtherscanV2 && networkConfig.primaryExplorerApiIdentifier === "etherscan-v2";
-  const globalV2ApiKey = isV2 ? import_ui_builder_utils21.appConfigService.getGlobalServiceConfig("etherscanv2")?.apiKey : void 0;
-  const appApiKey = networkConfig.primaryExplorerApiIdentifier ? import_ui_builder_utils21.appConfigService.getExplorerApiKey(networkConfig.primaryExplorerApiIdentifier) : void 0;
-  const userConfig = import_ui_builder_utils21.userExplorerConfigService.getUserExplorerConfig(networkConfig.id);
-  if (userConfig) {
-    import_ui_builder_utils21.logger.info("ExplorerConfig", `Using user-configured explorer for ${networkConfig.name}`);
-    return {
-      // Prefer user overrides when provided
-      explorerUrl: userConfig.explorerUrl ?? networkConfig.explorerUrl,
-      apiUrl: userConfig.apiUrl ?? networkConfig.apiUrl,
-      // If user did not provide an API key, fall back to global V2 key (when applicable)
-      // then to app-configured per-explorer identifier key
-      apiKey: userConfig.apiKey ?? globalV2ApiKey ?? appApiKey,
-      name: userConfig.name ?? `${networkConfig.name} Explorer`,
-      isCustom: userConfig.isCustom ?? false,
-      applyToAllNetworks: userConfig.applyToAllNetworks,
-      appliedNetworkIds: userConfig.appliedNetworkIds,
-      defaultProvider: userConfig.defaultProvider
-    };
-  }
-  if (isV2 && globalV2ApiKey) {
-    import_ui_builder_utils21.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
-    };
-  }
-  if (appApiKey) {
-    import_ui_builder_utils21.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
-    };
-  }
-  import_ui_builder_utils21.logger.info(
-    "ExplorerConfig",
-    `Using default explorer for ${networkConfig.name} (no API key configured)`
+// src/wallet/utils/uiKitService.ts
+function getResolvedWalletComponents(uiKitConfiguration) {
+  import_ui_builder_utils21.logger.debug(
+    "uiKitService:getResolvedWalletComponents",
+    "Received uiKitConfiguration:",
+    JSON.stringify(uiKitConfiguration)
   );
-  return {
-    explorerUrl: networkConfig.explorerUrl,
-    apiUrl: networkConfig.apiUrl,
-    name: `${networkConfig.name} Explorer`,
-    isCustom: false
-  };
-}
-function getEvmExplorerAddressUrl(address, networkConfig) {
-  if (!isValidEvmAddress(address)) {
-    return null;
-  }
-  const explorerConfig = resolveExplorerConfig(networkConfig);
-  if (!explorerConfig.explorerUrl) {
-    return null;
-  }
-  const baseUrl = explorerConfig.explorerUrl.replace(/\/+$/, "");
-  return `${baseUrl}/address/${address}`;
-}
-function getEvmExplorerTxUrl(txHash, networkConfig) {
-  if (!txHash) {
-    return null;
-  }
-  const explorerConfig = resolveExplorerConfig(networkConfig);
-  if (!explorerConfig.explorerUrl) {
-    return null;
-  }
-  const baseUrl = explorerConfig.explorerUrl.replace(/\/+$/, "");
-  return `${baseUrl}/tx/${txHash}`;
-}
-function validateEvmExplorerConfig(explorerConfig) {
-  if (explorerConfig.explorerUrl) {
-    try {
-      new URL(explorerConfig.explorerUrl);
-    } catch {
-      return false;
-    }
-  }
-  if (explorerConfig.apiUrl) {
-    try {
-      new URL(explorerConfig.apiUrl);
-    } catch {
-      return false;
-    }
-  }
-  if (explorerConfig.apiKey !== void 0 && explorerConfig.apiKey.trim().length === 0) {
-    return false;
-  }
-  return true;
-}
-async function testEvmExplorerConnection(explorerConfig, networkConfig) {
-  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"
-    };
-  }
-  if (networkConfig && shouldUseV2Api(networkConfig)) {
-    return testEtherscanV2Connection(networkConfig, explorerConfig.apiKey);
-  }
-  let apiUrl = explorerConfig.apiUrl;
-  if (!apiUrl && networkConfig?.apiUrl) {
-    apiUrl = networkConfig.apiUrl;
+  const currentKitName = uiKitConfiguration.kitName || "custom";
+  if (currentKitName === "none") {
+    import_ui_builder_utils21.logger.info(
+      "uiKitService",
+      'UI Kit set to "none" for getResolvedWalletComponents, not providing wallet components.'
+    );
+    return void 0;
   }
-  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 exclusions = getComponentExclusionsFromConfig(uiKitConfiguration.kitConfig);
+  import_ui_builder_utils21.logger.debug(
+    "uiKitService",
+    `Extracted component exclusions for ${currentKitName}: ${exclusions.join(", ") || "none"}.`
+  );
+  if (currentKitName === "custom") {
+    const allCustomComponents = {
+      ConnectButton: CustomConnectButton,
+      AccountDisplay: CustomAccountDisplay,
+      NetworkSwitcher: CustomNetworkSwitcher
     };
+    return filterWalletComponents(allCustomComponents, exclusions, currentKitName);
   }
-  const startTime = Date.now();
-  try {
-    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);
+  if (currentKitName === "rainbowkit") {
+    const validation = validateRainbowKitConfig(uiKitConfiguration.kitConfig);
+    if (!validation.isValid) {
+      import_ui_builder_utils21.logger.warn(
+        "uiKitService",
+        `Invalid RainbowKit configuration for components: ${validation.error}. No components provided.`
+      );
+      return void 0;
     }
-    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 rainbowKitComponents = createRainbowKitComponents();
+    import_ui_builder_utils21.logger.info("uiKitService", "Providing RainbowKit components.");
+    return filterWalletComponents(rainbowKitComponents, exclusions, currentKitName);
+  }
+  import_ui_builder_utils21.logger.warn(
+    "uiKitService",
+    `UI Kit "${currentKitName}" for getResolvedWalletComponents not explicitly supported. No components provided.`
+  );
+  return void 0;
+}
+
+// src/wallet/utils.ts
+function getResolvedWalletComponents2(uiKitConfig2) {
+  return getResolvedWalletComponents(uiKitConfig2);
+}
+async function resolveAndInitializeKitConfig(kitName, programmaticKitConfig, loadConfigModule) {
+  import_ui_builder_utils22.logger.debug(
+    "resolveAndInitializeKitConfig",
+    `Resolving native config for kit: ${kitName || "none"}`,
+    {
+      hasProgrammaticKitConfig: !!programmaticKitConfig,
+      hasLoadConfigModule: !!loadConfigModule
     }
-    const data = await response.json();
-    if (data.status === "0" && data.message) {
-      return {
-        success: false,
-        error: data.message,
-        latency
-      };
+  );
+  let userNativeConfig = null;
+  if (kitName && kitName !== "custom" && kitName !== "none" && loadConfigModule) {
+    const conventionalConfigPath = `./config/wallet/${kitName}.config.ts`;
+    try {
+      userNativeConfig = await loadConfigModule(conventionalConfigPath);
+    } catch (error) {
+      import_ui_builder_utils22.logger.warn(
+        "resolveAndInitializeKitConfig",
+        `Call to load native config for ${kitName} from ${conventionalConfigPath} failed. Error:`,
+        error
+      );
     }
-    return {
-      success: true,
-      latency
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Connection test failed",
-      latency: Date.now() - startTime
-    };
   }
+  if (userNativeConfig && programmaticKitConfig) {
+    const mergedConfig = { ...userNativeConfig, ...programmaticKitConfig };
+    return mergedConfig;
+  } else if (userNativeConfig) {
+    return userNativeConfig;
+  } else if (programmaticKitConfig) {
+    return programmaticKitConfig;
+  }
+  import_ui_builder_utils22.logger.debug(
+    "resolveAndInitializeKitConfig",
+    `No native or programmatic kitConfig provided for ${kitName || "none"}. Returning null.`
+  );
+  return null;
+}
+
+// src/wallet/services/configResolutionService.ts
+async function resolveFullUiKitConfiguration(programmaticOverrides, initialAppServiceKitName, currentAppServiceConfig, options) {
+  import_ui_builder_utils23.logger.debug(
+    "configResolutionService:resolveFullUiKitConfiguration",
+    "Starting resolution with:",
+    {
+      programmaticOverrides,
+      initialAppServiceKitName,
+      currentAppServiceConfig,
+      hasLoadNativeCallback: !!options?.loadUiKitNativeConfig,
+      hasCustomCode: !!programmaticOverrides.customCode
+    }
+  );
+  const effectiveKitName = programmaticOverrides.kitName || initialAppServiceKitName || currentAppServiceConfig.kitName || "custom";
+  const resolvedUserNativeAndProgrammaticKitConfig = await resolveAndInitializeKitConfig(
+    effectiveKitName,
+    programmaticOverrides.kitConfig,
+    options?.loadUiKitNativeConfig
+  );
+  const finalFullConfig = {
+    kitName: effectiveKitName,
+    kitConfig: {
+      ...currentAppServiceConfig.kitConfig || {},
+      ...resolvedUserNativeAndProgrammaticKitConfig || {}
+      // customCode is NOT applied to runtime config
+    },
+    // Pass through customCode for export purposes only
+    customCode: programmaticOverrides.customCode
+  };
+  import_ui_builder_utils23.logger.debug(
+    "configResolutionService:resolveFullUiKitConfiguration",
+    "Resolved finalFullConfig:",
+    finalFullConfig
+  );
+  return finalFullConfig;
 }
 
 // src/abi/etherscan.ts
+var import_ui_builder_utils24 = require("@openzeppelin/ui-builder-utils");
 async function loadAbiFromEtherscan(address, networkConfig) {
   if (shouldUseV2Api(networkConfig)) {
-    import_ui_builder_utils22.logger.info("loadAbiFromEtherscan", "Using V2 API for fetching ABI");
+    import_ui_builder_utils24.logger.info("loadAbiFromEtherscan", "Using V2 API for fetching ABI");
     return loadAbiFromEtherscanV2(address, networkConfig);
   }
-  import_ui_builder_utils22.logger.info("loadAbiFromEtherscan", "Using V1 API for fetching ABI");
+  import_ui_builder_utils24.logger.info("loadAbiFromEtherscan", "Using V1 API for fetching ABI");
   return loadAbiFromEtherscanV1(address, networkConfig);
 }
 async function loadAbiFromEtherscanV1(address, networkConfig) {
   const explorerConfig = resolveExplorerConfig(networkConfig);
   if (!explorerConfig.apiUrl) {
-    import_ui_builder_utils22.logger.error(
+    import_ui_builder_utils24.logger.error(
       "loadAbiFromEtherscanV1",
       `API URL is missing for ${networkConfig.name} explorer.`
     );
@@ -3130,20 +3418,20 @@ async function loadAbiFromEtherscanV1(address, networkConfig) {
   }
   let response;
   try {
-    import_ui_builder_utils22.logger.info(
+    import_ui_builder_utils24.logger.info(
       "loadAbiFromEtherscanV1",
       `Fetching ABI from ${explorerConfig.apiUrl} for address: ${address}`
     );
     response = await fetch(url);
   } catch (networkError) {
-    import_ui_builder_utils22.logger.error(
+    import_ui_builder_utils24.logger.error(
       "loadAbiFromEtherscanV1",
       `Network error fetching ABI from Explorer API: ${networkError}`
     );
     throw new Error(`Network error fetching ABI: ${networkError.message}`);
   }
   if (!response.ok) {
-    import_ui_builder_utils22.logger.error(
+    import_ui_builder_utils24.logger.error(
       "loadAbiFromEtherscanV1",
       `Explorer API request failed with status: ${response.status}`
     );
@@ -3153,14 +3441,14 @@ async function loadAbiFromEtherscanV1(address, networkConfig) {
   try {
     apiResult = await response.json();
   } catch (jsonError) {
-    import_ui_builder_utils22.logger.error(
+    import_ui_builder_utils24.logger.error(
       "loadAbiFromEtherscanV1",
       `Failed to parse Explorer API response as JSON: ${jsonError}`
     );
     throw new Error("Invalid JSON response received from Explorer API.");
   }
   if (apiResult.status !== "1") {
-    import_ui_builder_utils22.logger.warn(
+    import_ui_builder_utils24.logger.warn(
       "loadAbiFromEtherscanV1",
       `Explorer API error: Status ${apiResult.status}, Message: ${apiResult.message}, Result: ${apiResult.result}`
     );
@@ -3179,13 +3467,13 @@ async function loadAbiFromEtherscanV1(address, networkConfig) {
       throw new Error("Parsed ABI from Explorer API is not an array.");
     }
   } catch (error) {
-    import_ui_builder_utils22.logger.error(
+    import_ui_builder_utils24.logger.error(
       "loadAbiFromEtherscanV1",
       `Failed to parse ABI JSON string from Explorer API result: ${error}`
     );
     throw new Error(`Invalid ABI JSON received from Explorer API: ${error.message}`);
   }
-  import_ui_builder_utils22.logger.info(
+  import_ui_builder_utils24.logger.info(
     "loadAbiFromEtherscanV1",
     `Successfully parsed ABI for ${networkConfig.name} with ${abi.length} items.`
   );
@@ -3199,17 +3487,17 @@ async function loadAbiFromEtherscanV1(address, networkConfig) {
 
 // src/abi/loader.ts
 var import_viem5 = require("viem");
-var import_ui_builder_utils28 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils29 = require("@openzeppelin/ui-builder-utils");
 
 // src/proxy/detection.ts
 var import_viem4 = require("viem");
-var import_ui_builder_utils26 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils27 = require("@openzeppelin/ui-builder-utils");
 
 // src/configuration/execution.ts
-var import_ui_builder_utils24 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils26 = require("@openzeppelin/ui-builder-utils");
 
 // src/validation/eoa.ts
-var import_ui_builder_utils23 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils25 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG = "EoaValidator";
 async function validateEoaConfig(config, walletStatus) {
   if (!config.allowAny) {
@@ -3224,7 +3512,7 @@ async function validateEoaConfig(config, walletStatus) {
         return `Connected wallet address (${walletStatus.address}) does not match the required specific EOA address (${config.specificAddress}). Please connect the correct wallet.`;
       }
     } else if (walletStatus.isConnected && !walletStatus.address) {
-      import_ui_builder_utils23.logger.warn(
+      import_ui_builder_utils25.logger.warn(
         SYSTEM_LOG_TAG,
         "Wallet is connected but address is unavailable for EOA validation."
       );
@@ -3248,7 +3536,7 @@ async function validateRelayerConfig(config) {
 // src/configuration/execution.ts
 var SYSTEM_LOG_TAG2 = "adapter-evm-execution-config";
 async function getEvmSupportedExecutionMethods() {
-  import_ui_builder_utils24.logger.warn(
+  import_ui_builder_utils26.logger.warn(
     "adapter-evm-execution-config",
     "getEvmSupportedExecutionMethods is using placeholder implementation."
   );
@@ -3274,11 +3562,11 @@ async function getEvmSupportedExecutionMethods() {
   ]);
 }
 async function _validateMultisigConfig(_config, _walletStatus) {
-  import_ui_builder_utils24.logger.info(SYSTEM_LOG_TAG2, "Multisig execution config validation: Not yet fully implemented.");
+  import_ui_builder_utils26.logger.info(SYSTEM_LOG_TAG2, "Multisig execution config validation: Not yet fully implemented.");
   return true;
 }
 async function validateEvmExecutionConfig(config, walletStatus) {
-  import_ui_builder_utils24.logger.info(SYSTEM_LOG_TAG2, "Validating EVM execution config:", { config, walletStatus });
+  import_ui_builder_utils26.logger.info(SYSTEM_LOG_TAG2, "Validating EVM execution config:", { config, walletStatus });
   switch (config.method) {
     case "eoa":
       return validateEoaConfig(config, walletStatus);
@@ -3288,7 +3576,7 @@ async function validateEvmExecutionConfig(config, walletStatus) {
       return _validateMultisigConfig(config, walletStatus);
     default: {
       const unknownMethod = config.method;
-      import_ui_builder_utils24.logger.warn(
+      import_ui_builder_utils26.logger.warn(
         SYSTEM_LOG_TAG2,
         `Unsupported execution method type encountered: ${unknownMethod}`
       );
@@ -3297,130 +3585,6 @@ async function validateEvmExecutionConfig(config, walletStatus) {
   }
 }
 
-// src/configuration/rpc.ts
-var import_ui_builder_utils25 = require("@openzeppelin/ui-builder-utils");
-function buildRpcUrl(config) {
-  return config.url;
-}
-function resolveRpcUrl(networkConfig) {
-  const logSystem = "RpcResolver";
-  const networkId = networkConfig.id;
-  const userRpcConfig = import_ui_builder_utils25.userRpcConfigService.getUserRpcConfig(networkId);
-  if (userRpcConfig) {
-    const userRpcUrl = buildRpcUrl(userRpcConfig);
-    if ((0, import_ui_builder_utils25.isValidUrl)(userRpcUrl)) {
-      import_ui_builder_utils25.logger.info(
-        logSystem,
-        `Using user-configured RPC URL for network ${networkId}: ${userRpcConfig.name || "Custom"}`
-      );
-      return userRpcUrl;
-    } else {
-      import_ui_builder_utils25.logger.warn(
-        logSystem,
-        `User-configured RPC URL for ${networkId} is invalid: ${userRpcUrl}. Falling back.`
-      );
-    }
-  }
-  const rpcOverrideSetting = import_ui_builder_utils25.appConfigService.getRpcEndpointOverride(networkId);
-  let rpcUrlFromOverride;
-  if (typeof rpcOverrideSetting === "string") {
-    rpcUrlFromOverride = rpcOverrideSetting;
-  } else if (typeof rpcOverrideSetting === "object" && rpcOverrideSetting) {
-    if ("url" in rpcOverrideSetting && "isCustom" in rpcOverrideSetting) {
-      const userConfig = rpcOverrideSetting;
-      rpcUrlFromOverride = buildRpcUrl(userConfig);
-    } else if ("http" in rpcOverrideSetting) {
-      rpcUrlFromOverride = rpcOverrideSetting.http;
-    }
-  }
-  if (rpcUrlFromOverride) {
-    import_ui_builder_utils25.logger.info(
-      logSystem,
-      `Using overridden RPC URL for network ${networkId}: ${rpcUrlFromOverride}`
-    );
-    if ((0, import_ui_builder_utils25.isValidUrl)(rpcUrlFromOverride)) {
-      return rpcUrlFromOverride;
-    } else {
-      import_ui_builder_utils25.logger.warn(
-        logSystem,
-        `Overridden RPC URL for ${networkId} is invalid: ${rpcUrlFromOverride}. Falling back.`
-      );
-    }
-  }
-  if (networkConfig.rpcUrl && (0, import_ui_builder_utils25.isValidUrl)(networkConfig.rpcUrl)) {
-    import_ui_builder_utils25.logger.debug(
-      logSystem,
-      `Using default RPC URL for network ${networkId}: ${networkConfig.rpcUrl}`
-    );
-    return networkConfig.rpcUrl;
-  }
-  import_ui_builder_utils25.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}).`
-  );
-}
-function validateEvmRpcEndpoint(rpcConfig) {
-  try {
-    if (!(0, import_ui_builder_utils25.isValidUrl)(rpcConfig.url)) {
-      import_ui_builder_utils25.logger.error("validateEvmRpcEndpoint", `Invalid RPC URL format: ${rpcConfig.url}`);
-      return false;
-    }
-    return true;
-  } catch (error) {
-    import_ui_builder_utils25.logger.error("validateEvmRpcEndpoint", "Error validating RPC endpoint:", error);
-    return false;
-  }
-}
-async function testEvmRpcConnection(rpcConfig, timeoutMs = 5e3) {
-  if (!rpcConfig.url) {
-    return { success: false, error: "RPC URL is required" };
-  }
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const startTime = Date.now();
-    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) {
-    import_ui_builder_utils25.logger.error("testEvmRpcConnection", "Connection test failed:", error);
-    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 {
-    clearTimeout(timeoutId);
-  }
-}
-
 // src/proxy/detection.ts
 function detectProxyFromAbi(abi) {
   const functions = abi.filter((item) => item.type === "function");
@@ -3511,7 +3675,7 @@ function detectProxyFromAbi(abi) {
   };
 }
 async function getImplementationAddress(proxyAddress, networkConfig, proxyType) {
-  import_ui_builder_utils26.logger.info(
+  import_ui_builder_utils27.logger.info(
     "getImplementationAddress",
     `Resolving implementation for ${proxyType} proxy: ${proxyAddress}`
   );
@@ -3528,7 +3692,7 @@ async function getImplementationAddress(proxyAddress, networkConfig, proxyType)
       case "beacon":
         return await getBeaconImplementation(proxyAddress, networkConfig);
       case "diamond":
-        import_ui_builder_utils26.logger.info("getImplementationAddress", "Diamond proxies not fully supported yet");
+        import_ui_builder_utils27.logger.info("getImplementationAddress", "Diamond proxies not fully supported yet");
         return null;
       case "minimal":
         return await getMinimalProxyImplementation(proxyAddress, networkConfig);
@@ -3536,7 +3700,7 @@ async function getImplementationAddress(proxyAddress, networkConfig, proxyType)
         return await tryCommonImplementationMethods(proxyAddress, networkConfig);
     }
   } catch (error) {
-    import_ui_builder_utils26.logger.warn("getImplementationAddress", `Failed to resolve implementation: ${error}`);
+    import_ui_builder_utils27.logger.warn("getImplementationAddress", `Failed to resolve implementation: ${error}`);
     return null;
   }
 }
@@ -3548,7 +3712,7 @@ async function getAdminAddress(proxyAddress, networkConfig) {
     if (legacyAdmin) return legacyAdmin;
     return null;
   } catch (error) {
-    import_ui_builder_utils26.logger.warn("getAdminAddress", `Failed to resolve admin: ${error}`);
+    import_ui_builder_utils27.logger.warn("getAdminAddress", `Failed to resolve admin: ${error}`);
     return null;
   }
 }
@@ -3563,20 +3727,20 @@ async function getEIP1967Admin(proxyAddress, networkConfig) {
 async function getLegacyOZAdmin(proxyAddress, networkConfig) {
   try {
     const slot = (0, import_viem4.keccak256)((0, import_viem4.toHex)("org.zeppelinos.proxy.admin"));
-    import_ui_builder_utils26.logger.info("getLegacyOZAdmin", `Trying legacy OZ admin slot: ${slot}`);
+    import_ui_builder_utils27.logger.info("getLegacyOZAdmin", `Trying legacy OZ admin slot: ${slot}`);
     return await readStorageSlot(proxyAddress, slot, networkConfig);
   } catch (error) {
-    import_ui_builder_utils26.logger.warn("getLegacyOZAdmin", `Failed computing or reading legacy admin slot: ${error}`);
+    import_ui_builder_utils27.logger.warn("getLegacyOZAdmin", `Failed computing or reading legacy admin slot: ${error}`);
     return null;
   }
 }
 async function getLegacyOZImplementation(proxyAddress, networkConfig) {
   try {
     const slot = (0, import_viem4.keccak256)((0, import_viem4.toHex)("org.zeppelinos.proxy.implementation"));
-    import_ui_builder_utils26.logger.info("getLegacyOZImplementation", `Trying legacy OZ slot: ${slot}`);
+    import_ui_builder_utils27.logger.info("getLegacyOZImplementation", `Trying legacy OZ slot: ${slot}`);
     return await readStorageSlot(proxyAddress, slot, networkConfig);
   } catch (error) {
-    import_ui_builder_utils26.logger.warn("getLegacyOZImplementation", `Failed computing or reading legacy slot: ${error}`);
+    import_ui_builder_utils27.logger.warn("getLegacyOZImplementation", `Failed computing or reading legacy slot: ${error}`);
     return null;
   }
 }
@@ -3600,7 +3764,7 @@ async function getMinimalProxyImplementation(proxyAddress, networkConfig) {
     }
     return null;
   } catch (error) {
-    import_ui_builder_utils26.logger.warn("getMinimalProxyImplementation", `Error reading bytecode: ${error}`);
+    import_ui_builder_utils27.logger.warn("getMinimalProxyImplementation", `Error reading bytecode: ${error}`);
     return null;
   }
 }
@@ -3615,7 +3779,7 @@ async function tryCommonImplementationMethods(proxyAddress, networkConfig) {
     try {
       const result = await callContractFunction(proxyAddress, method, [], networkConfig);
       if (result && result !== "0x0000000000000000000000000000000000000000") {
-        import_ui_builder_utils26.logger.info(
+        import_ui_builder_utils27.logger.info(
           "tryCommonImplementationMethods",
           `Found implementation via ${method}: ${result}`
         );
@@ -3641,13 +3805,13 @@ async function readStorageSlot(address, slot, networkConfig) {
       slot
     });
     if (storageValue && storageValue !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
-      import_ui_builder_utils26.logger.info("readStorageSlot", `Found non-zero value at slot ${slot}: ${storageValue}`);
+      import_ui_builder_utils27.logger.info("readStorageSlot", `Found non-zero value at slot ${slot}: ${storageValue}`);
       const implAddress = "0x" + storageValue.slice(-40);
       return implAddress;
     }
     return null;
   } catch (error) {
-    import_ui_builder_utils26.logger.warn("readStorageSlot", `Failed to read storage slot ${slot}: ${error}`);
+    import_ui_builder_utils27.logger.warn("readStorageSlot", `Failed to read storage slot ${slot}: ${error}`);
     return null;
   }
 }
@@ -3668,7 +3832,7 @@ async function callContractFunction(address, signature, params, networkConfig) {
     }
     return null;
   } catch (error) {
-    import_ui_builder_utils26.logger.warn("callContractFunction", `Failed to call ${signature}: ${error}`);
+    import_ui_builder_utils27.logger.warn("callContractFunction", `Failed to call ${signature}: ${error}`);
     return null;
   }
 }
@@ -3680,17 +3844,16 @@ async function getContractBytecode(address, networkConfig) {
     });
     return bytecode || null;
   } catch (error) {
-    import_ui_builder_utils26.logger.warn("getContractBytecode", `Failed to get bytecode: ${error}`);
+    import_ui_builder_utils27.logger.warn("getContractBytecode", `Failed to get bytecode: ${error}`);
     return null;
   }
 }
 
 // src/abi/sourcify.ts
-var import_ui_builder_utils27 = require("@openzeppelin/ui-builder-utils");
-var SOURCIFY_APP_BASE = "https://sourcify.dev";
+var import_ui_builder_utils28 = require("@openzeppelin/ui-builder-utils");
+var SOURCIFY_APP_BASE = "https://repo.sourcify.dev";
 function getSourcifyContractAppUrl(chainId, address) {
-  const normalizedAddress = address.toLowerCase();
-  return `${SOURCIFY_APP_BASE}/status/${chainId}/${normalizedAddress}`;
+  return `${SOURCIFY_APP_BASE}/${chainId}/${address}`;
 }
 var SOURCIFY_API_BASE = "https://sourcify.dev/server/v2";
 function buildSourcifyApiUrl(chainId, address) {
@@ -3705,7 +3868,7 @@ async function loadAbiFromSourcify(address, networkConfig, timeoutMs = 4e3) {
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const url = buildSourcifyApiUrl(networkConfig.chainId, address);
-    import_ui_builder_utils27.logger.info("loadAbiFromSourcify", `Fetching contract from ${url}`);
+    import_ui_builder_utils28.logger.info("loadAbiFromSourcify", `Fetching contract from ${url}`);
     const response = await fetch(url, { signal: controller.signal });
     if (!response.ok) {
       throw new Error(`Sourcify request failed: ${response.status} ${response.statusText}`);
@@ -3720,7 +3883,7 @@ async function loadAbiFromSourcify(address, networkConfig, timeoutMs = 4e3) {
     const schema = transformAbiToSchema(abi, contractName, address);
     return { schema, originalAbi: JSON.stringify(abi) };
   } catch (error) {
-    import_ui_builder_utils27.logger.warn("loadAbiFromSourcify", `Failed to fetch ABI from Sourcify: ${String(error)}`);
+    import_ui_builder_utils28.logger.warn("loadAbiFromSourcify", `Failed to fetch ABI from Sourcify: ${String(error)}`);
     throw error;
   } finally {
     clearTimeout(timeout);
@@ -3728,9 +3891,6 @@ async function loadAbiFromSourcify(address, networkConfig, timeoutMs = 4e3) {
 }
 
 // src/abi/loader.ts
-function hasDefaultProvider(config) {
-  return config !== null && typeof config === "object" && "defaultProvider" in config;
-}
 async function loadAbiFromJson(abiJsonString) {
   let abi;
   try {
@@ -3739,10 +3899,10 @@ async function loadAbiFromJson(abiJsonString) {
       throw new Error("Parsed JSON is not an array.");
     }
   } catch (error) {
-    import_ui_builder_utils28.logger.error("loadAbiFromJson", "Failed to parse source string as JSON ABI:", error);
+    import_ui_builder_utils29.logger.error("loadAbiFromJson", "Failed to parse source string as JSON ABI:", error);
     throw new Error(`Invalid JSON ABI provided: ${error.message}`);
   }
-  import_ui_builder_utils28.logger.info("loadAbiFromJson", `Successfully parsed JSON ABI with ${abi.length} items.`);
+  import_ui_builder_utils29.logger.info("loadAbiFromJson", `Successfully parsed JSON ABI with ${abi.length} items.`);
   const contractName = "ContractFromABI";
   return transformAbiToSchema(abi, contractName, void 0);
 }
@@ -3761,7 +3921,7 @@ async function loadEvmContract(artifacts, networkConfig, options = {}) {
     const trimmed = contractDefinition.trim();
     const hasJsonContent = trimmed.includes("[") && trimmed.includes("]") && trimmed.includes("{");
     if (hasJsonContent) {
-      import_ui_builder_utils28.logger.info("loadEvmContract", "Manual contract definition provided. Attempting to parse...");
+      import_ui_builder_utils29.logger.info("loadEvmContract", "Manual contract definition provided. Attempting to parse...");
       try {
         const schema = await loadAbiFromJson(contractDefinition);
         return {
@@ -3777,14 +3937,14 @@ async function loadEvmContract(artifacts, networkConfig, options = {}) {
           // Note: No proxy detection for manual ABIs - user provides what they want
         };
       } catch (error) {
-        import_ui_builder_utils28.logger.error("loadEvmContract", "Failed to parse manually provided ABI:", error);
+        import_ui_builder_utils29.logger.error("loadEvmContract", "Failed to parse manually provided ABI:", error);
         throw new Error(`The provided ABI JSON is invalid: ${error.message}`);
       }
     }
   }
   const forcedRaw = artifacts.__forcedProvider || artifacts.service;
   const forcedProvider = isEvmProviderKey(forcedRaw) ? forcedRaw : null;
-  import_ui_builder_utils28.logger.info(
+  import_ui_builder_utils29.logger.info(
     "loadEvmContract",
     `No manual ABI detected. Attempting Etherscan fetch for address: ${contractAddress}...`
   );
@@ -3813,7 +3973,7 @@ function buildContractResult(contractAddress, abiResult, networkConfig, sourcePr
       contractName: abiResult.schema.name,
       verificationStatus: "verified",
       fetchTimestamp: /* @__PURE__ */ new Date(),
-      definitionHash: (0, import_ui_builder_utils28.simpleHash)(abiResult.originalAbi)
+      definitionHash: (0, import_ui_builder_utils29.simpleHash)(abiResult.originalAbi)
     },
     proxyInfo
   };
@@ -3821,13 +3981,13 @@ function buildContractResult(contractAddress, abiResult, networkConfig, sourcePr
 async function loadImplementationAbi(_contractAddress, implementationAddress, networkConfig, _proxyType) {
   try {
     const implementationResult = await loadAbiFromEtherscan(implementationAddress, networkConfig);
-    import_ui_builder_utils28.logger.info(
+    import_ui_builder_utils29.logger.info(
       "loadImplementationAbi",
       `Successfully fetched implementation ABI with ${implementationResult.schema.functions.length} functions`
     );
     return implementationResult;
   } catch (implementationError) {
-    import_ui_builder_utils28.logger.warn(
+    import_ui_builder_utils29.logger.warn(
       "loadImplementationAbi",
       `Failed to load implementation ABI: ${implementationError}`
     );
@@ -3840,7 +4000,7 @@ async function handleProxyDetection(contractAddress, initialResult, networkConfi
   if (!proxyDetection.isProxy) {
     return null;
   }
-  import_ui_builder_utils28.logger.info(
+  import_ui_builder_utils29.logger.info(
     "handleProxyDetection",
     `Proxy detected: ${proxyDetection.proxyType} (confidence: ${proxyDetection.confidence})`
   );
@@ -3852,7 +4012,7 @@ async function handleProxyDetection(contractAddress, initialResult, networkConfi
   );
   const adminAddress = await getAdminAddress(contractAddress, networkConfig);
   if (!implementationAddress) {
-    import_ui_builder_utils28.logger.info("handleProxyDetection", "Proxy detected but implementation address not found");
+    import_ui_builder_utils29.logger.info("handleProxyDetection", "Proxy detected but implementation address not found");
     return buildContractResult(contractAddress, initialResult, networkConfig, initialProvider, {
       isProxy: true,
       proxyType,
@@ -3860,7 +4020,7 @@ async function handleProxyDetection(contractAddress, initialResult, networkConfi
       detectionMethod: "automatic"
     });
   }
-  import_ui_builder_utils28.logger.info("handleProxyDetection", `Found implementation at: ${implementationAddress}`);
+  import_ui_builder_utils29.logger.info("handleProxyDetection", `Found implementation at: ${implementationAddress}`);
   const implementationResult = await loadImplementationAbi(
     contractAddress,
     implementationAddress,
@@ -3895,9 +4055,13 @@ async function handleProxyDetection(contractAddress, initialResult, networkConfi
 }
 async function loadContractWithProxyDetection(contractAddress, networkConfig, options = {}, forcedProvider = null) {
   try {
-    const userConfig = import_ui_builder_utils28.userExplorerConfigService.getUserExplorerConfig(networkConfig.id);
-    const uiDefault = hasDefaultProvider(userConfig) ? userConfig.defaultProvider || null : null;
-    const appDefaultRaw = import_ui_builder_utils28.appConfigService.getGlobalServiceParam(
+    let uiDefault = null;
+    const svcCfg = import_ui_builder_utils29.userNetworkServiceConfigService.get(networkConfig.id, "contract-definitions");
+    if (svcCfg && typeof svcCfg === "object" && "defaultProvider" in svcCfg) {
+      const raw = svcCfg.defaultProvider;
+      if (isEvmProviderKey(raw)) uiDefault = raw;
+    }
+    const appDefaultRaw = import_ui_builder_utils29.appConfigService.getGlobalServiceParam(
       "contractdefinition",
       "defaultProvider"
     );
@@ -3916,13 +4080,13 @@ async function loadContractWithProxyDetection(contractAddress, networkConfig, op
         const remainingOverall = Math.max(100, overallDeadline - Date.now());
         const attemptTimeout = Math.min(PER_PROVIDER_TIMEOUT_MS, remainingOverall);
         if (provider === EvmProviderKeys.Etherscan) {
-          initialResult = await (0, import_ui_builder_utils28.withTimeout)(
+          initialResult = await (0, import_ui_builder_utils29.withTimeout)(
             loadAbiFromEtherscan(contractAddress, networkConfig),
             attemptTimeout,
             "etherscan"
           );
         } else if (provider === EvmProviderKeys.Sourcify) {
-          initialResult = await (0, import_ui_builder_utils28.withTimeout)(
+          initialResult = await (0, import_ui_builder_utils29.withTimeout)(
             loadAbiFromSourcify(contractAddress, networkConfig, attemptTimeout),
             attemptTimeout,
             "sourcify"
@@ -3938,7 +4102,7 @@ async function loadContractWithProxyDetection(contractAddress, networkConfig, op
       }
     }
     if (!initialResult) throw lastError ?? new Error("No provider succeeded");
-    import_ui_builder_utils28.logger.info(
+    import_ui_builder_utils29.logger.info(
       "loadContractWithProxyDetection",
       `Successfully fetched initial ABI for ${contractAddress} with ${initialResult.schema.functions.length} functions`
     );
@@ -3955,7 +4119,7 @@ async function loadContractWithProxyDetection(contractAddress, networkConfig, op
     }
     return buildContractResult(contractAddress, initialResult, networkConfig, usedProvider);
   } catch (error) {
-    import_ui_builder_utils28.logger.warn("loadContractWithProxyDetection", `Contract loading failed: ${error}`);
+    import_ui_builder_utils29.logger.warn("loadContractWithProxyDetection", `Contract loading failed: ${error}`);
     if (forcedProvider) {
       throw error;
     }
@@ -4043,7 +4207,7 @@ function getEvmCompatibleFieldTypes(parameterType) {
 
 // src/mapping/field-generator.ts
 var import_lodash = require("lodash");
-var import_ui_builder_utils29 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils30 = require("@openzeppelin/ui-builder-utils");
 function extractArrayElementType(parameterType) {
   const arrayMatch = parameterType.match(/^(.+)\[\d*\]$/);
   if (arrayMatch) {
@@ -4064,7 +4228,7 @@ function generateEvmDefaultField(parameter) {
     type: fieldType,
     placeholder: `Enter ${parameter.displayName || parameter.name || parameter.type}`,
     helperText: parameter.description || "",
-    defaultValue: (0, import_ui_builder_utils29.getDefaultValueForType)(fieldType),
+    defaultValue: (0, import_ui_builder_utils30.getDefaultValueForType)(fieldType),
     validation: getDefaultValidation(),
     width: "full"
   };
@@ -4101,11 +4265,11 @@ function isEvmViewFunction(functionDetails) {
 
 // src/query/handler.ts
 var import_viem7 = require("viem");
-var import_ui_builder_utils32 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils33 = require("@openzeppelin/ui-builder-utils");
 
 // src/transform/input-parser.ts
 var import_viem6 = require("viem");
-var import_ui_builder_utils30 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils31 = require("@openzeppelin/ui-builder-utils");
 function parseEvmInput(param, rawValue, isRecursive = false) {
   const { type, name } = param;
   const baseType = type.replace(/\[\d*\]$/, "");
@@ -4223,7 +4387,7 @@ function parseEvmInput(param, rawValue, isRecursive = false) {
     } else if (baseType === "string") {
       return String(rawValue);
     }
-    import_ui_builder_utils30.logger.warn(
+    import_ui_builder_utils31.logger.warn(
       "parseEvmInput",
       `Unknown EVM parameter type encountered: '${type}'. Using raw value.`
     );
@@ -4236,10 +4400,10 @@ function parseEvmInput(param, rawValue, isRecursive = false) {
 }
 
 // src/transform/output-formatter.ts
-var import_ui_builder_utils31 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils32 = require("@openzeppelin/ui-builder-utils");
 function formatEvmFunctionResult(decodedValue, functionDetails) {
   if (!functionDetails.outputs || !Array.isArray(functionDetails.outputs)) {
-    import_ui_builder_utils31.logger.warn(
+    import_ui_builder_utils32.logger.warn(
       "formatEvmFunctionResult",
       `Output ABI definition missing or invalid for function ${functionDetails.name}.`
     );
@@ -4267,7 +4431,7 @@ function formatEvmFunctionResult(decodedValue, functionDetails) {
     }
   } catch (error) {
     const errorMessage = `Error formatting result for ${functionDetails.name}: ${error.message}`;
-    import_ui_builder_utils31.logger.error("formatEvmFunctionResult", errorMessage, {
+    import_ui_builder_utils32.logger.error("formatEvmFunctionResult", errorMessage, {
       functionName: functionDetails.name,
       decodedValue,
       error
@@ -4278,8 +4442,7 @@ function formatEvmFunctionResult(decodedValue, functionDetails) {
 
 // src/query/handler.ts
 async function getPublicClientForQuery(walletImplementation, networkConfig) {
-  const customRpcConfig = import_ui_builder_utils32.userRpcConfigService.getUserRpcConfig(networkConfig.id);
-  if (customRpcConfig) {
+  if (getUserRpcUrl(networkConfig.id)) {
     const resolvedRpc2 = resolveRpcUrl(networkConfig);
     return createPublicClientWithRpc(networkConfig, resolvedRpc2);
   }
@@ -4291,14 +4454,14 @@ async function getPublicClientForQuery(walletImplementation, networkConfig) {
     if (clientFromWallet) {
       return clientFromWallet;
     } else {
-      import_ui_builder_utils32.logger.warn(
+      import_ui_builder_utils33.logger.warn(
         "getPublicClientForQuery",
         `Could not get public client from connected wallet for chain ${walletChainId}. Falling back.`
       );
     }
   }
   const resolvedRpc = resolveRpcUrl(networkConfig);
-  import_ui_builder_utils32.logger.info(
+  import_ui_builder_utils33.logger.info(
     "getPublicClientForQuery",
     `Wallet not connected/on wrong chain OR failed to get wallet client. Creating dedicated public client for query on ${networkConfig.name} using RPC: ${resolvedRpc}`
   );
@@ -4309,7 +4472,7 @@ function createPublicClientWithRpc(networkConfig, rpcUrl) {
   if (networkConfig.viemChain) {
     chainForViem = networkConfig.viemChain;
   } else {
-    import_ui_builder_utils32.logger.warn(
+    import_ui_builder_utils33.logger.warn(
       "createPublicClientWithRpc",
       `Viem chain object (viemChain) not provided in EvmNetworkConfig for ${networkConfig.name} (query). Creating a minimal one.`
     );
@@ -4336,7 +4499,7 @@ function createPublicClientWithRpc(networkConfig, rpcUrl) {
     });
     return publicClient;
   } catch (error) {
-    import_ui_builder_utils32.logger.error(
+    import_ui_builder_utils33.logger.error(
       "createPublicClientWithRpc",
       "Failed to create network-specific public client for query:",
       error
@@ -4347,7 +4510,7 @@ function createPublicClientWithRpc(networkConfig, rpcUrl) {
   }
 }
 async function queryEvmViewFunction(contractAddress, functionId, networkConfig, params, contractSchema, walletImplementation, loadContractFn) {
-  import_ui_builder_utils32.logger.info(
+  import_ui_builder_utils33.logger.info(
     "queryEvmViewFunction",
     `Querying view function: ${functionId} on ${contractAddress} (${networkConfig.name})`,
     { params }
@@ -4378,9 +4541,9 @@ async function queryEvmViewFunction(contractAddress, functionId, networkConfig,
       }
       return parseEvmInput(inputParam, rawValue, false);
     });
-    import_ui_builder_utils32.logger.debug("queryEvmViewFunction", "Parsed Args for readContract:", args);
+    import_ui_builder_utils33.logger.debug("queryEvmViewFunction", "Parsed Args for readContract:", args);
     const functionAbiItem = createAbiFunctionItem(functionDetails);
-    import_ui_builder_utils32.logger.debug(
+    import_ui_builder_utils33.logger.debug(
       "queryEvmViewFunction",
       `[Query ${functionDetails.name}] Calling readContract with ABI:`,
       functionAbiItem,
@@ -4396,7 +4559,7 @@ async function queryEvmViewFunction(contractAddress, functionId, networkConfig,
         args
       });
     } catch (readError) {
-      import_ui_builder_utils32.logger.error(
+      import_ui_builder_utils33.logger.error(
         "queryEvmViewFunction",
         `[Query ${functionDetails.name}] publicClient.readContract specific error:`,
         readError
@@ -4405,7 +4568,7 @@ async function queryEvmViewFunction(contractAddress, functionId, networkConfig,
         `Viem readContract failed for ${functionDetails.name}: ${readError.message}`
       );
     }
-    import_ui_builder_utils32.logger.debug(
+    import_ui_builder_utils33.logger.debug(
       "queryEvmViewFunction",
       `[Query ${functionDetails.name}] Raw decoded result:`,
       decodedResult
@@ -4413,7 +4576,7 @@ async function queryEvmViewFunction(contractAddress, functionId, networkConfig,
     return decodedResult;
   } catch (error) {
     const errorMessage = `Failed to query view function ${functionId} on network ${networkConfig.name}: ${error.message}`;
-    import_ui_builder_utils32.logger.error("queryEvmViewFunction", errorMessage, {
+    import_ui_builder_utils33.logger.error("queryEvmViewFunction", errorMessage, {
       contractAddress,
       functionId,
       params,
@@ -4427,7 +4590,7 @@ async function queryEvmViewFunction(contractAddress, functionId, networkConfig,
 // src/transaction/relayer.ts
 var import_viem8 = require("viem");
 var import_relayer_sdk = require("@openzeppelin/relayer-sdk");
-var import_ui_builder_utils33 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils34 = require("@openzeppelin/ui-builder-utils");
 var RelayerExecutionStrategy = class {
   async execute(transactionData, executionConfig, _walletImplementation, onStatusChange, runtimeApiKey) {
     const relayerConfig = executionConfig;
@@ -4462,7 +4625,7 @@ var RelayerExecutionStrategy = class {
    * @throws If the API call fails or returns an unsuccessful response.
    */
   async getEvmRelayers(serviceUrl, accessToken, networkConfig) {
-    import_ui_builder_utils33.logger.info(
+    import_ui_builder_utils34.logger.info(
       "[Relayer] Getting relayers with access token",
       accessToken.slice(0, 5).padEnd(accessToken.length, "*")
     );
@@ -4510,7 +4673,7 @@ var RelayerExecutionStrategy = class {
    * @throws If any API call fails or returns an unsuccessful response.
    */
   async getEvmRelayer(serviceUrl, accessToken, relayerId, networkConfig) {
-    import_ui_builder_utils33.logger.info("[Relayer] Getting detailed relayer info", relayerId);
+    import_ui_builder_utils34.logger.info("[Relayer] Getting detailed relayer info", relayerId);
     const sdkConfig = new import_relayer_sdk.Configuration({
       basePath: serviceUrl,
       accessToken
@@ -4520,11 +4683,11 @@ var RelayerExecutionStrategy = class {
       const [relayerResponse, balanceResponse, statusResponse] = await Promise.all([
         relayersApi.getRelayer(relayerId),
         relayersApi.getRelayerBalance(relayerId).catch((err) => {
-          import_ui_builder_utils33.logger.warn("[Relayer] Failed to fetch balance", err);
+          import_ui_builder_utils34.logger.warn("[Relayer] Failed to fetch balance", err);
           return null;
         }),
         relayersApi.getRelayerStatus(relayerId).catch((err) => {
-          import_ui_builder_utils33.logger.warn("[Relayer] Failed to fetch status", err);
+          import_ui_builder_utils34.logger.warn("[Relayer] Failed to fetch status", err);
           return null;
         })
       ]);
@@ -4547,7 +4710,7 @@ var RelayerExecutionStrategy = class {
           const currencySymbol = networkConfig.nativeCurrency.symbol;
           enhancedDetails.balance = `${balanceInEth} ${currencySymbol}`;
         } catch (error) {
-          import_ui_builder_utils33.logger.warn("[Relayer] Failed to format balance, using raw value", String(error));
+          import_ui_builder_utils34.logger.warn("[Relayer] Failed to format balance, using raw value", String(error));
           enhancedDetails.balance = String(balanceResponse.data.data.balance);
         }
       }
@@ -4565,10 +4728,10 @@ var RelayerExecutionStrategy = class {
           }
         }
       }
-      import_ui_builder_utils33.logger.info("[Relayer] Retrieved enhanced relayer details", JSON.stringify(enhancedDetails));
+      import_ui_builder_utils34.logger.info("[Relayer] Retrieved enhanced relayer details", JSON.stringify(enhancedDetails));
       return enhancedDetails;
     } catch (error) {
-      import_ui_builder_utils33.logger.error(
+      import_ui_builder_utils34.logger.error(
         "[Relayer] Failed to get relayer details",
         error instanceof Error ? error.message : String(error)
       );
@@ -4593,7 +4756,7 @@ var RelayerExecutionStrategy = class {
     let valueNumber = 0;
     const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
     if (valueBigint > MAX_SAFE) {
-      import_ui_builder_utils33.logger.warn(
+      import_ui_builder_utils34.logger.warn(
         "[Relayer] Value exceeds JS safe integer. Truncating for request.",
         valueBigint.toString()
       );
@@ -4608,7 +4771,7 @@ var RelayerExecutionStrategy = class {
       // If no explicit gas limit is provided, keep a conservative default but warn.
       gas_limit: (() => {
         if (typeof evmOptions?.gasLimit === "number") return evmOptions.gasLimit;
-        import_ui_builder_utils33.logger.warn(
+        import_ui_builder_utils34.logger.warn(
           "[Relayer]",
           "No gasLimit provided; using default 210000. Consider setting explicitly."
         );
@@ -4680,10 +4843,10 @@ var RelayerExecutionStrategy = class {
 };
 
 // src/transaction/sender.ts
-var import_ui_builder_utils34 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils35 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG3 = "adapter-evm-sender";
 async function waitForEvmTransactionConfirmation(txHash, walletImplementation) {
-  import_ui_builder_utils34.logger.info(SYSTEM_LOG_TAG3, `Waiting for tx: ${txHash}`);
+  import_ui_builder_utils35.logger.info(SYSTEM_LOG_TAG3, `Waiting for tx: ${txHash}`);
   try {
     const resolvedPublicClient = await walletImplementation.getPublicClient();
     if (!resolvedPublicClient) {
@@ -4692,15 +4855,15 @@ async function waitForEvmTransactionConfirmation(txHash, walletImplementation) {
     const receipt = await resolvedPublicClient.waitForTransactionReceipt({
       hash: txHash
     });
-    import_ui_builder_utils34.logger.info(SYSTEM_LOG_TAG3, "Received receipt:", receipt);
+    import_ui_builder_utils35.logger.info(SYSTEM_LOG_TAG3, "Received receipt:", receipt);
     if (receipt.status === "success") {
       return { status: "success", receipt };
     } else {
-      import_ui_builder_utils34.logger.error(SYSTEM_LOG_TAG3, "Transaction reverted:", receipt);
+      import_ui_builder_utils35.logger.error(SYSTEM_LOG_TAG3, "Transaction reverted:", receipt);
       return { status: "error", receipt, error: new Error("Transaction reverted.") };
     }
   } catch (error) {
-    import_ui_builder_utils34.logger.error(SYSTEM_LOG_TAG3, "Error waiting for transaction confirmation:", error);
+    import_ui_builder_utils35.logger.error(SYSTEM_LOG_TAG3, "Error waiting for transaction confirmation:", error);
     return {
       status: "error",
       error: error instanceof Error ? error : new Error(String(error))
@@ -4710,9 +4873,9 @@ async function waitForEvmTransactionConfirmation(txHash, walletImplementation) {
 
 // src/transaction/formatter.ts
 var import_viem9 = require("viem");
-var import_ui_builder_utils35 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils36 = require("@openzeppelin/ui-builder-utils");
 function formatEvmTransactionData(contractSchema, functionId, submittedInputs, fields) {
-  import_ui_builder_utils35.logger.info(
+  import_ui_builder_utils36.logger.info(
     "formatEvmTransactionData",
     `Formatting EVM transaction data for function: ${functionId}`
   );
@@ -4750,7 +4913,7 @@ function formatEvmTransactionData(contractSchema, functionId, submittedInputs, f
   const isPayable = functionDetails.stateMutability === "payable";
   let transactionValue = 0n;
   if (isPayable) {
-    import_ui_builder_utils35.logger.warn(
+    import_ui_builder_utils36.logger.warn(
       "formatEvmTransactionData",
       "Payable function detected, but sending 0 ETH. Implement value input."
     );
@@ -4771,7 +4934,7 @@ function formatEvmTransactionData(contractSchema, functionId, submittedInputs, f
 }
 
 // src/transaction/eoa.ts
-var import_ui_builder_utils36 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils37 = require("@openzeppelin/ui-builder-utils");
 var SYSTEM_LOG_TAG4 = "EoaExecutionStrategy";
 var EoaExecutionStrategy = class {
   async execute(transactionData, executionConfig, walletImplementation, onStatusChange, _runtimeApiKey) {
@@ -4784,9 +4947,9 @@ var EoaExecutionStrategy = class {
     if (validationResult !== true) {
       throw new Error(validationResult);
     }
-    import_ui_builder_utils36.logger.info(SYSTEM_LOG_TAG4, "Using EOA execution strategy.");
+    import_ui_builder_utils37.logger.info(SYSTEM_LOG_TAG4, "Using EOA execution strategy.");
     try {
-      import_ui_builder_utils36.logger.debug(SYSTEM_LOG_TAG4, "Calling walletClient.writeContract with:", {
+      import_ui_builder_utils37.logger.debug(SYSTEM_LOG_TAG4, "Calling walletClient.writeContract with:", {
         account: accountStatus.address,
         address: transactionData.address,
         abi: transactionData.abi,
@@ -4805,10 +4968,10 @@ var EoaExecutionStrategy = class {
         value: transactionData.value,
         chain: walletClient.chain
       });
-      import_ui_builder_utils36.logger.info(SYSTEM_LOG_TAG4, "EOA Transaction initiated. Hash:", hash);
+      import_ui_builder_utils37.logger.info(SYSTEM_LOG_TAG4, "EOA Transaction initiated. Hash:", hash);
       return { txHash: hash };
     } catch (error) {
-      import_ui_builder_utils36.logger.error(SYSTEM_LOG_TAG4, "Error during EOA writeContract call:", error);
+      import_ui_builder_utils37.logger.error(SYSTEM_LOG_TAG4, "Error during EOA writeContract call:", error);
       const errorMessage = error instanceof Error ? error.message : "Unknown EOA transaction error";
       throw new Error(`Transaction failed (EOA): ${errorMessage}`);
     }
@@ -4816,12 +4979,12 @@ var EoaExecutionStrategy = class {
   async getAuthenticatedWalletClient(walletImplementation) {
     const walletClient = await walletImplementation.getWalletClient();
     if (!walletClient) {
-      import_ui_builder_utils36.logger.error(SYSTEM_LOG_TAG4, "Wallet client not available. Is wallet connected?");
+      import_ui_builder_utils37.logger.error(SYSTEM_LOG_TAG4, "Wallet client not available. Is wallet connected?");
       throw new Error("Wallet is not connected or client is unavailable.");
     }
     const accountStatus = walletImplementation.getWalletConnectionStatus();
     if (!accountStatus.isConnected || !accountStatus.address) {
-      import_ui_builder_utils36.logger.error(SYSTEM_LOG_TAG4, "Account not available. Is wallet connected?");
+      import_ui_builder_utils37.logger.error(SYSTEM_LOG_TAG4, "Account not available. Is wallet connected?");
       throw new Error("Wallet is not connected or account address is unavailable.");
     }
     return { walletClient, accountStatus };
@@ -4860,7 +5023,7 @@ var AdvancedInfo = ({ showAdvancedInfo, onToggle }) => {
 // src/transaction/components/CustomGasParameters.tsx
 var import_lucide_react6 = require("lucide-react");
 var import_ui_builder_ui7 = require("@openzeppelin/ui-builder-ui");
-var import_ui_builder_utils37 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils38 = require("@openzeppelin/ui-builder-utils");
 var import_jsx_runtime9 = require("react/jsx-runtime");
 var CustomGasParameters = ({
   control,
@@ -4893,7 +5056,7 @@ var CustomGasParameters = ({
               import_ui_builder_ui7.AccordionItem,
               {
                 value: "eip1559",
-                className: (0, import_ui_builder_utils37.cn)(
+                className: (0, import_ui_builder_utils38.cn)(
                   "rounded-lg border shadow-sm overflow-hidden transition-all",
                   gasType === "eip1559" ? "border-primary bg-primary/5" : "border-border bg-card hover:border-muted-foreground/50"
                 ),
@@ -4950,7 +5113,7 @@ var CustomGasParameters = ({
               import_ui_builder_ui7.AccordionItem,
               {
                 value: "legacy",
-                className: (0, import_ui_builder_utils37.cn)(
+                className: (0, import_ui_builder_utils38.cn)(
                   "rounded-lg border shadow-sm overflow-hidden transition-all",
                   gasType === "legacy" ? "border-primary bg-primary/5" : "border-border bg-card hover:border-muted-foreground/50"
                 ),
@@ -5246,7 +5409,7 @@ var EvmRelayerOptions = ({ options, onChange }) => {
 };
 
 // src/wallet/utils/connection.ts
-var import_ui_builder_utils38 = require("@openzeppelin/ui-builder-utils");
+var import_ui_builder_utils39 = require("@openzeppelin/ui-builder-utils");
 var LOG_SYSTEM3 = "adapter-evm-connection";
 function evmSupportsWalletConnection() {
   return true;
@@ -5254,7 +5417,7 @@ function evmSupportsWalletConnection() {
 async function getEvmAvailableConnectors() {
   const impl = await getEvmWalletImplementation();
   if (!impl) {
-    import_ui_builder_utils38.logger.warn(LOG_SYSTEM3, "getEvmAvailableConnectors: Wallet implementation not ready.");
+    import_ui_builder_utils39.logger.warn(LOG_SYSTEM3, "getEvmAvailableConnectors: Wallet implementation not ready.");
     return [];
   }
   return impl.getAvailableConnectors();
@@ -5262,7 +5425,7 @@ async function getEvmAvailableConnectors() {
 async function connectAndEnsureCorrectNetwork(connectorId, targetChainId) {
   const impl = await getEvmWalletImplementation();
   if (!impl) {
-    import_ui_builder_utils38.logger.error(LOG_SYSTEM3, "connectAndEnsureCorrectNetwork: Wallet implementation not ready.");
+    import_ui_builder_utils39.logger.error(LOG_SYSTEM3, "connectAndEnsureCorrectNetwork: Wallet implementation not ready.");
     return { connected: false, error: "Wallet system not initialized." };
   }
   const connectionResult = await impl.connect(connectorId);
@@ -5270,7 +5433,7 @@ async function connectAndEnsureCorrectNetwork(connectorId, targetChainId) {
     return { connected: false, error: connectionResult.error || "Connection failed" };
   }
   if (connectionResult.chainId !== targetChainId) {
-    import_ui_builder_utils38.logger.info(
+    import_ui_builder_utils39.logger.info(
       LOG_SYSTEM3,
       `Connected to chain ${connectionResult.chainId}, but target is ${targetChainId}. Attempting switch.`
     );
@@ -5279,23 +5442,23 @@ async function connectAndEnsureCorrectNetwork(connectorId, targetChainId) {
       const postSwitchStatus = impl.getWalletConnectionStatus();
       if (postSwitchStatus.chainId !== targetChainId) {
         const switchError = `Failed to switch to target network ${targetChainId}. Current: ${postSwitchStatus.chainId}`;
-        import_ui_builder_utils38.logger.error(LOG_SYSTEM3, switchError);
+        import_ui_builder_utils39.logger.error(LOG_SYSTEM3, switchError);
         try {
           await impl.disconnect();
         } catch (e) {
-          import_ui_builder_utils38.logger.warn(LOG_SYSTEM3, "Failed to disconnect after network switch failure.", e);
+          import_ui_builder_utils39.logger.warn(LOG_SYSTEM3, "Failed to disconnect after network switch failure.", e);
         }
         return { connected: false, error: switchError };
       }
-      import_ui_builder_utils38.logger.info(LOG_SYSTEM3, `Successfully switched to target chain ${targetChainId}.`);
+      import_ui_builder_utils39.logger.info(LOG_SYSTEM3, `Successfully switched to target chain ${targetChainId}.`);
       return { ...connectionResult, chainId: postSwitchStatus.chainId };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      import_ui_builder_utils38.logger.error(LOG_SYSTEM3, "Network switch failed:", errorMessage);
+      import_ui_builder_utils39.logger.error(LOG_SYSTEM3, "Network switch failed:", errorMessage);
       try {
         await impl.disconnect();
       } catch (e) {
-        import_ui_builder_utils38.logger.warn(LOG_SYSTEM3, "Failed to disconnect after network switch failure.", e);
+        import_ui_builder_utils39.logger.warn(LOG_SYSTEM3, "Failed to disconnect after network switch failure.", e);
       }
       return { connected: false, error: `Network switch failed: ${errorMessage}` };
     }
@@ -5305,7 +5468,7 @@ async function connectAndEnsureCorrectNetwork(connectorId, targetChainId) {
 async function disconnectEvmWallet() {
   const impl = await getEvmWalletImplementation();
   if (!impl) {
-    import_ui_builder_utils38.logger.warn(LOG_SYSTEM3, "disconnectEvmWallet: Wallet implementation not ready.");
+    import_ui_builder_utils39.logger.warn(LOG_SYSTEM3, "disconnectEvmWallet: Wallet implementation not ready.");
     return { disconnected: false, error: "Wallet system not initialized." };
   }
   return impl.disconnect();
@@ -5313,7 +5476,7 @@ async function disconnectEvmWallet() {
 function getEvmWalletConnectionStatus() {
   const impl = getInitializedEvmWalletImplementation();
   if (!impl) {
-    import_ui_builder_utils38.logger.warn(
+    import_ui_builder_utils39.logger.warn(
       LOG_SYSTEM3,
       "getEvmWalletConnectionStatus: Wallet implementation not ready. Returning default disconnected state."
     );
@@ -5363,18 +5526,36 @@ var EvmAdapter = class {
       throw new Error("EvmAdapter requires a valid EVM network configuration.");
     }
     this.networkConfig = networkConfig;
-    import_ui_builder_utils39.logger.info(
+    import_ui_builder_utils40.logger.info(
       "EvmAdapter",
       `Adapter initialized for network: ${networkConfig.name} (ID: ${networkConfig.id})`
     );
     const initialGlobalConfig = loadInitialConfigFromAppService();
     this.initialAppServiceKitName = initialGlobalConfig.kitName || "custom";
-    import_ui_builder_utils39.logger.info(
+    import_ui_builder_utils40.logger.info(
       "EvmAdapter:constructor",
       "Initial kitName from AppConfigService noted:",
       this.initialAppServiceKitName
     );
   }
+  /**
+   * @inheritdoc
+   */
+  getNetworkServiceForms() {
+    return getEvmNetworkServiceForms(this.networkConfig);
+  }
+  /**
+   * @inheritdoc
+   */
+  async validateNetworkServiceConfig(serviceId, values) {
+    return validateEvmNetworkServiceConfig(serviceId, values);
+  }
+  /**
+   * @inheritdoc
+   */
+  async testNetworkServiceConnection(serviceId, values) {
+    return testEvmNetworkServiceConnection(serviceId, values, this.networkConfig);
+  }
   /**
    * @inheritdoc
    */
@@ -5586,7 +5767,7 @@ var EvmAdapter = class {
   onWalletConnectionChange(callback) {
     const walletImplementation = getInitializedEvmWalletImplementation();
     if (!walletImplementation) {
-      import_ui_builder_utils39.logger.warn(
+      import_ui_builder_utils40.logger.warn(
         "EvmAdapter:onWalletConnectionChange",
         "Wallet implementation not ready. Subscription may not work."
       );
@@ -5635,7 +5816,7 @@ var EvmAdapter = class {
       options
     );
     await evmUiKitManager.configure(finalFullConfig);
-    import_ui_builder_utils39.logger.info(
+    import_ui_builder_utils40.logger.info(
       "EvmAdapter:configureUiKit",
       "EvmUiKitManager configuration requested with final config:",
       finalFullConfig
@@ -5645,7 +5826,7 @@ var EvmAdapter = class {
    * @inheritdoc
    */
   getEcosystemReactUiContextProvider() {
-    import_ui_builder_utils39.logger.info("EvmAdapter:getEcosystemReactUiContextProvider", "Returning EvmWalletUiRoot.");
+    import_ui_builder_utils40.logger.info("EvmAdapter:getEcosystemReactUiContextProvider", "Returning EvmWalletUiRoot.");
     return EvmWalletUiRoot;
   }
   /**
@@ -5669,7 +5850,7 @@ var EvmAdapter = class {
   getEcosystemWalletComponents() {
     const currentManagerState = evmUiKitManager.getState();
     if (!currentManagerState.currentFullUiKitConfig) {
-      import_ui_builder_utils39.logger.debug(
+      import_ui_builder_utils40.logger.debug(
         // Changed from warn to debug, as this can be normal during init sequence
         "EvmAdapter:getEcosystemWalletComponents",
         "No UI kit configuration available in manager yet. Returning undefined components."
@@ -5808,7 +5989,7 @@ Get your WalletConnect projectId from <a href="https://cloud.walletconnect.com"
         summary: result.summary
       };
     } catch (error) {
-      import_ui_builder_utils39.logger.error("EVM contract definition comparison failed:", error.message);
+      import_ui_builder_utils40.logger.error("EVM contract definition comparison failed:", error.message);
       throw new Error(`Contract definition comparison failed: ${error.message}`);
     }
   }