{"version":3,"file":"index-BIrigeDI.d.cts","names":["AccessControlCapability","ExecutionConfig","NetworkConfig","TransactionStatusUpdate","TxStatus","CreateAccessControlOptions","Promise","createAccessControl","n","t","a","WriteContractParameters","o","EvmCompatibleNetworkConfig","PublicClient","TransactionReceipt","WalletClient","Speed","GetAccountReturnType","ContractSchema","ExecutionCapability","ExecutionConfig","ExecutionMethodDetail","FormFieldType","NetworkConfig","RelayerDetails","RelayerDetailsRich","TransactionStatusUpdate","TxStatus","WalletConnectionStatus","formatEvmTransactionData","Record","EvmWalletConnectionStatus","EvmWalletConnectionResult","EvmWalletDisconnectResult","EvmWalletImplementation","Promise","AdapterExecutionStrategy","EoaExecutionStrategy","EvmRelayerTransactionOptions","RelayerExecutionStrategy","signAndBroadcastEvmTransaction","executeEvmTransaction","waitForEvmTransactionConfirmation","Error","CreateExecutionOptions","createExecution","c","d","f","i","l","m","n","p","r","s","t","u","n","createAccessControl","t","CreateAccessControlOptions","createAddressing","createContractLoading","a","WriteContractParameters","c","EvmContractArtifacts","d","EvmContractDefinitionProviderKey","f","EvmProviderKeys","i","AbiItem","l","isEvmContractArtifacts","EvmProxyInfo","o","EvmCompatibleNetworkConfig","p","isEvmProviderKey","r","EvmTransactionData","s","TypedEvmNetworkConfig","EvmAbiLoadResult","u","EVM_PROVIDER_ORDER_DEFAULT","CapabilityExecutor","createERC3643","CreateERC3643Options","createERC4626","CreateERC4626Options","waitForEvmTransactionConfirmation","EoaExecutionStrategy","EvmWalletConnectionStatus","EvmWalletDisconnectResult","signAndBroadcastEvmTransaction","AdapterExecutionStrategy","m","formatEvmTransactionData","createExecution","EvmRelayerTransactionOptions","EvmWalletImplementation","executeEvmTransaction","RelayerExecutionStrategy","EvmWalletConnectionResult","createExplorer","_","buildClaimPayload","createEvmIRSService","EvmIRSServiceOptions","isTrustedIssuer","isVerified","g","DeployOnchainIdSubmittedResult","h","DeployOnchainIdOutcome","EvmIRSService","getJurisdiction","DeployOnchainIdConfirmedResult","EvmIRSAddresses","createIRS","EvmIRSExecutor","CreateIRSOptions","getOnchainId","createNetworkCatalog","createQuery","createRelayer","createSchema","createTypeMapping","createUiKit","createUiLabels","createWallet","createComposerRuntime","createDeclarativeRuntime","createOperatorRuntime","createTransactorRuntime","createViewerRuntime","Abi","AbiFunction","Chain","PublicClient","Transport","WalletClient","react0","React$1","UseDisconnectReturnType","react_jsx_runtime0","Config","GetAccountReturnType","AccessControlCapabilities","AccessControlService","AccessSnapshot","AdminInfo","Amount","BaseComponentProps","CapabilityFactoryMap","Connector","ContractDefinitionMetadata","ContractFunction","ContractSchema","EcosystemRuntime","EcosystemWalletComponents","EnrichedRoleAssignment","EoaExecutionConfig","ExecutionConfig","ExpirationMetadata","FieldType","FormFieldType","FunctionParameter","HistoryQueryOptions","NameResolutionCapability","NameResolutionError","NativeConfigLoader","NetworkConfig","OperationResult","OwnershipInfo","PaginatedHistoryResult","ProfileName","ProxyInfo","RelayerExecutionConfig","ResolutionProvenance","ResolutionResult","ResolvedAddress","ResolvedName","RoleAssignment","TransactionStatusUpdate","TransferSimulationResult","TxStatus","TypeMappingInfo","UiKitConfiguration","UserExplorerConfig","UserRpcProviderConfig","VaultDepositResult","VaultWithdrawResult","ConnectButton","RainbowKitProvider","transformAbiToSchema","createAbiFunctionItem","EtherscanAbiResult","loadAbiFromEtherscan","Promise","loadAbiFromEtherscanV1","EtherscanAbiResult$1","shouldUseV2Api","loadAbiFromEtherscanV2","testEtherscanV2Connection","SourcifyAbiResult","getSourcifyContractAppUrl","loadAbiFromSourcify","EvmContractLoadResult","ContractLoadOptions","loadEvmContract","loadContractSchema","Record","loadContractWithFullMetadata","AbiComparisonResult","AbiDifference","AbiValidationResult","isValidAbiArray","isValidAbiItem","AbiComparisonService","abiComparisonService","compareContractDefinitions","validateContractDefinition","hashContractDefinition","EVM_TYPE_TO_FIELD_TYPE","getEvmTypeMappingInfo","mapEvmParamTypeToFieldType","getEvmCompatibleFieldTypes","generateEvmDefaultField","T","parseEvmInput","formatEvmFunctionResult","queryEvmViewFunction","isEvmViewFunction","WagmiProviderInitializedContext","Context","useIsWagmiProviderInitialized","useManagedWagmiDisconnect","SafeWagmiComponent","children","fallback","ReactNode","JSX","Element","ConnectButtonProps","CustomConnectButton","FC","ConnectorDialogProps","ConnectorDialog","CustomAccountDisplay","CustomNetworkSwitcher","DEFAULT_DISCONNECTED_STATUS","connectAndEnsureCorrectNetworkCore","WalletNetworkConfig","WagmiWalletConfig","WagmiConfigChains","GetWagmiConfigForRainbowKitFn","WagmiWalletImplementation","RainbowKitConfigOptions","generateRainbowKitConfigFile","generateRainbowKitExportables","AppInfo","React","ComponentProps","RainbowKitConnectButtonProps","RainbowKitProviderProps","RainbowKitKitConfig","Partial","RainbowKitCustomizations","isRainbowKitCustomizations","extractRainbowKitCustomizations","validateRainbowKitConfig","getRawUserNativeConfig","UiKitManagerState","PropsWithChildren","ComponentType","Error","RainbowKitAssetsResult","UiKitManagerDependencies","UiKitManager","createUiKitManager","RainbowKitConnectButtonProps$1","createRainbowKitConnectButton","createRainbowKitComponents","createRainbowKitWagmiConfig","getWagmiConfigForRainbowKit","ensureRainbowKitAssetsLoaded","resolveAndInitializeKitConfig","resolveFullUiKitConfiguration","filterWalletComponents","Array","getComponentExclusionsFromConfig","buildRpcUrl","getUserRpcUrl","resolveRpcUrl","validateEvmRpcEndpoint","testEvmRpcConnection","getEvmCurrentBlock","resolveExplorerApiKeyFromAppConfig","resolveExplorerConfig","getEvmExplorerAddressUrl","getEvmExplorerTxUrl","validateEvmExplorerConfig","testEvmExplorerConnection","getUserAccessControlIndexerUrl","resolveAccessControlIndexerUrl","validateEvmNetworkServiceConfig","testEvmNetworkServiceConnection","ProxyDetectionResult","detectProxyFromAbi","getImplementationAddress","getAdminAddress","EvmWalletStatus","validateEoaConfig","validateEvmEoaConfig","validateRelayerConfig","validateEvmRelayerConfig","validateEvmExecutionConfig","isValidEvmAddress","validateAndConvertEvmArtifacts","stringifyWithBigInt","formatMethodName","formatInputName","createEvmPublicClient","weiToGwei","gweiToWei","assembleTransferOwnershipAction","assembleAcceptOwnershipAction","assembleRenounceOwnershipAction","assembleBeginAdminTransferAction","assembleAcceptAdminTransferAction","assembleCancelAdminTransferAction","assembleChangeAdminDelayAction","assembleRollbackAdminDelayAction","assembleGrantRoleAction","assembleRevokeRoleAction","assembleRenounceRoleAction","DEFAULT_ADMIN_ROLE","DEFAULT_ADMIN_ROLE_LABEL","ZERO_ADDRESS","detectAccessControlCapabilities","validateAccessControlSupport","PendingOwnershipTransferData","PendingAdminTransferData","GrantInfo","EvmIndexerClient","Map","createIndexerClient","OwnershipReadResult","AdminReadResult","readOwnership","getAdmin","readCurrentRoles","getCurrentBlock","EvmAccessControlContext","EvmTransactionExecutor","EvmAccessControlService","createEvmAccessControlService","validateAddress","validateRoleId","validateRoleIds","CreateNameResolutionOptions","createNameResolution","Erc3643ErrorContext","mapErc3643Error","EvmErc3643Executor","EvmErc3643ServiceOptions","EvmErc3643Service","createEvmErc3643Service","Erc4626Operation","Erc4626ErrorContext","mapErc4626Error","EvmErc4626Executor","EvmErc4626ServiceOptions","EvmErc4626Service","createEvmErc4626Service","ELAPSED_UNMEASURED","NameResolutionErrorContext","nameNotFound","Extract","addressNotFound","unsupportedName","unsupportedNetwork","mapNameResolutionError","EnsProvenance","isEnsProvenance","scopedNetworkId","buildEnsProvenance","deriveCoinType","isValidName","normalizeName","MAINNET_NETWORK_ID","networkFallbackProvenanceFields","Pick","composeNetworkFallbackProvenance","baseEnsProvenance","boundReverseProvenance","EvmNameResolutionService","CreateEvmNameResolutionServiceOptions","createEvmNameResolutionService","createRuntime","getIrsJurisdiction","isIrsVerified"],"sources":["../../adapter-evm-core/dist/access-control-D7zWxavD.d.mts","../../adapter-evm-core/dist/execution-DfFyYNaI.d.mts","../../adapter-evm-core/dist/index.d.mts"],"sourcesContent":["import { AccessControlCapability, ExecutionConfig, NetworkConfig, TransactionStatusUpdate, TxStatus } from \"@openzeppelin/ui-types\";\n\n//#region src/capabilities/access-control.d.ts\ninterface CreateAccessControlOptions {\n  signAndBroadcast: (transactionData: unknown, executionConfig: ExecutionConfig, onStatusChange: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string) => Promise<{\n    txHash: string;\n    result?: unknown;\n  }>;\n}\ndeclare function createAccessControl(config: NetworkConfig, options: CreateAccessControlOptions): AccessControlCapability;\n//#endregion\nexport { createAccessControl as n, CreateAccessControlOptions as t };\n//# sourceMappingURL=access-control-D7zWxavD.d.mts.map","import { a as WriteContractParameters, o as EvmCompatibleNetworkConfig } from \"./index-CmTidOM3.mjs\";\nimport { PublicClient, TransactionReceipt, WalletClient } from \"viem\";\nimport { Speed } from \"@openzeppelin/relayer-sdk\";\nimport { GetAccountReturnType } from \"@wagmi/core\";\nimport { ContractSchema, ExecutionCapability, ExecutionConfig, ExecutionMethodDetail, FormFieldType, NetworkConfig, RelayerDetails, RelayerDetailsRich, TransactionStatusUpdate, TxStatus, WalletConnectionStatus } from \"@openzeppelin/ui-types\";\n\n//#region src/transaction/formatter.d.ts\n\n/**\n * Formats transaction data for EVM chains based on parsed inputs.\n *\n * @param contractSchema The contract schema.\n * @param functionId The ID of the function being called.\n * @param submittedInputs The raw data submitted from the form.\n * @param fields The fields of the form schema.\n * @returns The formatted data payload suitable for signAndBroadcast.\n */\ndeclare function formatEvmTransactionData(contractSchema: ContractSchema, functionId: string, submittedInputs: Record<string, unknown>, fields: FormFieldType[]): WriteContractParameters;\n//#endregion\n//#region src/transaction/types.d.ts\n/**\n * Wallet connection status from wagmi.\n * Re-exported from @wagmi/core for convenience.\n */\ntype EvmWalletConnectionStatus = GetAccountReturnType;\n/**\n * Minimal interface for EVM wallet implementations.\n *\n * This interface defines what execution strategies need from a wallet implementation.\n * Different adapters can provide their own implementations (e.g., WagmiWalletImplementation\n * in adapter-evm, or a simpler implementation in adapter-polkadot) as long as they\n * implement this interface.\n *\n * @example\n * ```typescript\n * // In adapter-evm:\n * class WagmiWalletImplementation implements EvmWalletImplementation {\n *   // Full implementation with RainbowKit, etc.\n * }\n *\n * // In adapter-polkadot:\n * class PolkadotWalletImplementation implements EvmWalletImplementation {\n *   // Simpler implementation for Polkadot chains\n * }\n * ```\n */\n/**\n * Result of a wallet connection attempt.\n */\ninterface EvmWalletConnectionResult {\n  connected: boolean;\n  address?: string;\n  chainId?: number;\n  error?: string;\n}\n/**\n * Result of a wallet disconnection attempt.\n */\ninterface EvmWalletDisconnectResult {\n  disconnected: boolean;\n  error?: string;\n}\ninterface EvmWalletImplementation {\n  /**\n   * Get the wallet client for signing transactions.\n   * @returns The viem WalletClient or null if not connected\n   */\n  getWalletClient(): Promise<WalletClient | null>;\n  /**\n   * Get the public client for reading chain data.\n   * @returns The viem PublicClient or null if not available\n   */\n  getPublicClient(): Promise<PublicClient | null>;\n  /**\n   * Get the current wallet connection status.\n   * @returns The connection status including address, chainId, isConnected, etc.\n   */\n  getWalletConnectionStatus(): EvmWalletConnectionStatus;\n  /**\n   * Switch to a different chain.\n   * @param chainId - The target chain ID to switch to\n   */\n  switchNetwork(chainId: number): Promise<void>;\n  /**\n   * Connect to a wallet using the specified connector.\n   * @param connectorId - The ID of the connector to use\n   * @returns The connection result including address and chainId\n   */\n  connect(connectorId: string): Promise<EvmWalletConnectionResult>;\n  /**\n   * Disconnect the currently connected wallet.\n   * @returns The disconnection result\n   */\n  disconnect(): Promise<EvmWalletDisconnectResult>;\n}\n//#endregion\n//#region src/transaction/execution-strategy.d.ts\n/**\n * Defines a common interface for different transaction execution strategies (e.g., EOA, Relayer).\n * This allows the adapter to remain a lean orchestrator that selects the appropriate strategy\n * at runtime based on the user's configuration.\n *\n * Concrete implementations of this interface (EoaExecutionStrategy, RelayerExecutionStrategy) are\n * available in this transaction module and can be used by any EVM-compatible adapter.\n */\ninterface AdapterExecutionStrategy {\n  /**\n   * Executes a transaction according to the specific strategy.\n   *\n   * @param transactionData The contract write parameters, including ABI, function name, and args.\n   * @param executionConfig The configuration for the selected execution method.\n   * @param walletImplementation The wallet implementation providing signing capabilities.\n   * @param onStatusChange A callback to report real-time status updates to the UI.\n   * @param runtimeApiKey Optional session-only API key for methods like Relayer.\n   * @returns A promise that resolves to an object containing the final transaction hash.\n   */\n  execute(transactionData: WriteContractParameters, executionConfig: ExecutionConfig, walletImplementation: EvmWalletImplementation, onStatusChange: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<{\n    txHash: string;\n  }>;\n}\n//#endregion\n//#region src/transaction/eoa.d.ts\n/**\n * Implements the ExecutionStrategy for a standard Externally Owned Account (EOA).\n * This strategy involves signing and broadcasting a transaction directly from the user's\n * connected wallet, which is the most common way of interacting with a blockchain.\n */\ndeclare class EoaExecutionStrategy implements AdapterExecutionStrategy {\n  execute(transactionData: WriteContractParameters, executionConfig: ExecutionConfig, walletImplementation: EvmWalletImplementation, onStatusChange: (status: TxStatus, details: TransactionStatusUpdate) => void, _runtimeApiKey?: string): Promise<{\n    txHash: string;\n  }>;\n  private getAuthenticatedWalletClient;\n}\n//#endregion\n//#region src/transaction/relayer.d.ts\n/**\n * EVM-specific transaction options for the OpenZeppelin Relayer.\n * These options map directly to the EvmTransactionRequest parameters in the SDK.\n */\ninterface EvmRelayerTransactionOptions {\n  speed?: Speed;\n  gasLimit?: number;\n  gasPrice?: number;\n  maxFeePerGas?: number;\n  maxPriorityFeePerGas?: number;\n  validUntil?: string;\n}\n/**\n * Implements the ExecutionStrategy for the OpenZeppelin Relayer.\n * This strategy sends the transaction to the relayer service, which then handles\n * gas payment, signing, and broadcasting. It includes a polling mechanism to wait\n * for the transaction to be mined and return the final hash.\n */\ndeclare class RelayerExecutionStrategy implements AdapterExecutionStrategy {\n  execute(transactionData: WriteContractParameters, executionConfig: ExecutionConfig, _walletImplementation: EvmWalletImplementation, onStatusChange: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<{\n    txHash: string;\n  }>;\n  /**\n   * Fetches and filters relayers for a specific EVM network from the OpenZeppelin Relayer service.\n   * This function handles pagination to retrieve all available relayers.\n   *\n   * @param serviceUrl - The base URL of the relayer service.\n   * @param accessToken - The session-based API key for authentication.\n   * @param networkConfig - EVM-compatible network configuration to filter relayers by (works with any ecosystem).\n   * @returns A promise that resolves to an array of compatible relayer details.\n   * @throws If the API call fails or returns an unsuccessful response.\n   */\n  getEvmRelayers(serviceUrl: string, accessToken: string, networkConfig: EvmCompatibleNetworkConfig): Promise<RelayerDetails[]>;\n  /**\n   * Fetches comprehensive information about a specific relayer including balance and status.\n   * This function combines multiple SDK API calls to provide rich relayer details.\n   *\n   * @param serviceUrl - The base URL of the relayer service.\n   * @param accessToken - The session-based API key for authentication.\n   * @param relayerId - The unique identifier of the relayer.\n   * @param networkConfig - EVM-compatible network configuration to get the native currency symbol (works with any ecosystem).\n   * @returns A promise that resolves to enhanced relayer details including balance and status.\n   * @throws If any API call fails or returns an unsuccessful response.\n   */\n  getEvmRelayer(serviceUrl: string, accessToken: string, relayerId: string, networkConfig: EvmCompatibleNetworkConfig): Promise<RelayerDetailsRich>;\n  /**\n   * Submits a transaction to the relayer service for asynchronous processing.\n   * @param transactionData The contract write parameters.\n   * @param executionConfig The relayer-specific execution configuration.\n   * @param runtimeApiKey The user's session-only API key.\n   * @returns A promise that resolves to an object containing the transaction ID assigned by the relayer.\n   */\n  private sendTransactionViaRelayer;\n  /**\n   * Polls the relayer for a transaction's status until it is mined and has a hash, or fails.\n   * @param relayerId The ID of the relayer processing the transaction.\n   * @param transactionId The ID of the transaction to poll.\n   * @param sdkConfig The SDK configuration containing the necessary authentication.\n   * @returns A promise that resolves to the final transaction hash.\n   * @throws If the transaction fails or polling times out.\n   */\n  private pollForTransactionHash;\n}\n//#endregion\n//#region src/transaction/sender.d.ts\n/**\n * Sign and broadcast an EVM transaction using the provided wallet implementation.\n *\n * This function handles:\n * - Network switching (if wallet is on wrong chain)\n * - Transaction signing via the wallet\n * - Transaction broadcasting\n *\n * @param transactionData - The contract write parameters\n * @param walletImplementation - The wallet implementation to use for signing\n * @param targetChainId - The chain ID to execute the transaction on\n * @param executionConfig - Optional execution configuration (for future method support)\n * @returns The transaction hash\n */\ndeclare function signAndBroadcastEvmTransaction(transactionData: WriteContractParameters, walletImplementation: EvmWalletImplementation, targetChainId: number, executionConfig?: ExecutionConfig): Promise<{\n  txHash: string;\n}>;\n/**\n * Sign and broadcast a transaction using the appropriate execution strategy.\n * This is a high-level router function that selects EOA or Relayer strategy\n * based on the execution configuration.\n *\n * @param transactionData - The contract write parameters\n * @param executionConfig - The execution configuration specifying method (eoa, relayer, multisig)\n * @param walletImplementation - The wallet implementation to use for signing\n * @param onStatusChange - Callback for status updates during transaction lifecycle\n * @param runtimeApiKey - Optional API key for relayer execution\n * @returns The transaction hash\n */\ndeclare function executeEvmTransaction(transactionData: WriteContractParameters, executionConfig: ExecutionConfig, walletImplementation: EvmWalletImplementation, onStatusChange: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<{\n  txHash: string;\n}>;\n/**\n * Waits for a transaction to be confirmed on the blockchain.\n *\n * @param txHash - The transaction hash to wait for\n * @param walletImplementation - The wallet implementation to get the public client from\n * @returns The transaction status and receipt\n */\ndeclare function waitForEvmTransactionConfirmation(txHash: string, walletImplementation: EvmWalletImplementation): Promise<{\n  status: 'success' | 'error';\n  receipt?: TransactionReceipt;\n  error?: Error;\n}>;\n//#endregion\n//#region src/capabilities/execution.d.ts\ninterface CreateExecutionOptions {\n  getSupportedExecutionMethods?: () => Promise<ExecutionMethodDetail[]>;\n  getWalletConnectionStatus?: () => WalletConnectionStatus;\n  getWalletImplementation: () => Promise<EvmWalletImplementation>;\n}\ndeclare function createExecution(config: NetworkConfig, options: CreateExecutionOptions): ExecutionCapability;\n//#endregion\nexport { waitForEvmTransactionConfirmation as a, EoaExecutionStrategy as c, EvmWalletConnectionStatus as d, EvmWalletDisconnectResult as f, signAndBroadcastEvmTransaction as i, AdapterExecutionStrategy as l, formatEvmTransactionData as m, createExecution as n, EvmRelayerTransactionOptions as o, EvmWalletImplementation as p, executeEvmTransaction as r, RelayerExecutionStrategy as s, CreateExecutionOptions as t, EvmWalletConnectionResult as u };\n//# sourceMappingURL=execution-DfFyYNaI.d.mts.map","import { n as createAccessControl, t as CreateAccessControlOptions } from \"./access-control-D7zWxavD.mjs\";\nimport { t as createAddressing } from \"./addressing-FVwEm88E.mjs\";\nimport { t as createContractLoading } from \"./contract-loading-Ofr7URjr.mjs\";\nimport { a as WriteContractParameters, c as EvmContractArtifacts, d as EvmContractDefinitionProviderKey, f as EvmProviderKeys, i as AbiItem, l as isEvmContractArtifacts, n as EvmProxyInfo, o as EvmCompatibleNetworkConfig, p as isEvmProviderKey, r as EvmTransactionData, s as TypedEvmNetworkConfig, t as EvmAbiLoadResult, u as EVM_PROVIDER_ORDER_DEFAULT } from \"./index-CmTidOM3.mjs\";\nimport { n as CapabilityExecutor } from \"./helpers-ZShvV2Sa.mjs\";\nimport { n as createERC3643, t as CreateERC3643Options } from \"./erc3643-BxgLdRs1.mjs\";\nimport { n as createERC4626, t as CreateERC4626Options } from \"./erc4626-DTDMsHkP.mjs\";\nimport { a as waitForEvmTransactionConfirmation, c as EoaExecutionStrategy, d as EvmWalletConnectionStatus, f as EvmWalletDisconnectResult, i as signAndBroadcastEvmTransaction, l as AdapterExecutionStrategy, m as formatEvmTransactionData, n as createExecution, o as EvmRelayerTransactionOptions, p as EvmWalletImplementation, r as executeEvmTransaction, s as RelayerExecutionStrategy, u as EvmWalletConnectionResult } from \"./execution-DfFyYNaI.mjs\";\nimport { t as createExplorer } from \"./explorer-16s3Bcqh.mjs\";\nimport { _ as buildClaimPayload, a as createEvmIRSService, c as EvmIRSServiceOptions, d as isTrustedIssuer, f as isVerified, g as DeployOnchainIdSubmittedResult, h as DeployOnchainIdOutcome, i as EvmIRSService, l as getJurisdiction, m as DeployOnchainIdConfirmedResult, o as EvmIRSAddresses, r as createIRS, s as EvmIRSExecutor, t as CreateIRSOptions, u as getOnchainId } from \"./irs-B3kbyWmK.mjs\";\nimport { t as createNetworkCatalog } from \"./network-catalog-DhgvLZjC.mjs\";\nimport { n as createQuery } from \"./query-DPMIFBsS.mjs\";\nimport { n as createRelayer } from \"./relayer-T6MayhUn.mjs\";\nimport { t as createSchema } from \"./schema-dmMWX1QQ.mjs\";\nimport { t as createTypeMapping } from \"./type-mapping-jutXmqoS.mjs\";\nimport { n as createUiKit } from \"./ui-kit-Cdrce7VX.mjs\";\nimport { t as createUiLabels } from \"./ui-labels-N0WSrYid.mjs\";\nimport { n as createWallet } from \"./wallet-CZcALjFS.mjs\";\nimport { t as createComposerRuntime } from \"./composer-XDKteMoA.mjs\";\nimport { t as createDeclarativeRuntime } from \"./declarative-B8R_RuUx.mjs\";\nimport { t as createOperatorRuntime } from \"./operator-3HeOGvV5.mjs\";\nimport { t as createTransactorRuntime } from \"./transactor-C3N4cyA-.mjs\";\nimport { t as createViewerRuntime } from \"./viewer-C_CF4A6g.mjs\";\nimport { Abi, AbiFunction, Chain, PublicClient, Transport, WalletClient } from \"viem\";\nimport * as react0 from \"react\";\nimport React$1 from \"react\";\nimport { UseDisconnectReturnType } from \"wagmi\";\nimport * as react_jsx_runtime0 from \"react/jsx-runtime\";\nimport { Config, GetAccountReturnType } from \"@wagmi/core\";\nimport { AccessControlCapabilities, AccessControlService, AccessSnapshot, AdminInfo, Amount, BaseComponentProps, CapabilityFactoryMap, Connector, ContractDefinitionMetadata, ContractFunction, ContractSchema, EcosystemRuntime, EcosystemWalletComponents, EnrichedRoleAssignment, EoaExecutionConfig, ExecutionConfig, ExpirationMetadata, FieldType, FormFieldType, FunctionParameter, HistoryQueryOptions, NameResolutionCapability, NameResolutionError, NativeConfigLoader, NetworkConfig, OperationResult, OwnershipInfo, PaginatedHistoryResult, ProfileName, ProxyInfo, RelayerExecutionConfig, ResolutionProvenance, ResolutionResult, ResolvedAddress, ResolvedName, RoleAssignment, TransactionStatusUpdate, TransferSimulationResult, TxStatus, TypeMappingInfo, UiKitConfiguration, UserExplorerConfig, UserRpcProviderConfig, VaultDepositResult, VaultWithdrawResult } from \"@openzeppelin/ui-types\";\nimport { ConnectButton, RainbowKitProvider } from \"@rainbow-me/rainbowkit\";\n\n//#region src/abi/transformer.d.ts\n/**\n * Transforms a standard ABI array (typically from an EVM-compatible chain)\n * into the project's internal `ContractSchema` format.\n * This schema is used by the builder app and renderer to represent contract interactions\n * in a chain-agnostic way (though this specific transformer is for EVM ABIs).\n *\n * @param abi The raw ABI array (e.g., parsed from a JSON ABI file or fetched from Etherscan).\n *            It's expected to be an array of `AbiItem` (from viem types or a compatible structure).\n * @param contractName A name to assign to the contract within the schema. This might be derived\n *                     from a file name, user input, or a default if not otherwise available.\n * @param address Optional address of the deployed contract. If provided, it's included in the schema.\n * @returns A `ContractSchema` object representing the contract's interface.\n */\ndeclare function transformAbiToSchema(abi: readonly AbiItem[], contractName: string, address?: string): ContractSchema;\n/**\n * Private helper to convert internal `ContractFunction` details (our model)\n * back into a viem `AbiFunction` object.\n * This is useful when interacting with libraries like viem that expect a standard ABI format.\n * Ensures that the generated AbiFunction conforms to viem's type definitions.\n *\n * @param functionDetails The `ContractFunction` object from our internal schema.\n * @returns An `AbiFunction` object.\n */\ndeclare function createAbiFunctionItem(functionDetails: ContractFunction): AbiFunction;\n//#endregion\n//#region src/abi/etherscan.d.ts\n/**\n * Result type for Etherscan ABI loading that includes the original ABI string\n */\ninterface EtherscanAbiResult {\n  schema: ContractSchema;\n  originalAbi: string;\n}\n/**\n * IMPORTANT: Etherscan V1 API Deprecation Notice\n *\n * Etherscan has announced the deprecation of their V1 API endpoints in favor of the new V2 unified API.\n * The V2 API provides a single endpoint that works across all EVM chains, making it more scalable and\n * easier to maintain.\n *\n * Key differences:\n * - V1: Each chain has its own API endpoint (e.g., api.etherscan.io, api.bscscan.com, etc.)\n * - V2: Single unified endpoint (api.etherscan.io/v2/api) with chainId parameter\n *\n * Migration strategy:\n * - Networks with `supportsEtherscanV2: true` will automatically use V2 API\n * - Legacy networks without V2 support will continue using V1 until they're updated\n * - New networks should always be configured with V2 support\n *\n * The V1 API functions are maintained for backward compatibility but should be considered\n * deprecated and will be removed in a future release.\n */\n/**\n * Fetches and parses an ABI from Etherscan-compatible explorers using a contract address and network config.\n * Automatically selects V1 or V2 API based on network support and user configuration.\n *\n * @param address - Contract address to fetch ABI for\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n */\ndeclare function loadAbiFromEtherscan(address: string, networkConfig: EvmCompatibleNetworkConfig): Promise<EtherscanAbiResult>;\n/**\n * Fetches and parses an ABI from Etherscan V1 API using a contract address and network config.\n *\n * @param address - Contract address to fetch ABI for\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n */\ndeclare function loadAbiFromEtherscanV1(address: string, networkConfig: EvmCompatibleNetworkConfig): Promise<EtherscanAbiResult>;\n//#endregion\n//#region src/abi/etherscan-v2.d.ts\n/**\n * Result type for Etherscan ABI loading that includes the original ABI string\n */\ninterface EtherscanAbiResult$1 {\n  schema: ContractSchema;\n  originalAbi: string;\n}\n/**\n * Checks if the network supports V2 API\n *\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n */\ndeclare function shouldUseV2Api(networkConfig: EvmCompatibleNetworkConfig): boolean;\n/**\n * Fetches and parses an ABI from Etherscan V2 API using a contract address and network config.\n *\n * @param address - Contract address to fetch ABI for\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n */\ndeclare function loadAbiFromEtherscanV2(address: string, networkConfig: EvmCompatibleNetworkConfig): Promise<EtherscanAbiResult$1>;\n/**\n * Test connection to Etherscan V2 API\n *\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n * @param apiKey - Optional API key for authentication\n */\ndeclare function testEtherscanV2Connection(networkConfig: EvmCompatibleNetworkConfig, apiKey?: string): Promise<{\n  success: boolean;\n  latency?: number;\n  error?: string;\n}>;\n//#endregion\n//#region src/abi/sourcify.d.ts\ninterface SourcifyAbiResult {\n  schema: ContractSchema;\n  originalAbi: string;\n}\ndeclare function getSourcifyContractAppUrl(chainId: number, address: string): string;\n/**\n * Fetches and parses an ABI from Sourcify using a contract address and network config.\n *\n * @param address - Contract address to fetch ABI for\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n * @param timeoutMs - Timeout in milliseconds (default: 4000ms)\n */\ndeclare function loadAbiFromSourcify(address: string, networkConfig: EvmCompatibleNetworkConfig, timeoutMs?: number): Promise<SourcifyAbiResult>;\n//#endregion\n//#region src/abi/loader.d.ts\n/**\n * Enhanced result type for ABI loading with metadata and proxy information\n */\ninterface EvmContractLoadResult {\n  schema: ContractSchema;\n  source: 'fetched' | 'manual';\n  contractDefinitionOriginal?: string;\n  metadata?: ContractDefinitionMetadata;\n  proxyInfo?: ProxyInfo;\n}\n/**\n * Options for contract loading behavior\n */\ninterface ContractLoadOptions {\n  /** Skip proxy detection and load the contract ABI as-is */\n  skipProxyDetection?: boolean;\n  /** Force treating the address as an implementation contract */\n  treatAsImplementation?: boolean;\n}\n/**\n * Loads contract schema from artifacts provided by the UI, prioritizing manual ABI input.\n * Returns enhanced result with schema source information and automatic proxy detection.\n *\n * @param artifacts - Contract artifacts containing address and optional ABI\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n * @param options - Optional loading options\n */\ndeclare function loadEvmContract(artifacts: EvmContractArtifacts, networkConfig: EvmCompatibleNetworkConfig, options?: ContractLoadOptions): Promise<EvmContractLoadResult>;\n/**\n * Convenience wrapper that loads a contract and returns just the schema.\n * Handles artifact validation, ABI fetching, and proxy detection.\n *\n * @param source - Contract address string or artifacts object\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n * @param options - Optional loading options\n * @returns The contract schema\n *\n * @example\n * ```typescript\n * // Load by address (fetches ABI from explorer)\n * const schema = await loadContractSchema('0x1234...', networkConfig);\n *\n * // Load with manual ABI\n * const schema = await loadContractSchema(\n *   { contractAddress: '0x1234...', contractDefinition: '[...]' },\n *   networkConfig\n * );\n * ```\n */\ndeclare function loadContractSchema(source: string | Record<string, unknown>, networkConfig: EvmCompatibleNetworkConfig, options?: ContractLoadOptions): Promise<ContractSchema>;\n/**\n * Convenience wrapper that loads a contract with full metadata.\n * Returns schema, source information, original ABI, metadata, and proxy info.\n *\n * @param source - Contract address string or artifacts object\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n * @returns Full contract load result with metadata\n *\n * @example\n * ```typescript\n * const result = await loadContractWithFullMetadata('0x1234...', networkConfig);\n * console.log(result.schema.name);          // Contract name\n * console.log(result.source);               // 'fetched' | 'manual'\n * console.log(result.metadata?.fetchedFrom); // Explorer URL\n * console.log(result.proxyInfo?.isProxy);   // Proxy detection result\n * ```\n */\ndeclare function loadContractWithFullMetadata(source: string | Record<string, unknown>, networkConfig: EvmCompatibleNetworkConfig): Promise<EvmContractLoadResult>;\n//#endregion\n//#region src/abi/types.d.ts\n/**\n * Result of comparing two ABIs\n */\ninterface AbiComparisonResult {\n  /** Whether the ABIs are identical after normalization */\n  identical: boolean;\n  /** List of differences found between the ABIs */\n  differences: AbiDifference[];\n  /** Overall severity of the changes */\n  severity: 'none' | 'minor' | 'major' | 'breaking';\n  /** Human-readable summary of the comparison */\n  summary: string;\n}\n/**\n * Represents a single difference between two ABIs\n */\ninterface AbiDifference {\n  /** Type of change */\n  type: 'added' | 'removed' | 'modified';\n  /** Which section of the ABI was affected */\n  section: 'function' | 'event' | 'constructor' | 'error' | 'fallback' | 'receive';\n  /** Name of the affected item (or type if no name) */\n  name: string;\n  /** Detailed description of the change */\n  details: string;\n  /** Impact level of this change */\n  impact: 'low' | 'medium' | 'high';\n  /** Signature before the change (for removed/modified) */\n  oldSignature?: string;\n  /** Signature after the change (for added/modified) */\n  newSignature?: string;\n}\n/**\n * Result of validating an ABI structure\n */\ninterface AbiValidationResult {\n  /** Whether the ABI is structurally valid */\n  valid: boolean;\n  /** List of validation errors found */\n  errors: string[];\n  /** List of validation warnings */\n  warnings: string[];\n  /** Normalized ABI if validation passed */\n  normalizedAbi?: Abi;\n}\n/**\n * Type guard to check if a value is a valid ABI array\n */\ndeclare function isValidAbiArray(value: unknown): value is Abi;\n/**\n * Type guard to check if a value is a valid ABI item\n */\ndeclare function isValidAbiItem(item: unknown): boolean;\n//#endregion\n//#region src/abi/comparison.d.ts\n/**\n * Service for comparing and validating EVM ABIs\n */\ndeclare class AbiComparisonService {\n  /**\n   * Compares two ABIs and returns detailed difference analysis\n   */\n  compareAbis(abi1: string, abi2: string): AbiComparisonResult;\n  /**\n   * Validates ABI structure and format\n   */\n  validateAbi(abiString: string): AbiValidationResult;\n  /**\n   * Creates deterministic hash of ABI for quick comparison\n   */\n  hashAbi(abiString: string): string;\n  /**\n   * Normalizes ABI for consistent comparison\n   */\n  private normalizeAbi;\n  /**\n   * Finds detailed differences between two normalized ABIs\n   */\n  private findDifferences;\n  private createAbiMap;\n  private generateItemKey;\n  private generateSignature;\n  private itemsEqual;\n  private calculateImpact;\n  private calculateSeverity;\n  private generateSummary;\n}\ndeclare const abiComparisonService: AbiComparisonService;\n/**\n * Compare two contract definitions (ABI strings).\n * Convenience wrapper around abiComparisonService.compareAbis().\n *\n * @param storedSchema - The stored/original ABI JSON string\n * @param freshSchema - The new/fresh ABI JSON string to compare against\n * @returns Comparison result with differences and severity\n *\n * @example\n * ```typescript\n * const result = await compareContractDefinitions(oldAbi, newAbi);\n * if (!result.identical) {\n *   console.log(`Changes detected: ${result.summary}`);\n *   console.log(`Severity: ${result.severity}`);\n * }\n * ```\n */\ndeclare function compareContractDefinitions(storedSchema: string, freshSchema: string): Promise<AbiComparisonResult>;\n/**\n * Validate a contract definition (ABI string).\n * Convenience wrapper around abiComparisonService.validateAbi().\n *\n * @param definition - The ABI JSON string to validate\n * @returns Validation result with errors and warnings\n *\n * @example\n * ```typescript\n * const result = validateContractDefinition(abiJson);\n * if (!result.valid) {\n *   console.log('Validation errors:', result.errors);\n * }\n * ```\n */\ndeclare function validateContractDefinition(definition: string): AbiValidationResult;\n/**\n * Hash a contract definition (ABI string) for comparison.\n * Convenience wrapper around abiComparisonService.hashAbi().\n *\n * @param definition - The ABI JSON string to hash\n * @returns Deterministic hash of the normalized ABI\n *\n * @example\n * ```typescript\n * const hash1 = hashContractDefinition(abi1);\n * const hash2 = hashContractDefinition(abi2);\n * if (hash1 === hash2) {\n *   console.log('ABIs are identical');\n * }\n * ```\n */\ndeclare function hashContractDefinition(definition: string): string;\n//#endregion\n//#region src/mapping/constants.d.ts\n/**\n * EVM-specific type mapping to default form field types.\n *\n * Note: Large integer types (uint128, uint256, int128, int256) are mapped to 'bigint'\n * instead of 'number' to avoid JavaScript's Number precision limitations.\n * JavaScript's Number type can only safely represent integers up to 2^53 - 1,\n * but these types can hold much larger values. The BigIntField component stores values\n * as strings and the EVM adapter handles BigInt conversion automatically.\n */\ndeclare const EVM_TYPE_TO_FIELD_TYPE: Record<string, FieldType>;\n/**\n * Returns complete type mapping information for EVM.\n */\ndeclare function getEvmTypeMappingInfo(): TypeMappingInfo;\n//#endregion\n//#region src/mapping/type-mapper.d.ts\n/**\n * Map a blockchain-specific parameter type to a default form field type.\n * @param parameterType The blockchain parameter type (e.g., 'uint256', 'address', 'tuple')\n * @returns The appropriate default form field type (e.g., 'number', 'blockchain-address', 'object')\n */\ndeclare function mapEvmParamTypeToFieldType(parameterType: string): FieldType;\n/**\n * Get field types compatible with a specific parameter type.\n * @param parameterType The blockchain parameter type.\n * @returns Array of compatible form field types.\n */\ndeclare function getEvmCompatibleFieldTypes(parameterType: string): FieldType[];\n//#endregion\n//#region src/mapping/field-generator.d.ts\n/**\n * Generate default field configuration for an EVM function parameter.\n */\ndeclare function generateEvmDefaultField<T extends FieldType = FieldType>(parameter: FunctionParameter): FormFieldType<T>;\n//#endregion\n//#region src/transform/input-parser.d.ts\n/**\n * Recursively parses a raw input value based on its expected ABI type definition.\n *\n * @param param The ABI parameter definition ({ name, type, components?, ... })\n * @param rawValue The raw value obtained from the form input or hardcoded config.\n * @param isRecursive Internal flag to indicate if the call is nested.\n * @returns The parsed and typed value suitable for ABI encoding.\n * @throws {Error} If parsing or type validation fails.\n */\ndeclare function parseEvmInput(param: FunctionParameter, rawValue: unknown, isRecursive?: boolean): unknown;\n//#endregion\n//#region src/transform/output-formatter.d.ts\n/**\n * Formats the decoded result of an EVM view function call into a user-friendly string.\n *\n * @param decodedValue The decoded value (can be primitive, array, object, BigInt).\n * @param functionDetails The ABI details of the function called.\n * @returns A string representation suitable for display.\n */\ndeclare function formatEvmFunctionResult(decodedValue: unknown, functionDetails: ContractFunction): string;\n//#endregion\n//#region src/query/handler.d.ts\n/**\n * Core logic for querying an EVM view function.\n * This is a stateless version that accepts an RPC URL directly.\n *\n * @param contractAddress - Address of the contract.\n * @param functionId - ID of the function to query.\n * @param params - Raw parameters for the function call.\n * @param schema - Contract schema with function definitions.\n * @param rpcUrl - RPC URL to use for the query.\n * @param networkConfig - Optional EVM-compatible network configuration for chain metadata (works with any ecosystem).\n * @returns The decoded result of the view function call.\n */\ndeclare function queryEvmViewFunction(contractAddress: string, functionId: string, params: unknown[], schema: ContractSchema, rpcUrl: string, networkConfig?: EvmCompatibleNetworkConfig): Promise<unknown>;\n//#endregion\n//#region src/query/view-checker.d.ts\n/**\n * Determines if a function is a view/pure function (read-only).\n * @param functionDetails The function details from the contract schema.\n * @returns True if the function is read-only, false otherwise.\n */\ndeclare function isEvmViewFunction(functionDetails: ContractFunction): boolean;\n//#endregion\n//#region src/wallet/context/wagmi-context.d.ts\n/**\n * Context to track Wagmi provider initialization status\n * Used by components to safely render when the provider is ready\n */\ndeclare const WagmiProviderInitializedContext: react0.Context<boolean>;\n//#endregion\n//#region src/wallet/hooks/useIsWagmiProviderInitialized.d.ts\n/**\n * Hook to check if WagmiProvider is ready\n * @returns boolean indicating if the provider is initialized\n */\ndeclare const useIsWagmiProviderInitialized: () => boolean;\n//#endregion\n//#region src/wallet/hooks/useManagedWagmiDisconnect.d.ts\n/**\n * Backwards-compatible alias for wagmi's disconnect hook.\n *\n * The reconnect workaround path is no longer active now that wallet providers are scoped to\n * ecosystem sessions instead of network remounts, but this export remains for compatibility.\n */\ndeclare function useManagedWagmiDisconnect(): UseDisconnectReturnType;\n//#endregion\n//#region src/wallet/components/SafeWagmiComponent.d.ts\n/**\n * A wrapper component that safely renders children that use wagmi hooks.\n * It handles errors and provider initialization state to prevent crashes.\n */\ndeclare const SafeWagmiComponent: ({\n  children,\n  fallback\n}: {\n  children: React$1.ReactNode;\n  fallback?: React$1.ReactNode;\n}) => react_jsx_runtime0.JSX.Element;\n//#endregion\n//#region src/wallet/components/connect/ConnectButton.d.ts\n/**\n * A button that allows users to connect their wallet.\n * Opens a dialog to select from available connectors.\n * @param hideWhenConnected - Whether to hide the button when wallet is connected (default: true)\n * @param showInjectedConnector - Whether to show the injected connector in the dialog (default: false)\n */\ninterface ConnectButtonProps extends BaseComponentProps {\n  hideWhenConnected?: boolean;\n  showInjectedConnector?: boolean;\n}\ndeclare const CustomConnectButton: React$1.FC<ConnectButtonProps>;\n//#endregion\n//#region src/wallet/components/connect/ConnectorDialog.d.ts\ninterface ConnectorDialogProps {\n  open: boolean;\n  onOpenChange: (open: boolean) => void;\n  showInjectedConnector?: boolean;\n}\ndeclare const ConnectorDialog: React$1.FC<ConnectorDialogProps>;\n//#endregion\n//#region src/wallet/components/account/AccountDisplay.d.ts\n/**\n * A component that displays the connected account address and chain ID.\n * Also includes a disconnect button.\n */\ndeclare const CustomAccountDisplay: React$1.FC<BaseComponentProps>;\n//#endregion\n//#region src/wallet/components/network/NetworkSwitcher.d.ts\n/**\n * A component that displays the current network and allows switching to other networks.\n * Uses the chainId and switchChain hooks.\n */\ndeclare const CustomNetworkSwitcher: React$1.FC<BaseComponentProps>;\n//#endregion\n//#region src/wallet/connection.d.ts\n/**\n * Default wallet connection status when disconnected.\n * Use this constant when the wallet implementation is not ready or available.\n */\ndeclare const DEFAULT_DISCONNECTED_STATUS: GetAccountReturnType;\n/**\n * Core implementation of connect and ensure correct network logic.\n *\n * This function handles the common pattern of:\n * 1. Connect to wallet using the specified connector\n * 2. Check if connected to the target chain\n * 3. If not, attempt to switch networks\n * 4. If switch fails, disconnect and return error\n *\n * @param impl - The wallet implementation to use\n * @param connectorId - The ID of the connector to use\n * @param targetChainId - The desired chain ID to switch to after connection\n * @param logSystem - The log system identifier for logging\n * @returns An object containing connection status, address, and any error\n */\ndeclare function connectAndEnsureCorrectNetworkCore(impl: EvmWalletImplementation, connectorId: string, targetChainId: number, logSystem: string): Promise<EvmWalletConnectionResult>;\n//#endregion\n//#region src/wallet/types.d.ts\n/**\n * Network configuration with chain ID to network ID mapping.\n * This is a minimal interface that both EVM and Polkadot network configs satisfy.\n */\ninterface WalletNetworkConfig {\n  /** Unique network identifier (e.g., 'ethereum', 'polygon', 'polkadot-hub') */\n  id: string;\n  /** Chain ID for the network */\n  chainId: number;\n  /** Optional viem Chain object */\n  viemChain?: Chain;\n}\n/**\n * Configuration options for WagmiWalletImplementation.\n *\n * This interface defines what adapters need to provide when creating\n * a wallet implementation instance.\n */\ninterface WagmiWalletConfig {\n  /**\n   * The supported chains for this wallet implementation.\n   * These chains will be used to configure wagmi and for wallet operations.\n   */\n  chains: readonly Chain[];\n  /**\n   * Network configurations for chain ID to network ID mapping.\n   * Used for RPC override lookups via AppConfigService.\n   */\n  networkConfigs: WalletNetworkConfig[];\n  /**\n   * Optional initial UI kit configuration.\n   * Used primarily for logging the anticipated kit name.\n   */\n  initialUiKitConfig?: UiKitConfiguration;\n  /**\n   * Log system identifier for this implementation.\n   * Defaults to 'WagmiWalletImplementation'.\n   */\n  logSystem?: string;\n}\n/**\n * Type alias for wagmi config chains parameter.\n * Represents the chains array that wagmi expects in its configuration.\n * Must have at least one chain (non-empty tuple).\n */\ntype WagmiConfigChains = readonly [Chain, ...Chain[]];\n//#endregion\n//#region src/wallet/wagmi-implementation.d.ts\n/**\n * Type for RainbowKit config retrieval function.\n * This allows adapters to provide their own RainbowKit config service.\n */\ntype GetWagmiConfigForRainbowKitFn = (uiKitConfiguration: UiKitConfiguration, chains: WagmiConfigChains, chainIdToNetworkIdMap: Record<number, string>, getRpcOverride: (networkId: string) => string | {\n  http?: string;\n  ws?: string;\n} | undefined) => Promise<Config | null>;\n/**\n * Class responsible for encapsulating Wagmi core logic for wallet interactions.\n * This class should not be used directly by UI components. The adapters\n * expose a standardized interface for wallet operations.\n * It manages Wagmi Config instances and provides methods for wallet actions.\n *\n * Implements EvmWalletImplementation interface for use with shared execution strategies.\n *\n * @example\n * ```typescript\n * // In adapter-evm:\n * const walletImpl = new WagmiWalletImplementation({\n *   chains: evmChains,\n *   networkConfigs: evmNetworks,\n * });\n *\n * // In adapter-polkadot:\n * const walletImpl = new WagmiWalletImplementation({\n *   chains: polkadotChains,\n *   networkConfigs: polkadotNetworks,\n * });\n * ```\n */\ndeclare class WagmiWalletImplementation implements EvmWalletImplementation {\n  private defaultInstanceConfig;\n  private activeWagmiConfig;\n  private unsubscribe?;\n  private initialized;\n  private rpcConfigUnsubscribe?;\n  private readonly supportedChains;\n  private readonly chainIdToNetworkId;\n  private readonly logSystem;\n  private rainbowKitConfigFn?;\n  /**\n   * Constructs the WagmiWalletImplementation.\n   * Configuration for Wagmi is deferred until actually needed or set externally.\n   *\n   * @param config - Configuration options for the wallet implementation\n   */\n  constructor(config: WagmiWalletConfig);\n  /**\n   * Sets the RainbowKit config retrieval function.\n   * This allows adapters to inject their own RainbowKit integration.\n   *\n   * @param fn - Function to get RainbowKit wagmi config\n   */\n  setRainbowKitConfigFn(fn: GetWagmiConfigForRainbowKitFn): void;\n  /**\n   * Gets the supported chains for this implementation.\n   */\n  getSupportedChains(): readonly Chain[];\n  /**\n   * Gets the chain ID to network ID mapping.\n   */\n  getChainIdToNetworkIdMapping(): Record<number, string>;\n  /**\n   * Sets up a listener for RPC configuration changes to invalidate the cached Wagmi config\n   * when user changes RPC settings.\n   */\n  private setupRpcConfigListener;\n  /**\n   * Cleanup method to unsubscribe from RPC config changes\n   */\n  cleanup(): void;\n  /**\n   * Sets the externally determined, currently active WagmiConfig instance.\n   * This is typically called by UiKitManager after it has resolved the appropriate\n   * config for the selected UI kit (e.g., RainbowKit's config or a default custom config).\n   *\n   * @param config - The Wagmi Config object to set as active, or null to clear it.\n   */\n  setActiveWagmiConfig(config: Config | null): void;\n  /**\n   * Checks if an active wagmi config has been set.\n   * Subclasses can use this to determine if the wallet is ready for operations.\n   *\n   * @returns true if an active wagmi config is set\n   */\n  protected hasActiveConfig(): boolean;\n  /**\n   * Creates a default WagmiConfig instance on demand.\n   * This configuration includes standard connectors (injected, Safe).\n   * Used as a fallback or for 'custom' UI kit mode.\n   *\n   * The dedicated `metaMask()` connector is deliberately absent: it pulls in\n   * `@metamask/sdk`, which ships a proprietary ConsenSys licence restricted to\n   * Non-Commercial Use and requiring any derivative to carry that same\n   * restriction forward. We publish under AGPL-3.0, which forbids conveying the\n   * work under added restrictions, so the two cannot both be satisfied.\n   *\n   * The MetaMask browser extension still connects through `injected()` plus\n   * EIP-6963 discovery, which `createConfig` enables by default. What is lost is\n   * MetaMask *mobile* deep-link / QR pairing, which only the SDK provided.\n   *\n   * @returns A Wagmi Config object.\n   */\n  private createDefaultConfig;\n  /**\n   * Wrapper function to convert AppConfigService RPC overrides to the format expected by RainbowKit.\n   *\n   * @param networkId - The network ID to get RPC override for\n   * @returns RPC configuration in the format expected by RainbowKit\n   */\n  getRpcOverrideForRainbowKit(networkId: string): string | {\n    http?: string;\n    ws?: string;\n  } | undefined;\n  /**\n   * Retrieves or creates the WagmiConfig specifically for RainbowKit.\n   * This delegates to the injected RainbowKit config function if available.\n   *\n   * @param currentAdapterUiKitConfig - The fully resolved UI kit configuration for the adapter.\n   * @returns A Promise resolving to the RainbowKit-specific Wagmi Config object, or null if creation fails or not RainbowKit.\n   */\n  getConfigForRainbowKit(currentAdapterUiKitConfig: UiKitConfiguration): Promise<Config | null>;\n  /**\n   * Determines and returns the WagmiConfig to be used by UiKitManager during its configuration process.\n   * If RainbowKit is specified in the passed uiKitConfig, it attempts to get its specific config.\n   * Otherwise, it falls back to creating/returning a default instance config.\n   *\n   * @param uiKitConfig - The fully resolved UiKitConfiguration that the manager is currently processing.\n   * @returns A Promise resolving to the determined Wagmi Config object.\n   */\n  getActiveConfigForManager(uiKitConfig: UiKitConfiguration): Promise<Config>;\n  /**\n   * @deprecated Prefer using methods that rely on the externally set `activeWagmiConfig`\n   * or methods that determine contextually appropriate config like `getActiveConfigForManager` (for manager use)\n   * or ensure `activeWagmiConfig` is set before calling wagmi actions.\n   * This method returns the internally cached default config or the active one if set.\n   *\n   * @returns The current default or active Wagmi Config object.\n   */\n  getConfig(): Config;\n  /**\n   * Gets the current wallet connection status (isConnected, address, chainId, etc.).\n   * This is a synchronous operation and uses the `activeWagmiConfig` if set by `UiKitManager`,\n   * otherwise falls back to the default instance config (created on demand).\n   *\n   * @returns The current account status from Wagmi.\n   */\n  getWalletConnectionStatus(): GetAccountReturnType;\n  /**\n   * Subscribes to account and connection status changes from Wagmi.\n   * The subscription is bound to the `activeWagmiConfig` if available at the time of call,\n   * otherwise to the default instance config.\n   *\n   * @param callback - Function to call when connection status changes.\n   * @returns A function to unsubscribe from the changes.\n   */\n  onWalletConnectionChange(callback: (status: GetAccountReturnType, prevStatus: GetAccountReturnType) => void): () => void;\n  /**\n   * Gets the Viem Wallet Client for the currently connected account and chain.\n   *\n   * @returns A Promise resolving to the Viem WalletClient or null if not connected.\n   */\n  getWalletClient(): Promise<WalletClient | null>;\n  /**\n   * Gets the Viem Public Client for the currently connected chain.\n   *\n   * @returns A Promise resolving to the Viem PublicClient or null.\n   */\n  getPublicClient(): Promise<PublicClient | null>;\n  /**\n   * Gets the list of available wallet connectors from the active Wagmi config.\n   *\n   * @returns A Promise resolving to an array of available connectors.\n   */\n  getAvailableConnectors(): Promise<Connector[]>;\n  /**\n   * Initiates the connection process for a specific connector.\n   *\n   * @param connectorId - The ID of the connector to use.\n   * @returns A Promise with connection result including address and chainId if successful.\n   */\n  connect(connectorId: string): Promise<{\n    connected: boolean;\n    address?: string;\n    chainId?: number;\n    error?: string;\n  }>;\n  /**\n   * Disconnects the currently connected wallet.\n   *\n   * @returns A Promise with disconnection result.\n   */\n  disconnect(): Promise<{\n    disconnected: boolean;\n    error?: string;\n  }>;\n  /**\n   * Prompts the user to switch to the specified network.\n   *\n   * @param chainId - The target chain ID to switch to.\n   * @returns A Promise that resolves if the switch is successful, or rejects with an error.\n   */\n  switchNetwork(chainId: number): Promise<void>;\n}\n//#endregion\n//#region src/wallet/rainbowkit/config-generator.d.ts\ninterface RainbowKitConfigOptions {\n  /** Default app name if not provided in config */\n  defaultAppName?: string;\n  /** Header comment for the generated file */\n  headerComment?: string;\n}\n/**\n * Generates the content for a `rainbowkit.config.ts` file for an exported project.\n * It merges the user-provided configuration with the necessary boilerplate to ensure\n * the config is valid for RainbowKit's `getDefaultConfig`.\n *\n * @param userConfig - The user-provided configuration from the builder app.\n * @param options - Optional customization for the generated file.\n * @returns A string containing the formatted TypeScript code for the config file.\n */\ndeclare function generateRainbowKitConfigFile(userConfig: UiKitConfiguration['kitConfig'], options?: RainbowKitConfigOptions): string;\n/**\n * Generates the specific configuration file for RainbowKit during project export.\n *\n * @param uiKitConfig The full UI kit configuration object from the builder.\n * @param options - Optional customization for the generated file.\n * @returns A record containing the file path and its generated content.\n */\ndeclare function generateRainbowKitExportables(uiKitConfig: UiKitConfiguration, options?: RainbowKitConfigOptions): Record<string, string>;\n//#endregion\n//#region src/wallet/rainbowkit/types.d.ts\n/**\n * Extract the `AppInfo` type from the RainbowKitProvider's props.\n * This is the canonical way to get the type for the `appInfo` object.\n */\ntype AppInfo = React.ComponentProps<typeof RainbowKitProvider>['appInfo'];\n/**\n * Extract the props type from RainbowKit's ConnectButton component\n * This gives us the exact same types that RainbowKit uses internally\n */\ntype RainbowKitConnectButtonProps = React.ComponentProps<typeof ConnectButton>;\n/**\n * Represents the props expected by the RainbowKitProvider component.\n * It uses a nested `appInfo` object.\n */\ninterface RainbowKitProviderProps {\n  appInfo?: AppInfo;\n  [key: string]: unknown;\n}\n/**\n * Represents the shape of the `kitConfig` object we use internally when the\n * selected kit is RainbowKit. It has a flat structure for `appName` and `learnMoreUrl`\n * for easier handling in our builder app, and can also contain pre-existing providerProps.\n */\ntype RainbowKitKitConfig = Partial<AppInfo> & {\n  providerProps?: RainbowKitProviderProps;\n  [key: string]: unknown;\n};\n/**\n * Custom UI configuration that uses RainbowKit's native types\n * This extends our configuration system while leveraging RainbowKit's own type definitions\n */\ninterface RainbowKitCustomizations {\n  /**\n   * Configuration for the RainbowKit ConnectButton component\n   * Uses RainbowKit's native prop types for type safety and compatibility\n   */\n  connectButton?: Partial<RainbowKitConnectButtonProps>;\n}\n/**\n * Type guard to check if an object contains RainbowKit customizations\n */\ndeclare function isRainbowKitCustomizations(obj: unknown): obj is RainbowKitCustomizations;\n/**\n * Utility to extract RainbowKit customizations from a kit config\n */\ndeclare function extractRainbowKitCustomizations(kitConfig: Record<string, unknown> | undefined): RainbowKitCustomizations | undefined;\n//#endregion\n//#region src/wallet/rainbowkit/utils.d.ts\n/**\n * RainbowKit configuration options definition\n */\n/**\n * Validates the RainbowKit configuration to ensure required fields are present.\n *\n * @param kitConfig - The RainbowKit configuration object\n * @returns Object containing the validation result and any missing fields or error message\n */\ndeclare function validateRainbowKitConfig(kitConfig?: UiKitConfiguration['kitConfig']): {\n  isValid: boolean;\n  missingFields?: string[];\n  error?: string;\n};\n/**\n * Extracts and type-guards a RainbowKit configuration from a UiKitConfiguration\n *\n * @param config The UI kit configuration\n * @returns The raw kitConfig Record<string, unknown> or undefined.\n */\ndeclare function getRawUserNativeConfig(config: UiKitConfiguration): Record<string, unknown> | undefined;\n//#endregion\n//#region src/wallet/uiKitManager.d.ts\n/**\n * State interface for UI Kit Manager.\n * Tracks the current UI kit configuration, wagmi config, and loading states.\n */\ninterface UiKitManagerState {\n  /** The current full UI kit configuration */\n  currentFullUiKitConfig: UiKitConfiguration | null;\n  /** The active wagmi configuration */\n  wagmiConfig: Config | null;\n  /** The UI kit provider component (e.g., RainbowKitProvider) */\n  kitProviderComponent: React$1.ComponentType<React$1.PropsWithChildren<unknown>> | null;\n  /** Whether the UI kit assets have been loaded */\n  isKitAssetsLoaded: boolean;\n  /** Whether the manager is currently initializing */\n  isInitializing: boolean;\n  /** Any error that occurred during configuration */\n  error: Error | null;\n}\n/**\n * Result type for loading RainbowKit assets.\n */\ninterface RainbowKitAssetsResult {\n  /** The provider component to wrap the app, or null if loading failed */\n  ProviderComponent: React$1.ComponentType<React$1.PropsWithChildren<unknown>> | null;\n  /** Whether CSS was loaded successfully */\n  cssLoaded: boolean;\n}\n/**\n * Dependencies required by the UI Kit Manager factory.\n */\ninterface UiKitManagerDependencies {\n  /**\n   * Function to get the wallet implementation.\n   * Can be sync or async to support both EVM (async) and Polkadot (sync) patterns.\n   */\n  getWalletImplementation: () => WagmiWalletImplementation | Promise<WagmiWalletImplementation>;\n  /**\n   * Function to load RainbowKit assets (provider component and CSS).\n   */\n  loadRainbowKitAssets: () => Promise<RainbowKitAssetsResult>;\n  /**\n   * Log prefix for identifying the adapter in logs.\n   */\n  logPrefix: string;\n}\n/**\n * Interface for the UI Kit Manager returned by the factory.\n */\ninterface UiKitManager {\n  /** Get the current state */\n  getState: () => UiKitManagerState;\n  /** Subscribe to state changes */\n  subscribe: (listener: () => void) => () => void;\n  /** Configure the UI kit with new settings */\n  configure: (newFullUiKitConfig: UiKitConfiguration) => Promise<void>;\n}\n/**\n * Creates a UI Kit Manager instance with the provided dependencies.\n *\n * @param deps - The dependencies for the UI Kit Manager\n * @returns A UI Kit Manager instance with getState, subscribe, and configure methods\n *\n * @example\n * ```typescript\n * // In adapter-evm:\n * const evmUiKitManager = createUiKitManager({\n *   getWalletImplementation: getEvmWalletImplementation,\n *   loadRainbowKitAssets: async () => {\n *     const { ensureRainbowKitAssetsLoaded } = await import('./rainbowkit/rainbowkitAssetManager');\n *     return ensureRainbowKitAssetsLoaded();\n *   },\n *   logPrefix: 'EvmUiKitManager',\n * });\n *\n * // In adapter-polkadot:\n * const polkadotUiKitManager = createUiKitManager({\n *   getWalletImplementation: () => getPolkadotWalletImplementation(),\n *   loadRainbowKitAssets: async () => {\n *     const { ensureRainbowKitAssetsLoaded } = await import('./rainbowkit/rainbowkitAssetManager');\n *     return ensureRainbowKitAssetsLoaded();\n *   },\n *   logPrefix: 'PolkadotUiKitManager',\n * });\n * ```\n */\ndeclare function createUiKitManager(deps: UiKitManagerDependencies): UiKitManager;\n//#endregion\n//#region src/wallet/rainbowkit/components.d.ts\n/**\n * Props for the RainbowKitConnectButton component created by the factory.\n */\ntype RainbowKitConnectButtonProps$1 = BaseComponentProps;\n/**\n * Creates a RainbowKitConnectButton component that uses the provided UI kit manager.\n * This factory pattern allows adapters to inject their specific UI kit manager instance.\n *\n * @param uiKitManager - The UI kit manager instance to use for state management\n * @returns A React component that renders the RainbowKit ConnectButton\n *\n * @example\n * ```typescript\n * // In adapter-evm:\n * import { createRainbowKitConnectButton } from '@openzeppelin/adapter-evm-core';\n * import { evmUiKitManager } from './evmUiKitManager';\n *\n * export const RainbowKitConnectButton = createRainbowKitConnectButton(evmUiKitManager);\n *\n * // In adapter-polkadot:\n * import { createRainbowKitConnectButton } from '@openzeppelin/adapter-evm-core';\n * import { polkadotUiKitManager } from './polkadotUiKitManager';\n *\n * export const RainbowKitConnectButton = createRainbowKitConnectButton(polkadotUiKitManager);\n * ```\n */\ndeclare function createRainbowKitConnectButton(uiKitManager: UiKitManager): React$1.FC<RainbowKitConnectButtonProps$1>;\n//#endregion\n//#region src/wallet/rainbowkit/componentFactory.d.ts\n/**\n * Creates the complete set of RainbowKit wallet components.\n *\n * This factory function accepts a RainbowKitConnectButton component that has been\n * created with an adapter-specific UI kit manager. This allows different adapters\n * to use their own manager instance while sharing the component creation logic.\n *\n * @param RainbowKitConnectButton - The connect button component created via createRainbowKitConnectButton\n * @returns An object containing all RainbowKit wallet components\n *\n * @example\n * ```typescript\n * // In adapter-evm:\n * import { createRainbowKitConnectButton, createRainbowKitComponents } from '@openzeppelin/adapter-evm-core';\n * import { evmUiKitManager } from './evmUiKitManager';\n *\n * const RainbowKitConnectButton = createRainbowKitConnectButton(evmUiKitManager);\n * const components = createRainbowKitComponents(RainbowKitConnectButton);\n *\n * // In adapter-polkadot:\n * import { createRainbowKitConnectButton, createRainbowKitComponents } from '@openzeppelin/adapter-evm-core';\n * import { polkadotUiKitManager } from './polkadotUiKitManager';\n *\n * const RainbowKitConnectButton = createRainbowKitConnectButton(polkadotUiKitManager);\n * const components = createRainbowKitComponents(RainbowKitConnectButton);\n * ```\n */\ndeclare function createRainbowKitComponents(RainbowKitConnectButton: React.ComponentType<BaseComponentProps>): EcosystemWalletComponents;\n//#endregion\n//#region src/wallet/rainbowkit/config-service.d.ts\n/**\n * Creates a Wagmi configuration for RainbowKit using getDefaultConfig\n *\n * @param userFullNativeConfig The full native configuration object. This object IS the result of merging\n *                             AppConfigService settings, user's native rainbowkit.config.ts, and programmatic overrides.\n *                             It is expected to contain a `wagmiParams` object for RainbowKit's getDefaultConfig\n *                             and potentially a `providerProps` object for RainbowKitProvider.\n *                             Only `appName` is required. `projectId` is supplied by this\n *                             adapter as a placeholder and any user-provided value is\n *                             ignored, because WalletConnect support was removed.\n * @param chains Array of viem Chain objects - will be safely cast to wagmi's expected chain type\n * @param chainIdToNetworkIdMap Mapping of chain IDs to network IDs for RPC override lookups\n * @param getRpcEndpointOverride Function to get RPC endpoint overrides\n * @returns Wagmi configuration for RainbowKit or null if creation fails\n */\ndeclare function createRainbowKitWagmiConfig(userFullNativeConfig: Record<string, unknown> | undefined | null,\n// This is the fully resolved kitConfig\nchains: readonly Chain[], chainIdToNetworkIdMap: Record<number, string>, getRpcEndpointOverride: (networkId: string) => string | {\n  http?: string;\n  ws?: string;\n} | undefined): Promise<Config | null>;\n/**\n * Gets the Wagmi configuration for RainbowKit based on the global UI kit settings.\n * This function is intended to be called by WagmiWalletImplementation.\n *\n * @param uiKitConfiguration The UI kit configuration object from UiKitManager (contains the resolved kitConfig).\n * @param chains Array of viem Chain objects to use with RainbowKit\n * @param chainIdToNetworkIdMap Mapping of chain IDs to network IDs for RPC override lookups\n * @param getRpcEndpointOverride Function to get RPC endpoint overrides\n * @returns The wagmi Config object or null if invalid or not RainbowKit\n */\ndeclare function getWagmiConfigForRainbowKit(uiKitConfiguration: UiKitConfiguration | undefined, chains: readonly Chain[], chainIdToNetworkIdMap: Record<number, string>, getRpcEndpointOverride: (networkId: string) => string | {\n  http?: string;\n  ws?: string;\n} | undefined): Promise<Config | null>;\n//#endregion\n//#region src/wallet/rainbowkitAssetManager.d.ts\n/**\n * Ensures RainbowKit provider component and CSS are loaded.\n * Loads them dynamically only once and caches the result.\n *\n * @returns A promise resolving to an object containing the ProviderComponent and cssLoaded status.\n */\ndeclare function ensureRainbowKitAssetsLoaded(): Promise<RainbowKitAssetsResult>;\n//#endregion\n//#region src/wallet/configResolution.d.ts\n/**\n * Resolves and initializes the kit-specific configuration.\n * This function acts as a manager to call the appropriate kit's configuration initializer.\n *\n * @param kitName The name of the UI kit (e.g., 'rainbowkit').\n * @param programmaticKitConfig Optional base/programmatic config passed to the kit initializer.\n * @param loadConfigModule Optional generic callback to load configuration modules by path.\n * @returns A Promise resolving to the final kitConfig (Record<string, unknown>) for the specified kit, or null.\n */\ndeclare function resolveAndInitializeKitConfig(kitName?: string,\n// kitName is used to construct the path to the conventional config file\nprogrammaticKitConfig?: Record<string, unknown>, loadConfigModule?: NativeConfigLoader): Promise<Record<string, unknown> | null>;\n/**\n * Resolves the final, complete UiKitConfiguration by merging various sources.\n *\n * @param programmaticOverrides - Overrides passed directly to the configureUiKit call.\n * @param initialAppServiceKitName - The kitName noted from AppConfigService when the adapter instance was constructed.\n * @param currentAppServiceConfig - The full UiKitConfiguration from AppConfigService, re-fetched at the time of the call.\n * @param options - Options, including the callback to load user's native config file.\n * @returns A Promise resolving to the final UiKitConfiguration.\n */\ndeclare function resolveFullUiKitConfiguration(programmaticOverrides: Partial<UiKitConfiguration>, initialAppServiceKitName: UiKitConfiguration['kitName'], currentAppServiceConfig: UiKitConfiguration,\n// This is the result of loadInitialConfigFromAppService()\noptions?: {\n  loadUiKitNativeConfig?: NativeConfigLoader;\n}): Promise<UiKitConfiguration>;\n//#endregion\n//#region src/wallet/utils/filterWalletComponents.d.ts\n/**\n * Filters a set of wallet components based on an exclusion list.\n *\n * @param allPossibleComponents - An object containing all potential components for a kit.\n * @param exclusions - An array of component keys to exclude.\n * @param kitName - The name of the kit being filtered (for logging purposes).\n * @returns The filtered EcosystemWalletComponents object, or undefined if all components are excluded.\n */\ndeclare function filterWalletComponents(allPossibleComponents: EcosystemWalletComponents, exclusions: Array<keyof EcosystemWalletComponents>, kitName?: string): EcosystemWalletComponents | undefined;\n/**\n * Extracts the component exclusion list from a UI kit configuration object.\n *\n * @param kitConfig - The `kitConfig` object from `UiKitConfiguration`.\n * @returns An array of component keys to exclude, or an empty array if none are specified or config is invalid.\n */\ndeclare function getComponentExclusionsFromConfig(kitConfig: UiKitConfiguration['kitConfig']): Array<keyof EcosystemWalletComponents>;\n//#endregion\n//#region src/configuration/rpc.d.ts\n/**\n * Builds a complete RPC URL from a user RPC provider configuration.\n * For simplified RPC configuration, this just returns the URL as-is since\n * users are now providing complete RPC URLs including any API keys.\n *\n * @param config The user RPC provider configuration\n * @returns The RPC URL\n */\ndeclare function buildRpcUrl(config: UserRpcProviderConfig): string;\n/**\n * Extracts the user-configured RPC URL from UserNetworkServiceConfigService.\n *\n * @param networkId - The network ID to get the RPC URL for\n * @returns The RPC URL string if configured, undefined otherwise\n */\ndeclare function getUserRpcUrl(networkId: string): string | undefined;\n/**\n * Resolves the RPC URL for a given EVM network configuration.\n * Priority order:\n * 1. User-provided RPC configuration (from UserRpcConfigService)\n * 2. RPC URL override from AppConfigService\n * 3. Default rpcUrl from the network configuration\n *\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem).\n * @returns The resolved RPC URL string.\n * @throws If no RPC URL can be resolved (neither user config, override, nor default is present and valid).\n */\ndeclare function resolveRpcUrl(networkConfig: EvmCompatibleNetworkConfig): string;\n/**\n * Validates an RPC endpoint configuration for EVM networks.\n * @param rpcConfig - The RPC provider configuration to validate\n * @returns True if the configuration is valid, false otherwise\n */\ndeclare function validateEvmRpcEndpoint(rpcConfig: UserRpcProviderConfig): boolean;\n/**\n * Tests the connection to an EVM RPC endpoint with a timeout.\n * @param rpcConfig - The RPC provider configuration to test\n * @param timeoutMs - Timeout in milliseconds (default: 5000ms)\n * @returns Connection test results including success status, latency, and any errors\n */\ndeclare function testEvmRpcConnection(rpcConfig: UserRpcProviderConfig, timeoutMs?: number): Promise<{\n  success: boolean;\n  latency?: number;\n  error?: string;\n}>;\n/**\n * Gets the current block number from an EVM network.\n *\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n * @returns Promise resolving to the current block number\n * @throws Error if the RPC call fails\n */\ndeclare function getEvmCurrentBlock(networkConfig: EvmCompatibleNetworkConfig): Promise<number>;\n//#endregion\n//#region src/configuration/explorer.d.ts\n/**\n * Resolves the explorer API key from app configuration (without user overrides).\n * This is used by getDefaultServiceConfig to provide defaults for health checks.\n *\n * Priority order:\n * 1. For V2 API networks: Global Etherscan V2 API key\n * 2. Network-specific global service config API key\n * 3. Fallback to explorer API key by identifier\n *\n * @param networkConfig - EVM-compatible network configuration\n * @returns The resolved API key, or undefined if not configured\n */\ndeclare function resolveExplorerApiKeyFromAppConfig(networkConfig: EvmCompatibleNetworkConfig): string | undefined;\n/**\n * Resolves the explorer configuration for a given EVM network.\n * Priority order:\n * 1. User-configured explorer (from UserExplorerConfigService)\n * 2. For V2 API networks: Global Etherscan V2 API key (from AppConfigService global service configs)\n * 3. App-configured explorer API key (from AppConfigService network service configs)\n * 4. Default network explorer (from NetworkConfig)\n *\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem).\n * @returns The resolved explorer configuration.\n */\ndeclare function resolveExplorerConfig(networkConfig: EvmCompatibleNetworkConfig): UserExplorerConfig;\n/**\n * Gets a blockchain explorer URL for an EVM address.\n * Uses the resolved explorer configuration.\n *\n * @param address - Contract or wallet address\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n */\ndeclare function getEvmExplorerAddressUrl(address: string, networkConfig: EvmCompatibleNetworkConfig): string | null;\n/**\n * Gets a blockchain explorer URL for an EVM transaction.\n * Uses the resolved explorer configuration.\n *\n * @param txHash - Transaction hash\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n */\ndeclare function getEvmExplorerTxUrl(txHash: string, networkConfig: EvmCompatibleNetworkConfig): string | null;\n/**\n * Validates an EVM explorer configuration.\n * Checks URL formats and API key format.\n */\ndeclare function validateEvmExplorerConfig(explorerConfig: UserExplorerConfig): boolean;\n/**\n * Tests the connection to an EVM explorer API.\n * Makes a test API call to verify the API key works.\n * Automatically uses V2 API testing for networks that support it.\n *\n * @param explorerConfig - Explorer configuration to test\n * @param networkConfig - Optional EVM-compatible network configuration (works with any ecosystem)\n */\ndeclare function testEvmExplorerConnection(explorerConfig: UserExplorerConfig, networkConfig?: EvmCompatibleNetworkConfig): Promise<{\n  success: boolean;\n  latency?: number;\n  error?: string;\n}>;\n//#endregion\n//#region src/configuration/access-control-indexer.d.ts\n/**\n * Extracts the user-configured access control indexer URL from UserNetworkServiceConfigService.\n *\n * @param networkId - The network ID to get the access control indexer URL for\n * @returns The access control indexer URL string if configured, undefined otherwise\n */\ndeclare function getUserAccessControlIndexerUrl(networkId: string): string | undefined;\n/**\n * Resolves the access control indexer URL for a given EVM network configuration.\n *\n * Priority order:\n * 1. User-configured access control indexer URL (from Network Settings dialog)\n * 2. Default `accessControlIndexerUrl` from the network configuration\n *\n * Unlike RPC resolution, the access control indexer is optional — returns `undefined`\n * instead of throwing when no URL is available.\n *\n * @param networkConfig - EVM-compatible network configuration\n * @returns The resolved access control indexer URL string, or undefined if not configured\n */\ndeclare function resolveAccessControlIndexerUrl(networkConfig: EvmCompatibleNetworkConfig): string | undefined;\n//#endregion\n//#region src/configuration/network-services.d.ts\n/**\n * Validates a network service configuration for EVM-compatible networks.\n *\n * @param serviceId - The service identifier ('rpc', 'explorer', or 'contract-definitions')\n * @param values - The form values to validate\n * @returns True if valid, false otherwise\n */\ndeclare function validateEvmNetworkServiceConfig(serviceId: string, values: Record<string, unknown>): Promise<boolean>;\n/**\n * Tests a network service connection for EVM-compatible networks.\n *\n * @param serviceId - The service identifier ('rpc', 'explorer', or 'contract-definitions')\n * @param values - The form values containing connection details\n * @param networkConfig - The network configuration (ecosystem-agnostic)\n * @returns Connection test result with success status, latency, and optional error\n */\ndeclare function testEvmNetworkServiceConnection(serviceId: string, values: Record<string, unknown>, networkConfig: EvmCompatibleNetworkConfig): Promise<{\n  success: boolean;\n  latency?: number;\n  error?: string;\n}>;\n//#endregion\n//#region src/proxy/detection.d.ts\ninterface ProxyDetectionResult {\n  isProxy: boolean;\n  proxyType: 'uups' | 'transparent' | 'beacon' | 'diamond' | 'minimal' | 'unknown' | null;\n  confidence: 'high' | 'medium' | 'low';\n  indicators: string[];\n}\n/**\n * Analyzes an ABI to determine if it belongs to a proxy contract\n */\ndeclare function detectProxyFromAbi(abi: AbiItem[]): ProxyDetectionResult;\n/**\n * Attempts to resolve the implementation address for a proxy contract\n *\n * @param proxyAddress - Address of the proxy contract\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n * @param proxyType - Type of proxy (uups, transparent, beacon, diamond, minimal, unknown)\n */\ndeclare function getImplementationAddress(proxyAddress: string, networkConfig: EvmCompatibleNetworkConfig, proxyType: string): Promise<string | null>;\n/**\n * Attempts to resolve the admin address for a proxy contract\n * Tries EIP-1967 admin slot first, then legacy OZ slot\n *\n * @param proxyAddress - Address of the proxy contract\n * @param networkConfig - EVM-compatible network configuration (works with any ecosystem)\n */\ndeclare function getAdminAddress(proxyAddress: string, networkConfig: EvmCompatibleNetworkConfig): Promise<string | null>;\n//#endregion\n//#region src/validation/eoa.d.ts\n/**\n * Wallet connection status for EOA validation\n */\ninterface EvmWalletStatus {\n  isConnected: boolean;\n  address?: string;\n}\n/**\n * Validates an EOA execution configuration.\n *\n * @param config The EOA execution config to validate\n * @param walletStatus Optional wallet connection status for address validation\n * @returns true if valid, or an error message string if invalid\n */\ndeclare function validateEoaConfig(config: EoaExecutionConfig, walletStatus?: EvmWalletStatus): Promise<true | string>;\n/**\n * Simple validation of EOA config without wallet status check.\n * Useful for static validation before execution.\n */\ndeclare function validateEvmEoaConfig(config: EoaExecutionConfig): boolean;\n//#endregion\n//#region src/validation/relayer.d.ts\n/**\n * Validates a relayer execution configuration.\n *\n * @param config The relayer execution config to validate\n * @returns true if valid, or an error message string if invalid\n */\ndeclare function validateRelayerConfig(config: RelayerExecutionConfig): Promise<true | string>;\n/**\n * Simple validation of relayer config.\n * Useful for static validation before execution.\n */\ndeclare function validateEvmRelayerConfig(config: RelayerExecutionConfig): boolean;\n//#endregion\n//#region src/validation/execution.d.ts\n/**\n * Validates the complete execution configuration object against the\n * requirements and capabilities of EVM-compatible adapters.\n *\n * @param config The execution configuration to validate\n * @param walletStatus The wallet connection status for validation\n * @returns true if valid, or an error message string if invalid\n */\ndeclare function validateEvmExecutionConfig(config: ExecutionConfig, walletStatus: EvmWalletStatus): Promise<true | string>;\n//#endregion\n//#region src/utils/validation.d.ts\n/**\n * Validates if a string is a valid EVM address.\n * @param address The address string to validate.\n * @returns True if the address is valid, false otherwise.\n */\ndeclare function isValidEvmAddress(address: string): boolean;\n//#endregion\n//#region src/utils/artifacts.d.ts\n/**\n * Validates and converts generic source input to EvmContractArtifacts\n *\n * @param source - Generic contract source (string address or artifacts object)\n * @returns Validated EvmContractArtifacts\n * @throws Error if the source is invalid\n */\ndeclare function validateAndConvertEvmArtifacts(source: string | Record<string, unknown>): EvmContractArtifacts;\n//#endregion\n//#region src/utils/json.d.ts\n/**\n * Custom JSON stringifier that handles BigInt values by converting them to strings.\n * @param value The value to stringify.\n * @param space Adds indentation, white space, and line break characters to the return-value JSON text for readability.\n * @returns A JSON string representing the given value.\n */\ndeclare function stringifyWithBigInt(value: unknown, space?: number | string): string;\n//#endregion\n//#region src/utils/formatting.d.ts\n/**\n * Format a method name for display (e.g., from camelCase to Title Case).\n */\ndeclare function formatMethodName(name: string): string;\n/**\n * Format an input name for display (e.g., from camelCase or snake_case to Title Case).\n * Provides a default name based on type if the original name is empty.\n */\ndeclare function formatInputName(name: string, type: string): string;\n//#endregion\n//#region src/utils/public-client.d.ts\n/**\n * Creates a viem `PublicClient` for on-chain reads.\n *\n * If `viemChain` is provided, it is used directly. Otherwise a minimal chain\n * config is built from the RPC URL — this is sufficient for `readContract()`\n * calls where chain metadata (block explorers, native currency, etc.) is not required.\n *\n * @param rpcUrl - The RPC endpoint URL\n * @param viemChain - Optional viem Chain object with full chain metadata\n * @returns A viem PublicClient ready for on-chain reads\n * @throws If client creation fails (e.g. invalid RPC URL)\n */\ndeclare function createEvmPublicClient(rpcUrl: string, viemChain?: Chain): PublicClient<Transport, Chain>;\n//#endregion\n//#region src/utils/gas.d.ts\n/**\n * Convert wei values to gwei for display using viem\n */\ndeclare const weiToGwei: (wei?: number) => number | undefined;\n/**\n * Convert gwei values to wei using viem\n */\ndeclare const gweiToWei: (gwei?: number) => number | undefined;\n//#endregion\n//#region src/access-control/actions.d.ts\n/**\n * Assembles a `transferOwnership(address newOwner)` transaction.\n *\n * Works with both Ownable (single-step) and Ownable2Step (sets pendingOwner).\n * The contract determines the behavior — same function signature for both patterns.\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @param newOwner - The new owner address (0x-prefixed)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleTransferOwnershipAction(contractAddress: string, newOwner: string): WriteContractParameters;\n/**\n * Assembles an `acceptOwnership()` transaction (Ownable2Step only).\n *\n * Must be called by the pending owner to complete a two-step transfer.\n * No arguments — the caller is implicitly the pending owner.\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleAcceptOwnershipAction(contractAddress: string): WriteContractParameters;\n/**\n * Assembles a `renounceOwnership()` transaction (Ownable).\n *\n * Permanently renounces ownership — after execution, `owner()` returns the zero address.\n * This is an EVM-specific operation not present in the Stellar adapter.\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleRenounceOwnershipAction(contractAddress: string): WriteContractParameters;\n/**\n * Assembles a `beginDefaultAdminTransfer(address newAdmin)` transaction.\n *\n * Initiates a two-step admin transfer on an AccessControlDefaultAdminRules contract.\n * The transfer can be accepted after the contract's built-in delay period.\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @param newAdmin - The new admin address (0x-prefixed)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleBeginAdminTransferAction(contractAddress: string, newAdmin: string): WriteContractParameters;\n/**\n * Assembles an `acceptDefaultAdminTransfer()` transaction.\n *\n * Must be called by the pending admin after the accept schedule timestamp\n * has passed. No arguments — the caller is implicitly the pending admin.\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleAcceptAdminTransferAction(contractAddress: string): WriteContractParameters;\n/**\n * Assembles a `cancelDefaultAdminTransfer()` transaction.\n *\n * Cancels a pending admin transfer. Must be called by the current default admin.\n * EVM-specific operation — Stellar has no cancel mechanism.\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleCancelAdminTransferAction(contractAddress: string): WriteContractParameters;\n/**\n * Assembles a `changeDefaultAdminDelay(uint48 newDelay)` transaction.\n *\n * Schedules a change to the admin transfer delay. The delay change itself\n * has a delay before it takes effect.\n * EVM-specific operation — Stellar has no delay mechanism.\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @param newDelay - The new delay in seconds (uint48)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleChangeAdminDelayAction(contractAddress: string, newDelay: number): WriteContractParameters;\n/**\n * Assembles a `rollbackDefaultAdminDelay()` transaction.\n *\n * Rolls back a pending admin delay change. Must be called by the current\n * default admin before the delay change takes effect.\n * EVM-specific operation — Stellar has no delay mechanism.\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleRollbackAdminDelayAction(contractAddress: string): WriteContractParameters;\n/**\n * Assembles a `grantRole(bytes32 role, address account)` transaction.\n *\n * Grants a role to an account. Must be called by an account with the role's\n * admin role (typically DEFAULT_ADMIN_ROLE for newly created roles).\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @param roleId - The bytes32 role identifier\n * @param account - The account to grant the role to (0x-prefixed)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleGrantRoleAction(contractAddress: string, roleId: string, account: string): WriteContractParameters;\n/**\n * Assembles a `revokeRole(bytes32 role, address account)` transaction.\n *\n * Revokes a role from an account. Must be called by an account with the\n * role's admin role.\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @param roleId - The bytes32 role identifier\n * @param account - The account to revoke the role from (0x-prefixed)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleRevokeRoleAction(contractAddress: string, roleId: string, account: string): WriteContractParameters;\n/**\n * Assembles a `renounceRole(bytes32 role, address callerConfirmation)` transaction.\n *\n * Renounces a role from the caller's own account. The `callerConfirmation` parameter\n * must match the caller's address — this is an on-chain safety check to prevent\n * accidental renouncement.\n *\n * **EVM-specific extension** — Stellar uses `revokeRole` for self-revocation instead\n * of a separate `renounceRole` function.\n *\n * @param contractAddress - The target contract address (0x-prefixed)\n * @param roleId - The bytes32 role identifier\n * @param account - The caller's address for confirmation (0x-prefixed)\n * @returns WriteContractParameters ready for execution\n */\ndeclare function assembleRenounceRoleAction(contractAddress: string, roleId: string, account: string): WriteContractParameters;\n//#endregion\n//#region src/access-control/constants.d.ts\n/**\n * EVM Access Control Constants\n *\n * Shared constants for the access control module.\n * These values match OpenZeppelin's Solidity AccessControl contract definitions.\n *\n * @module access-control/constants\n */\n/**\n * The bytes32 zero value used by OpenZeppelin AccessControl as the default admin role.\n * This is `keccak256(\"\")` equivalent — the admin role that governs all other roles by default.\n *\n * @see https://docs.openzeppelin.com/contracts/5.x/api/access#AccessControl-DEFAULT_ADMIN_ROLE--\n */\ndeclare const DEFAULT_ADMIN_ROLE: \"0x0000000000000000000000000000000000000000000000000000000000000000\";\n/**\n * Human-readable label for the default admin role.\n * Used when displaying role information in the Role Manager UI.\n */\ndeclare const DEFAULT_ADMIN_ROLE_LABEL: \"DEFAULT_ADMIN_ROLE\";\n/**\n * The EVM zero address (20 bytes of zeros).\n * Indicates renounced ownership or admin when returned by `owner()` or `defaultAdmin()`.\n */\ndeclare const ZERO_ADDRESS: \"0x0000000000000000000000000000000000000000\";\n//#endregion\n//#region src/access-control/feature-detection.d.ts\n/**\n * Detect access control capabilities from a contract's ABI.\n *\n * Analyzes `ContractSchema.functions` for the presence of OpenZeppelin\n * access control function signatures, checking both function names AND\n * parameter types for accuracy.\n *\n * @param contractSchema - Parsed contract schema with functions array\n * @param indexerAvailable - Whether an indexer endpoint is configured and reachable\n * @returns Detected capabilities flags\n */\ndeclare function detectAccessControlCapabilities(contractSchema: ContractSchema, indexerAvailable?: boolean): AccessControlCapabilities;\n/**\n * Validate that a contract has minimum viable access control support.\n *\n * Returns `true` if the contract has at least Ownable or AccessControl.\n * Unlike the Stellar adapter's version (which throws), this returns a boolean\n * for simpler integration — callers can decide how to handle unsupported contracts.\n *\n * @param capabilities - Previously detected capabilities\n * @returns true if the contract has at least Ownable or AccessControl\n */\ndeclare function validateAccessControlSupport(capabilities: AccessControlCapabilities): boolean;\n//#endregion\n//#region src/access-control/indexer-client.d.ts\n/** Pending ownership transfer enrichment data from the indexer */\ninterface PendingOwnershipTransferData {\n  /** Address of the pending new owner */\n  pendingOwner: string;\n  /** ISO8601 timestamp of the initiation event */\n  initiatedAt: string;\n  /** Transaction hash of the initiation event */\n  initiatedTxId: string;\n  /** Block number of the initiation event */\n  initiatedBlock: number;\n}\n/** Pending admin transfer enrichment data from the indexer */\ninterface PendingAdminTransferData {\n  /** Address of the pending new admin */\n  pendingAdmin: string;\n  /** UNIX timestamp (seconds) at which the transfer can be accepted */\n  acceptSchedule: number;\n  /** ISO8601 timestamp of the initiation event */\n  initiatedAt: string;\n  /** Transaction hash of the initiation event */\n  initiatedTxId: string;\n  /** Block number of the initiation event */\n  initiatedBlock: number;\n}\n/** Grant info data returned from queryLatestGrants */\ninterface GrantInfo {\n  /** The account address */\n  account: string;\n  /** The role ID */\n  role: string;\n  /** ISO8601 timestamp of the grant event */\n  grantedAt: string;\n  /** Transaction hash of the grant event */\n  txHash: string;\n  /** Who granted the role */\n  grantedBy?: string;\n}\n/**\n * EVM Indexer Client\n *\n * Handles GraphQL queries to the configured indexer for historical access control data.\n * The client is designed for graceful degradation — all query methods return null\n * instead of throwing when the indexer is unavailable.\n */\ndeclare class EvmIndexerClient {\n  private readonly networkConfig;\n  private readonly endpoint;\n  private availabilityChecked;\n  private available;\n  constructor(networkConfig: EvmCompatibleNetworkConfig);\n  /**\n   * Check if the indexer is available and configured.\n   *\n   * Performs a lightweight health check (`{ __typename }`) on the first call,\n   * then caches the result for subsequent calls.\n   *\n   * @returns true if the indexer endpoint is configured and responds to health checks\n   */\n  isAvailable(): Promise<boolean>;\n  /**\n   * Query the indexer for the latest pending ownership transfer event.\n   *\n   * Queries for `OWNERSHIP_TRANSFER_STARTED` events, ordered by timestamp descending.\n   * Returns the most recent event if found, or null if no pending transfer exists.\n   *\n   * Graceful degradation: returns null if the indexer is unavailable or the query fails.\n   *\n   * @param contractAddress - The contract address to query\n   * @returns Pending transfer data or null\n   */\n  queryPendingOwnershipTransfer(contractAddress: string): Promise<PendingOwnershipTransferData | null>;\n  /**\n   * Query the indexer for the latest pending admin transfer event.\n   *\n   * Queries for `DEFAULT_ADMIN_TRANSFER_SCHEDULED` or `ADMIN_TRANSFER_INITIATED` events,\n   * ordered by timestamp descending. Returns the most recent event if found,\n   * or null if no pending transfer exists.\n   *\n   * Graceful degradation: returns null if the indexer is unavailable or the query fails.\n   *\n   * @param contractAddress - The contract address to query\n   * @returns Pending admin transfer data or null\n   */\n  queryPendingAdminTransfer(contractAddress: string): Promise<PendingAdminTransferData | null>;\n  /**\n   * Query the indexer for current role membership grant data.\n   *\n   * Queries `roleMemberships` for the specified roles, returning a map of\n   * `role:account → GrantInfo` for enrichment of role assignments. The composite\n   * key ensures that an account holding multiple roles retains distinct grant\n   * metadata per role. Use {@link grantMapKey} to build lookup keys.\n   *\n   * Returns an empty Map if roleIds is empty. Returns null if the indexer\n   * is unavailable or the query fails (graceful degradation).\n   *\n   * @param contractAddress - The contract address to query\n   * @param roleIds - Array of bytes32 role IDs to query\n   * @returns Map of `role:account` composite key to GrantInfo, or null on failure\n   */\n  queryLatestGrants(contractAddress: string, roleIds: string[]): Promise<Map<string, GrantInfo> | null>;\n  /**\n   * Discover all unique role identifiers for a contract by querying historical events.\n   *\n   * Queries all `accessControlEvents` for the contract and extracts unique, non-empty\n   * `role` values. This enables role enumeration even when `knownRoleIds` are not\n   * provided at registration.\n   *\n   * Graceful degradation: returns null if the indexer is unavailable or the query fails.\n   *\n   * @param contractAddress - The contract address to discover roles for\n   * @returns Array of unique role identifiers, or null on failure\n   */\n  discoverRoleIds(contractAddress: string): Promise<string[] | null>;\n  /**\n   * Query historical access control events with filtering and pagination.\n   *\n   * Queries `accessControlEvents` with the specified filters. All 13 EVM event types\n   * are mapped to `HistoryChangeType` values per research.md §R6.\n   *\n   * Graceful degradation: returns null if the indexer is unavailable or the query fails.\n   *\n   * @param contractAddress - The contract address to query\n   * @param options - Optional filtering and pagination options\n   * @returns Paginated history result, or null on failure\n   */\n  queryHistory(contractAddress: string, options?: HistoryQueryOptions, roleLabelMap?: Map<string, string>): Promise<PaginatedHistoryResult | null>;\n  /**\n   * Builds the dynamic GraphQL history query with conditional filter clauses.\n   *\n   * Filter conditions are added only when the corresponding option is present.\n   * EventType filter uses inline GraphQL enum values (not quoted strings).\n   */\n  private buildHistoryQuery;\n  /**\n   * Builds query variables for history queries, mapping options to GraphQL variables.\n   */\n  private buildHistoryVariables;\n  /**\n   * Transforms indexer event nodes to unified HistoryEntry format.\n   *\n   * Maps EVM event types to HistoryChangeType, normalizes account field\n   * based on event type (role → account, ownership → newOwner, admin → newAdmin),\n   * and resolves the role identifier using event-type-aware logic so that\n   * `role.id` is always a valid bytes32 hex string in the EVM context.\n   */\n  private transformToHistoryEntries;\n  /**\n   * Resolves the RoleIdentifier from an indexer event node based on event type.\n   *\n   * - **Role events** (ROLE_GRANTED, ROLE_REVOKED, ROLE_ADMIN_CHANGED): Use the\n   *   actual `node.role` bytes32 value from the indexed event; label from\n   *   roleLabelMap or well-known dictionary.\n   * - **Ownership events** (OWNERSHIP_*): The Ownable pattern has no AccessControl\n   *   role, so we use `DEFAULT_ADMIN_ROLE` (bytes32 zero) as a canonical sentinel\n   *   with `label: 'OWNER'` for display context.\n   * - **Admin events** (ADMIN_*, DEFAULT_ADMIN_*): These events concern the default\n   *   admin role, so we use `DEFAULT_ADMIN_ROLE` with its standard label.\n   *\n   * This ensures `role.id` is always a valid bytes32 hex string, maintaining\n   * consistency with EVM's address/role format conventions. Consumers can use\n   * `role.label` to distinguish ownership vs. admin events.\n   */\n  private resolveRoleFromEvent;\n  /**\n   * Maps an EVM indexer event type string to the unified HistoryChangeType.\n   * Returns 'UNKNOWN' for unrecognized event types.\n   */\n  private mapEventTypeToChangeType;\n  /**\n   * Normalizes the account field from an indexer event node.\n   *\n   * Different event types store the relevant account in different fields:\n   * - Role events (ROLE_GRANTED, ROLE_REVOKED, ROLE_ADMIN_CHANGED): `account`\n   * - Ownership events: `newOwner`\n   * - Admin events: `newAdmin`\n   * - Fallback: `account` or empty string\n   */\n  private normalizeAccountFromEvent;\n}\n/**\n * Creates an EvmIndexerClient instance for a network configuration.\n *\n * @param networkConfig - EVM network configuration (includes indexer URL)\n * @returns A new EvmIndexerClient instance\n */\ndeclare function createIndexerClient(networkConfig: EvmCompatibleNetworkConfig): EvmIndexerClient;\n//#endregion\n//#region src/access-control/onchain-reader.d.ts\n/** Result of readOwnership — raw on-chain data before state classification */\ninterface OwnershipReadResult {\n  /** Owner address, or null if zero address (renounced) */\n  owner: string | null;\n  /** Pending owner address (Ownable2Step), or undefined if not available */\n  pendingOwner?: string;\n}\n/** Result of getAdmin — raw on-chain data for DefaultAdminRules */\ninterface AdminReadResult {\n  /** Default admin address, or null if zero address (renounced) */\n  defaultAdmin: string | null;\n  /** Pending new admin address, or undefined if no scheduled transfer */\n  pendingDefaultAdmin?: string;\n  /**\n   * UNIX timestamp (seconds) at which the pending transfer can be accepted.\n   * Only present when pendingDefaultAdmin is set.\n   *\n   * **Semantic note**: Despite the field name in the unified type (`expirationBlock`),\n   * this is NOT a block number — it is a UNIX timestamp from the contract's\n   * `pendingDefaultAdmin()` return value. See research.md §R5.\n   */\n  acceptSchedule?: number;\n  /** Current admin delay in seconds */\n  defaultAdminDelay?: number;\n  /** Pending new admin delay in seconds (from `pendingDefaultAdminDelay()`) */\n  pendingDefaultAdminDelay?: number;\n  /** UNIX timestamp when the pending delay takes effect (from `pendingDefaultAdminDelay()`) */\n  pendingDefaultAdminDelaySchedule?: number;\n}\n/**\n * Read the current ownership state from an Ownable / Ownable2Step contract.\n *\n * Calls `owner()` (required) and `pendingOwner()` (optional — only Ownable2Step).\n * If `pendingOwner()` reverts or returns the zero address, `pendingOwner` is undefined.\n * If `owner()` returns the zero address, `owner` is returned as `null` (renounced).\n *\n * @param rpcUrl - RPC endpoint URL\n * @param contractAddress - The EVM contract address (0x-prefixed)\n * @param viemChain - Optional viem Chain object for the network\n * @returns Ownership read result with owner and optional pendingOwner\n * @throws OperationFailed if the `owner()` call fails\n */\ndeclare function readOwnership(rpcUrl: string, contractAddress: string, viemChain?: Chain): Promise<OwnershipReadResult>;\n/**\n * Read the current default admin state from an AccessControlDefaultAdminRules contract.\n *\n * Calls `defaultAdmin()`, `pendingDefaultAdmin()`, `defaultAdminDelay()`, and\n * `pendingDefaultAdminDelay()`.\n * If `defaultAdmin()` returns the zero address, `defaultAdmin` is returned as `null` (renounced).\n * If `pendingDefaultAdmin()` returns the zero address as the new admin, no pending transfer\n * is indicated.\n *\n * @param rpcUrl - RPC endpoint URL\n * @param contractAddress - The EVM contract address (0x-prefixed)\n * @param viemChain - Optional viem Chain object for the network\n * @returns Admin read result with defaultAdmin, optional pendingDefaultAdmin and acceptSchedule\n * @throws OperationFailed if the `defaultAdmin()` call fails\n */\ndeclare function getAdmin(rpcUrl: string, contractAddress: string, viemChain?: Chain): Promise<AdminReadResult>;\n/**\n * Read current role assignments for provided role IDs.\n *\n * For each role ID, enumerates members (if `hasEnumerableRoles` is true) or\n * returns the role with an empty members array (caller must check membership\n * via `hasRole` or indexer).\n *\n * Labels are resolved from the optional roleLabelMap (external + ABI-extracted),\n * then the well-known dictionary (DEFAULT_ADMIN_ROLE, MINTER_ROLE, etc.).\n *\n * @param rpcUrl - RPC endpoint URL\n * @param contractAddress - The EVM contract address\n * @param roleIds - Array of bytes32 role identifiers\n * @param hasEnumerableRoles - Whether the contract supports AccessControlEnumerable\n * @param viemChain - Optional viem Chain object\n * @param roleLabelMap - Optional per-contract map of hash -> label for human-readable display\n * @returns Array of role assignments\n */\ndeclare function readCurrentRoles(rpcUrl: string, contractAddress: string, roleIds: string[], hasEnumerableRoles: boolean, viemChain?: Chain, roleLabelMap?: Map<string, string>): Promise<RoleAssignment[]>;\n/**\n * Get the current block number from the RPC endpoint.\n *\n * @param rpcUrl - RPC endpoint URL\n * @param viemChain - Optional viem Chain object\n * @returns The current block number\n * @throws OperationFailed if the call fails\n */\ndeclare function getCurrentBlock(rpcUrl: string, viemChain?: Chain): Promise<number>;\n//#endregion\n//#region src/access-control/types.d.ts\n/**\n * In-memory context stored per registered contract.\n *\n * Not persisted — created on `registerContract()`, enriched on capability\n * detection and role discovery, removed on `dispose()`.\n *\n * Identity: Keyed by normalized (lowercased) `contractAddress` in a\n * `Map<string, EvmAccessControlContext>`.\n */\ninterface EvmAccessControlContext {\n  /** Normalized (lowercased) EVM address with `0x` prefix */\n  contractAddress: string;\n  /** Parsed ABI as ContractSchema (from adapter's `loadContract`) */\n  contractSchema: ContractSchema;\n  /** Role IDs explicitly provided via `registerContract()` or `addKnownRoleIds()` (bytes32 hex) */\n  knownRoleIds: string[];\n  /** Role IDs discovered via indexer query (cached) */\n  discoveredRoleIds: string[];\n  /** Flag to prevent repeated discovery attempts when indexer is unavailable */\n  roleDiscoveryAttempted: boolean;\n  /** Cached capabilities (populated on first `getCapabilities()` call) */\n  capabilities: AccessControlCapabilities | null;\n  /** Merged role label map: hash -> human-readable name (populated by dictionary, ABI scan, and external labels) */\n  roleLabelMap: Map<string, string>;\n  /** Flag to prevent repeated ABI role-constant discovery on first getCurrentRoles/getHistory */\n  abiRoleDiscoveryDone: boolean;\n}\n/**\n * Transaction executor callback type.\n *\n * Provided by the adapter runtime's execution wiring to decouple the access control\n * service from wallet/signing infrastructure. The service assembles transaction data\n * (as `WriteContractParameters`) and delegates execution to this callback.\n *\n * @param txData - Assembled transaction parameters (address, abi, functionName, args)\n * @param executionConfig - Execution strategy configuration (EOA, Relayer, etc.)\n * @param onStatusChange - Optional callback for transaction status updates\n * @param runtimeApiKey - Optional API key for relayer execution\n * @returns Promise resolving to the operation result with transaction hash\n */\ntype EvmTransactionExecutor = (txData: WriteContractParameters, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string) => Promise<OperationResult>;\n//#endregion\n//#region src/access-control/service.d.ts\n/**\n * EVM implementation of AccessControlService.\n *\n * This class is incrementally built across user stories. Phase 3 (US1) provides:\n * - registerContract()\n * - addKnownRoleIds()\n * - getCapabilities()\n * - dispose()\n *\n * Subsequent phases add: getOwnership, getAdminInfo, getCurrentRoles,\n * getCurrentRolesEnriched, grantRole, revokeRole, transferOwnership,\n * acceptOwnership, renounceOwnership, transferAdminRole, acceptAdminTransfer,\n * cancelAdminTransfer, changeAdminDelay, rollbackAdminDelay, renounceRole,\n * getHistory, exportSnapshot, discoverKnownRoleIds.\n */\ndeclare class EvmAccessControlService implements AccessControlService {\n  private readonly contractContexts;\n  private readonly networkConfig;\n  private readonly executeTransaction;\n  private readonly indexerClient;\n  constructor(networkConfig: EvmCompatibleNetworkConfig, executeTransaction: EvmTransactionExecutor);\n  /**\n   * Register a contract for access control operations.\n   *\n   * Validates the contract address and optional role IDs, then stores the context\n   * in-memory. Re-registration overwrites the previous context.\n   *\n   * @param contractAddress - EVM address (0x-prefixed, 42 chars)\n   * @param contractSchema - Parsed ABI as ContractSchema\n   * @param knownRoleIds - Optional bytes32 role identifiers\n   * @throws ConfigurationInvalid if address or role IDs are invalid\n   */\n  registerContract(contractAddress: string, contractSchema: ContractSchema, knownRoleIds?: string[]): void;\n  /**\n   * Add additional known role IDs to a registered contract.\n   *\n   * Merges with existing role IDs using union with deduplication.\n   * Accepts plain role IDs (string) or label pairs ({ id, label }) for human-readable display.\n   * External labels are stored in context.roleLabelMap and take precedence over ABI/dictionary.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param roleIds - Additional bytes32 role identifiers, or { id, label } pairs\n   * @returns Merged array of all known role IDs\n   * @throws ConfigurationInvalid if contract not registered or role IDs invalid\n   */\n  addKnownRoleIds(contractAddress: string, roleIds: Array<string | {\n    id: string;\n    label: string;\n  }>): string[];\n  /**\n   * Ensures ABI role constant discovery has been run once for this contract.\n   * Merges discovered hash -> label into context.roleLabelMap and sets abiRoleDiscoveryDone.\n   */\n  private ensureAbiRoleLabels;\n  /**\n   * Detect access control capabilities from the contract's ABI.\n   *\n   * Results are cached after the first call for a given contract. Also checks\n   * indexer availability for the `supportsHistory` flag.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @returns Detected capabilities\n   * @throws ConfigurationInvalid if contract not registered or address invalid\n   */\n  getCapabilities(contractAddress: string): Promise<AccessControlCapabilities>;\n  /**\n   * Get current ownership state.\n   *\n   * On-chain reads: `owner()`, `pendingOwner()` (if Ownable2Step)\n   * Indexer enrichment: pending transfer initiation timestamp/tx\n   *\n   * State mapping:\n   * - owner !== zeroAddress && no pendingOwner → 'owned'\n   * - pendingOwner set → 'pending' (expirationBlock = undefined — no expiration for EVM)\n   * - owner === zeroAddress → 'renounced'\n   * - Never returns 'expired' for EVM (FR-023)\n   *\n   * Graceful degradation (FR-017): Returns on-chain data without enrichment\n   * when the indexer is unavailable.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @returns Ownership information with state classification\n   * @throws ConfigurationInvalid if contract not registered or address invalid\n   */\n  getOwnership(contractAddress: string): Promise<OwnershipInfo>;\n  /**\n   * Initiate ownership transfer.\n   *\n   * - Ownable: single-step `transferOwnership(newOwner)` — ownership changes immediately\n   * - Ownable2Step: `transferOwnership(newOwner)` — sets `pendingOwner`, requires `acceptOwnership()`\n   *\n   * The `expirationBlock` parameter is **ignored for EVM** — EVM Ownable2Step has no\n   * expiration mechanism (FR-023). The parameter exists for API parity with Stellar.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param newOwner - The new owner address\n   * @param _expirationBlock - Ignored for EVM (no expiration). Exists for Stellar API parity.\n   * @param executionConfig - Execution strategy configuration (EOA, Relayer, etc.)\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered or addresses invalid\n   */\n  transferOwnership(contractAddress: string, newOwner: string, _expirationBlock: number | undefined, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Accept a pending ownership transfer (Ownable2Step only).\n   *\n   * Must be called by the pending owner. No arguments — the caller is\n   * implicitly validated on-chain.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param executionConfig - Execution strategy configuration\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered or address invalid\n   */\n  acceptOwnership(contractAddress: string, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Renounce ownership (Ownable).\n   *\n   * Permanently renounces ownership — after execution, `owner()` returns the zero address\n   * and ownership queries return state `'renounced'`.\n   *\n   * Part of the unified `AccessControlService` interface — gated by\n   * `hasRenounceOwnership` capability flag.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param executionConfig - Execution strategy configuration\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered or address invalid\n   */\n  renounceOwnership(contractAddress: string, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Get expiration metadata for a transfer type.\n   *\n   * EVM semantics:\n   * - Ownership transfers (Ownable2Step): No expiration → mode 'none'\n   * - Admin transfers (AccessControlDefaultAdminRules): Contract-managed accept schedule\n   *   → mode 'contract-managed' with the accept schedule as current value\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param transferType - 'ownership' or 'admin'\n   * @returns Expiration metadata for the UI\n   */\n  getExpirationMetadata(contractAddress: string, transferType: 'ownership' | 'admin'): Promise<ExpirationMetadata>;\n  /**\n   * Get current default admin state (AccessControlDefaultAdminRules).\n   *\n   * On-chain reads: `defaultAdmin()`, `pendingDefaultAdmin()`, `defaultAdminDelay()`\n   * Indexer enrichment: pending transfer initiation timestamp/tx\n   *\n   * State mapping:\n   * - defaultAdmin !== zeroAddress && no pending → 'active'\n   * - pendingDefaultAdmin set → 'pending'\n   * - defaultAdmin === zeroAddress → 'renounced'\n   * - Never returns 'expired' for EVM (FR-023)\n   *\n   * For pending transfers, `acceptSchedule` maps to `expirationBlock` — this is a\n   * **UNIX timestamp in seconds** (NOT a block number). See research.md §R5 for the\n   * semantic divergence between Stellar and EVM.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @returns Admin information with state classification\n   * @throws ConfigurationInvalid if contract not registered or address invalid\n   */\n  getAdminInfo(contractAddress: string): Promise<AdminInfo>;\n  /**\n   * Initiate default admin transfer (AccessControlDefaultAdminRules).\n   *\n   * Assembles `beginDefaultAdminTransfer(newAdmin)` and delegates execution.\n   * The contract's built-in delay determines when the transfer can be accepted.\n   *\n   * The `expirationBlock` parameter is **ignored for EVM** — the delay is\n   * determined by the contract's `defaultAdminDelay()`. The parameter exists\n   * for API parity with Stellar.\n   *\n   * **Guard (FR-024)**: Throws `ConfigurationInvalid` if the contract does not\n   * have the `hasTwoStepAdmin` capability.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param newAdmin - The new admin address\n   * @param _expirationBlock - Ignored for EVM. Exists for Stellar API parity.\n   * @param executionConfig - Execution strategy configuration\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered, address invalid, or lacks hasTwoStepAdmin\n   */\n  transferAdminRole(contractAddress: string, newAdmin: string, _expirationBlock: number | undefined, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Accept a pending default admin transfer (AccessControlDefaultAdminRules).\n   *\n   * Must be called by the pending admin after the accept schedule timestamp.\n   * No arguments — the caller is implicitly validated on-chain.\n   *\n   * **Guard (FR-024)**: Throws `ConfigurationInvalid` if the contract does not\n   * have the `hasTwoStepAdmin` capability.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param executionConfig - Execution strategy configuration\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered, address invalid, or lacks hasTwoStepAdmin\n   */\n  acceptAdminTransfer(contractAddress: string, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Cancel a pending default admin transfer (AccessControlDefaultAdminRules).\n   *\n   * Must be called by the current default admin. Cancels any pending transfer\n   * and resets the pending admin state.\n   *\n   * Part of the unified `AccessControlService` interface — gated by\n   * `hasCancelAdminTransfer` capability flag.\n   *\n   * **Guard (FR-024)**: Throws `ConfigurationInvalid` if the contract does not\n   * have the `hasTwoStepAdmin` capability.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param executionConfig - Execution strategy configuration\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered, address invalid, or lacks hasTwoStepAdmin\n   */\n  cancelAdminTransfer(contractAddress: string, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Change the default admin transfer delay (AccessControlDefaultAdminRules).\n   *\n   * Schedules a change to the delay period. The change itself has a delay\n   * before it takes effect (determined by the current delay).\n   *\n   * Part of the unified `AccessControlService` interface — gated by\n   * `hasAdminDelayManagement` capability flag.\n   *\n   * **Guard (FR-024)**: Throws `ConfigurationInvalid` if the contract does not\n   * have the `hasTwoStepAdmin` capability.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param newDelay - The new delay in seconds (uint48)\n   * @param executionConfig - Execution strategy configuration\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered, address invalid, or lacks hasTwoStepAdmin\n   */\n  changeAdminDelay(contractAddress: string, newDelay: number, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Rollback a pending admin delay change (AccessControlDefaultAdminRules).\n   *\n   * Cancels a scheduled delay change. Must be called by the current default admin\n   * before the delay change takes effect.\n   *\n   * Part of the unified `AccessControlService` interface — gated by\n   * `hasAdminDelayManagement` capability flag.\n   *\n   * **Guard (FR-024)**: Throws `ConfigurationInvalid` if the contract does not\n   * have the `hasTwoStepAdmin` capability.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param executionConfig - Execution strategy configuration\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered, address invalid, or lacks hasTwoStepAdmin\n   */\n  rollbackAdminDelay(contractAddress: string, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Get current role assignments for a registered AccessControl contract.\n   *\n   * Strategy:\n   * 1. If AccessControlEnumerable: enumerate on-chain via `getRoleMember()`\n   * 2. If known role IDs available: use on-chain `readCurrentRoles()` with hasRole checks\n   * 3. If indexer available: attempt to discover role IDs via indexer\n   * 4. Fallback: return empty array\n   *\n   * The `DEFAULT_ADMIN_ROLE` (bytes32 zero) is given the label `\"DEFAULT_ADMIN_ROLE\"`.\n   * Other roles have no label (the keccak256 hash cannot be reversed).\n   *\n   * **Note (FR-026)**: `DEFAULT_ADMIN_ROLE` is NOT auto-included in knownRoleIds.\n   * Consumers must provide it explicitly or rely on indexer discovery.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @returns Array of role assignments with members\n   * @throws ConfigurationInvalid if contract not registered or address invalid\n   */\n  getCurrentRoles(contractAddress: string): Promise<RoleAssignment[]>;\n  /**\n   * Get enriched role assignments with grant metadata from the indexer.\n   *\n   * Builds on `getCurrentRoles()` and enriches each member with grant timestamp,\n   * transaction ID, and block number from the indexer. Falls back to unenriched\n   * data if the indexer is unavailable (graceful degradation per FR-017).\n   *\n   * The `grantedLedger` field in `EnrichedRoleMember` stores an EVM **block number**\n   * despite its Stellar-originated name. This is a consequence of the unified type\n   * design — see data-model.md §6.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @returns Array of enriched role assignments\n   * @throws ConfigurationInvalid if contract not registered or address invalid\n   */\n  getCurrentRolesEnriched(contractAddress: string): Promise<EnrichedRoleAssignment[]>;\n  /**\n   * Grant a role to an account.\n   *\n   * Assembles `grantRole(bytes32 role, address account)` and delegates execution.\n   * Must be called by an account with the role's admin role (typically DEFAULT_ADMIN_ROLE).\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param roleId - The bytes32 role identifier to grant\n   * @param account - The account to grant the role to\n   * @param executionConfig - Execution strategy configuration\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered, addresses invalid, or role ID invalid\n   */\n  grantRole(contractAddress: string, roleId: string, account: string, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Revoke a role from an account.\n   *\n   * Assembles `revokeRole(bytes32 role, address account)` and delegates execution.\n   * Must be called by an account with the role's admin role.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param roleId - The bytes32 role identifier to revoke\n   * @param account - The account to revoke the role from\n   * @param executionConfig - Execution strategy configuration\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered, addresses invalid, or role ID invalid\n   */\n  revokeRole(contractAddress: string, roleId: string, account: string, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Renounce own role.\n   *\n   * Assembles `renounceRole(bytes32 role, address callerConfirmation)` and delegates execution.\n   * The `account` parameter acts as a caller confirmation — on-chain, the contract verifies\n   * it matches `msg.sender` to prevent accidental renouncement.\n   *\n   * Part of the unified `AccessControlService` interface — gated by\n   * `hasRenounceRole` capability flag.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param roleId - The bytes32 role identifier to renounce\n   * @param account - The caller's address for confirmation (must match msg.sender on-chain)\n   * @param executionConfig - Execution strategy configuration\n   * @param onStatusChange - Optional callback for transaction status updates\n   * @param runtimeApiKey - Optional API key for relayer execution\n   * @returns Operation result with transaction hash\n   * @throws ConfigurationInvalid if contract not registered, addresses invalid, or role ID invalid\n   */\n  renounceRole(contractAddress: string, roleId: string, account: string, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  /**\n   * Query historical access control events from the indexer.\n   *\n   * Delegates to the indexer client's `queryHistory()` with filter/pagination options.\n   * Supports filtering by: role, account, event type, time range, and pagination.\n   *\n   * **Graceful degradation (FR-017)**: Returns an empty `PaginatedHistoryResult`\n   * (`{ items: [], pageInfo: { hasNextPage: false } }`) when:\n   * - The indexer is unavailable\n   * - The indexer query returns null\n   * - The indexer query throws an error\n   *\n   * @param contractAddress - Previously registered contract address\n   * @param options - Optional filtering and pagination options\n   * @returns Paginated history result\n   * @throws ConfigurationInvalid if contract not registered or address invalid\n   */\n  getHistory(contractAddress: string, options?: HistoryQueryOptions): Promise<PaginatedHistoryResult>;\n  /**\n   * Export a point-in-time snapshot of the contract's access control state.\n   *\n   * Combines `getCurrentRoles()` + `getOwnership()` into a unified `AccessSnapshot`.\n   * Ownership is omitted if the contract does not support Ownable (try/catch).\n   * Roles default to an empty array if the read fails.\n   *\n   * **Known limitation**: The unified `AccessSnapshot` type does not include `adminInfo`.\n   * Admin information is accessible separately via `getAdminInfo()`. If a future\n   * `@openzeppelin/ui-types` update adds `adminInfo` to `AccessSnapshot`, this method\n   * should be updated to populate it.\n   *\n   * @param contractAddress - Previously registered contract address\n   * @returns Access control snapshot with roles and optional ownership\n   * @throws ConfigurationInvalid if contract not registered or address invalid\n   * @throws OperationFailed if the snapshot structure fails validation\n   */\n  exportSnapshot(contractAddress: string): Promise<AccessSnapshot>;\n  /**\n   * Discover role IDs from the indexer's historical events.\n   *\n   * Queries the indexer for all unique role IDs that have appeared in events\n   * for the given contract. Results are cached in the contract context — subsequent\n   * calls return the cached value without re-querying (`roleDiscoveryAttempted` flag).\n   *\n   * When `knownRoleIds` were explicitly provided at registration, they are preserved\n   * and merged with any newly discovered roles.\n   *\n   * **Graceful degradation (FR-017)**: Returns an empty array when:\n   * - The indexer is unavailable\n   * - The indexer query returns null\n   * - The indexer query throws an error\n   *\n   * @param contractAddress - Previously registered contract address\n   * @returns Array of known + discovered role IDs (deduplicated)\n   * @throws ConfigurationInvalid if contract not registered or address invalid\n   */\n  discoverKnownRoleIds(contractAddress: string): Promise<string[]>;\n  /**\n   * Clean up resources — clear all contract contexts and indexer resources.\n   *\n   * Safe to call multiple times.\n   */\n  dispose(): void;\n  /**\n   * Retrieves the context for a registered contract, throwing if not found.\n   *\n   * @param contractAddress - Contract address (will be normalized)\n   * @returns The contract context\n   * @throws ConfigurationInvalid if the contract is not registered\n   */\n  private getContextOrThrow;\n  /**\n   * Checks whether an indexer endpoint is configured for this network.\n   *\n   * Uses the config precedence: `accessControlIndexerUrl` on the network config.\n   */\n  private hasIndexerEndpoint;\n  /**\n   * Guards admin operations — ensures the contract has `hasTwoStepAdmin` capability.\n   *\n   * Throws `ConfigurationInvalid` if the contract does not support\n   * AccessControlDefaultAdminRules (FR-024). This prevents any on-chain\n   * interaction with incompatible contracts.\n   *\n   * @param contractAddress - The contract address to check\n   * @throws ConfigurationInvalid if the contract lacks hasTwoStepAdmin capability\n   */\n  private ensureHasTwoStepAdmin;\n  /**\n   * Returns the union of known + discovered role IDs for a context.\n   * Deduplicates the combined set.\n   */\n  private getMergedRoleIds;\n  /**\n   * Attempt to discover role IDs via the indexer.\n   *\n   * Delegates to the indexer client's `discoverRoleIds()`. Results are cached\n   * in the context's `discoveredRoleIds` and the `roleDiscoveryAttempted` flag\n   * prevents retries on failure.\n   *\n   * @internal\n   */\n  private attemptRoleDiscovery;\n  /**\n   * Populate empty member arrays from indexer grant data (non-enumerable contracts).\n   *\n   * For contracts without `AccessControlEnumerable`, on-chain reads cannot enumerate\n   * members. This method queries the indexer's `roleMemberships` to discover who holds\n   * each role, mutating the `assignments` array in place.\n   *\n   * Graceful degradation: if the indexer is unavailable or the query fails,\n   * members stay empty — no error is thrown.\n   *\n   * @internal\n   */\n  private populateMembersFromIndexer;\n  /**\n   * Converts RoleAssignment[] to EnrichedRoleAssignment[] without timestamps.\n   *\n   * Used for graceful degradation when the indexer is unavailable.\n   * Each member gets an `EnrichedRoleMember` with only the `address` field populated.\n   */\n  private convertToEnrichedWithoutTimestamps;\n  /**\n   * Delegates transaction execution to the injected callback.\n   * Single entry point for all write operations (Phase 6+).\n   *\n   * @internal\n   */\n  protected executeAction(txData: WriteContractParameters, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n}\n/**\n * Creates an EvmAccessControlService instance.\n *\n * @param networkConfig - EVM network configuration (includes indexer URL)\n * @param executeTransaction - Callback for transaction execution (provided by runtime composition)\n * @returns A new EvmAccessControlService instance\n */\ndeclare function createEvmAccessControlService(networkConfig: EvmCompatibleNetworkConfig, executeTransaction: EvmTransactionExecutor): EvmAccessControlService;\n//#endregion\n//#region src/access-control/validation.d.ts\n/**\n * EVM Access Control Input Validation\n *\n * Provides throwing validation wrappers for the access control module.\n * Reuses `isValidEvmAddress` from `../utils/validation.ts` for address checks\n * and adds bytes32 role ID validation (access-control-specific).\n *\n * All functions throw `ConfigurationInvalid` from `@openzeppelin/ui-types`\n * on failure, matching the Stellar adapter's error handling pattern.\n *\n * @module access-control/validation\n * @see research.md §R8 — EVM Address and Role Validation\n */\n/**\n * Validates an EVM address, throwing `ConfigurationInvalid` on failure.\n *\n * Delegates to the existing `isValidEvmAddress()` utility (which uses\n * viem's `isAddress()` under the hood). EVM does not distinguish between\n * contract and account addresses — both are 20-byte hex strings — so a\n * single validation function is sufficient.\n *\n * @param address - The EVM address to validate (contract or account)\n * @param paramName - Parameter name for error messages (e.g. 'contractAddress', 'account', 'newOwner')\n * @throws ConfigurationInvalid if the address is empty or not a valid EVM address\n */\ndeclare function validateAddress(address: string, paramName?: string): void;\n/**\n * Validates a role identifier as a bytes32 hex string.\n *\n * EVM AccessControl uses `bytes32` values as role identifiers, typically\n * computed as `keccak256(\"ROLE_NAME\")`. The format is `0x` followed by\n * exactly 64 hex characters (case-insensitive).\n *\n * The `DEFAULT_ADMIN_ROLE` (bytes32 zero: `0x0000...0000`) is a valid role ID.\n *\n * Returns the trimmed, lowercase-normalized role ID so callers can use the\n * sanitized value in downstream operations (e.g. transaction assembly, Set\n * deduplication, Map lookups). Normalizing to lowercase at the validation\n * boundary ensures case-insensitive deduplication across all consumers.\n *\n * @param roleId - The role identifier to validate\n * @param paramName - Optional parameter name for error messages (defaults to 'roleId')\n * @returns The trimmed, lowercase-normalized, validated role ID\n * @throws ConfigurationInvalid if the role ID is invalid\n */\ndeclare function validateRoleId(roleId: string, paramName?: string): string;\n/**\n * Validates an array of role identifiers.\n *\n * Each role ID is validated as a bytes32 hex string. The array is deduplicated\n * before returning. An empty array is valid (means no known role IDs).\n *\n * @param roleIds - The array of role identifiers to validate\n * @param paramName - Optional parameter name for error messages (defaults to 'roleIds')\n * @returns The validated and deduplicated array of role IDs\n * @throws ConfigurationInvalid if the input is not an array or any role ID is invalid\n */\ndeclare function validateRoleIds(roleIds: string[], paramName?: string): string[];\n//#endregion\n//#region src/capabilities/name-resolution.d.ts\n/**\n * Dependencies injected into {@link createNameResolution}.\n *\n * The client is **owned by the composing runtime** (see State Ownership / INV-15) — the capability\n * borrows it and never disposes it.\n */\ninterface CreateNameResolutionOptions {\n  /**\n   * A viem `PublicClient` whose `chain` carries `contracts.ensUniversalResolver` for ENS-supporting\n   * networks. Injected (not constructed here — D-A / INV-25) so the capability inherits the runtime's\n   * transport / timeout / CCIP-Read configuration and stays trivially mockable in unit tests. When\n   * the bound network's chain has no Universal Resolver, `resolveName` returns a typed\n   * `UNSUPPORTED_NETWORK` — it does not throw (D-B).\n   */\n  readonly publicClient: PublicClient;\n  /**\n   * SF-5 — OPTIONAL. A dedicated **mainnet** viem client, used for:\n   *   - `001` SF-5 non-UR forward chain-scoped resolution (`coinType = toCoinType(boundChainId)`)\n   *   - L1 miss-fallback on reverse (002) and forward (SF-4) **only when**\n   *     {@link enableMainnetL1MissFallback} is explicitly `true`\n   *\n   * Also borrowed, never disposed (INV-21). Wiring `ensL1Client` does **not** imply opt-in.\n   * Default miss-fallback posture remains OFF (003 SF-1).\n   */\n  readonly ensL1Client?: PublicClient;\n  /**\n   * SF-1 (003) — OPTIONAL. When `true`, permits mainnet-L1 miss-fallback after a **definitive**\n   * bound-chain empty / NAME_NOT_FOUND-class miss on **both** `resolveAddress` and `resolveName`\n   * (UR-carrying bound chains). When absent or `false` (default), preserves safe posture: reverse\n   * does not consult L1 on bound empty; forward stays bound-UR-authoritative on bound miss.\n   *\n   * Does not relax never-silent-fallback — transport/gateway/timeout failures remain terminal.\n   */\n  readonly enableMainnetL1MissFallback?: boolean;\n}\n/**\n * Create the EVM name-resolution capability (forward path — SF-2).\n *\n * Mirrors {@link createERC4626}: narrows the network config, assembles the service over the injected\n * viem client, and wraps it with `guardRuntimeCapability` for the `RuntimeCapability` surface\n * (network context, idempotent `dispose()`, use-after-dispose → `RuntimeDisposedError` raised before\n * the method body, in-flight-promise rejection on dispose).\n *\n * The capability is ALWAYS constructible on EVM: `isValidName` is network-independent, and\n * `resolveName` is always present (it reports `UNSUPPORTED_NETWORK` for a bound network without a\n * Universal Resolver rather than being omitted). Whole-capability omission is reserved for non-EVM\n * adapters (SC-006). `cleanupStage: 'general'` — the capability releases no RPC resource of its own\n * (it borrows the runtime's client — INV-15).\n */\ndeclare function createNameResolution(config: NetworkConfig, options: CreateNameResolutionOptions): NameResolutionCapability;\n//#endregion\n//#region src/erc3643/error-mapping.d.ts\n/** Context threaded into the mapped error for actionable messages. */\ninterface Erc3643ErrorContext {\n  /** Holder/recipient most relevant to the operation (for holder-scoped errors). */\n  holder?: string;\n  /** Requested base-unit amount, when the operation carries one. */\n  requested?: string;\n}\n/**\n * Map a raw ERC-3643 write failure to a typed error.\n *\n * @param error - The underlying execution error.\n * @param operation - Operation name (e.g. `mint`, `transfer`) for fallback context.\n * @param contractAddress - The token address for error context.\n * @param ctx - Optional holder/amount details for holder-scoped errors.\n */\ndeclare function mapErc3643Error(error: Error, operation: string, contractAddress?: string, ctx?: Erc3643ErrorContext): Error;\n//#endregion\n//#region src/erc3643/types.d.ts\n/** Transaction executor callback — decouples the service from wallet/signing. */\ntype EvmErc3643Executor = CapabilityExecutor;\n/**\n * Construction options for the EVM ERC-3643 service.\n *\n * The capability operates against a single T-REX token (its methods take holder/amount\n * arguments rather than per-call addresses), so the deployment-specific token address is\n * supplied once at construction.\n */\ninterface EvmErc3643ServiceOptions {\n  /** The ERC-3643 (T-REX) token contract address. */\n  tokenAddress: string;\n}\n//#endregion\n//#region src/erc3643/service.d.ts\n/**\n * EVM implementation of the ERC-3643 capability surface.\n */\ndeclare class EvmErc3643Service {\n  private readonly networkConfig;\n  private readonly executeTransaction;\n  private readonly tokenAddress;\n  constructor(networkConfig: EvmCompatibleNetworkConfig, executeTransaction: EvmErc3643Executor, options: EvmErc3643ServiceOptions);\n  balanceOf(holder: string): Promise<Amount>;\n  isVerified(holder: string): Promise<boolean>;\n  isFrozen(holder: string): Promise<boolean>;\n  getJurisdiction(holder: string): Promise<string | undefined>;\n  simulateTransfer(input: {\n    from: string;\n    to: string;\n    amount: Amount;\n  }): Promise<TransferSimulationResult>;\n  mint(input: {\n    to: string;\n    amount: Amount;\n  }, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  burn(input: {\n    from: string;\n    amount: Amount;\n  }, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  transfer(input: {\n    from: string;\n    to: string;\n    amount: Amount;\n  }, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  freeze(input: {\n    holder: string;\n  }, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  unfreeze(input: {\n    holder: string;\n  }, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<OperationResult>;\n  dispose(): void;\n  private rpcUrl;\n  private execute;\n}\n/**\n * Factory for {@link EvmErc3643Service}.\n */\ndeclare function createEvmErc3643Service(networkConfig: EvmCompatibleNetworkConfig, executeTransaction: EvmErc3643Executor, options: EvmErc3643ServiceOptions): EvmErc3643Service;\n//#endregion\n//#region src/erc4626/error-mapping.d.ts\n/** Which write failed, selecting the insufficient-funds error class. */\ntype Erc4626Operation = 'deposit' | 'withdraw';\n/** Context threaded into the mapped error for actionable messages. */\ninterface Erc4626ErrorContext {\n  /** Holder most relevant to the operation. */\n  holder?: string;\n  /** Requested base-unit amount (assets for deposit, shares for withdraw). */\n  requested?: string;\n}\n/**\n * Map a raw ERC-4626 write failure to a typed error.\n *\n * @param error - The underlying execution error.\n * @param operation - `deposit` or `withdraw` — selects the insufficient-funds error class.\n * @param contractAddress - The vault address for error context.\n * @param ctx - Optional holder/amount details for the typed error.\n */\ndeclare function mapErc4626Error(error: Error, operation: Erc4626Operation, contractAddress?: string, ctx?: Erc4626ErrorContext): Error;\n//#endregion\n//#region src/erc4626/types.d.ts\n/** Transaction executor callback — decouples the service from wallet/signing. */\ntype EvmErc4626Executor = CapabilityExecutor;\n/**\n * Construction options for the EVM ERC-4626 service.\n *\n * The capability operates against a single vault (its methods take amounts/shares rather\n * than per-call addresses), so the deployment-specific vault address is supplied once at\n * construction.\n */\ninterface EvmErc4626ServiceOptions {\n  /** The ERC-4626 vault contract address. */\n  vaultAddress: string;\n}\n//#endregion\n//#region src/erc4626/service.d.ts\n/**\n * EVM implementation of the ERC-4626 capability surface (sans the `RuntimeCapability` mixin).\n */\ndeclare class EvmErc4626Service {\n  private readonly networkConfig;\n  private readonly executeTransaction;\n  private readonly vaultAddress;\n  constructor(networkConfig: EvmCompatibleNetworkConfig, executeTransaction: EvmErc4626Executor, options: EvmErc4626ServiceOptions);\n  convertToAssets(shares: Amount): Promise<Amount>;\n  convertToShares(assets: Amount): Promise<Amount>;\n  totalAssets(): Promise<Amount>;\n  deposit(input: {\n    from: string;\n    amount: Amount;\n  }, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<VaultDepositResult>;\n  withdraw(input: {\n    from: string;\n    shares: Amount;\n  }, executionConfig: ExecutionConfig, onStatusChange?: (status: TxStatus, details: TransactionStatusUpdate) => void, runtimeApiKey?: string): Promise<VaultWithdrawResult>;\n  dispose(): void;\n  private rpcUrl;\n  private execute;\n}\n/**\n * Factory for {@link EvmErc4626Service}.\n */\ndeclare function createEvmErc4626Service(networkConfig: EvmCompatibleNetworkConfig, executeTransaction: EvmErc4626Executor, options: EvmErc4626ServiceOptions): EvmErc4626Service;\n//#endregion\n//#region src/name-resolution/error-mapping.d.ts\n/**\n * The closed seven-code taxonomy this module maps INTO, owned by UIKit SF-1 and imported\n * type-only from `@openzeppelin/ui-types`. Reproduced here as documentation ONLY — the\n * authoritative definition lives upstream and is never redefined or modified here.\n *\n * ```ts\n * type NameResolutionError =\n *   | { readonly code: 'NAME_NOT_FOUND';         readonly name: string }\n *   | { readonly code: 'ADDRESS_NOT_FOUND';      readonly address: string }\n *   | { readonly code: 'UNSUPPORTED_NETWORK';    readonly networkId: string }\n *   | { readonly code: 'UNSUPPORTED_NAME';       readonly name: string;    readonly reason: string }\n *   | { readonly code: 'RESOLUTION_TIMEOUT';     readonly elapsedMs: number }\n *   | { readonly code: 'EXTERNAL_GATEWAY_ERROR'; readonly detail: string }\n *   | { readonly code: 'ADAPTER_ERROR';          readonly message: string; readonly cause?: unknown };\n * ```\n */\n/**\n * `RESOLUTION_TIMEOUT.elapsedMs` sentinel for \"not measured\" (INV-12). Chosen over `0` because it\n * is not a physically-realizable elapsed time, so a consumer can distinguish an unmeasured timeout\n * from a genuine sub-millisecond `0`. A `-1` reaching a consumer means a caller omitted its\n * required `ctx.elapsedMs` measurement (cross-SF caller obligation — SF-2/SF-3/SF-5).\n */\ndeclare const ELAPSED_UNMEASURED: -1;\n/**\n * Payload details the mapper cannot recover from a caught error alone; the calling resolution path\n * (SF-2 / SF-3 / SF-5) supplies them at the catch site. All fields optional, so a bare\n * `mapNameResolutionError(error)` is always valid (INV-4); each field only refines the mapped\n * result when its corresponding classification fires.\n */\ninterface NameResolutionErrorContext {\n  /**\n   * The active network id (this repo's `NetworkConfig.networkId` namespace), used to populate\n   * `UNSUPPORTED_NETWORK.networkId`. Omitted → the code still maps, with an empty `networkId` the\n   * caller may backfill.\n   */\n  readonly networkId?: string;\n  /**\n   * Elapsed milliseconds measured by the caller's timeout wrapper, used to populate\n   * `RESOLUTION_TIMEOUT.elapsedMs`. The mapper cannot read a clock (purity, INV-14), so this is\n   * caller-supplied; when absent or not a finite `≥ 0` number the mapper emits\n   * {@link ELAPSED_UNMEASURED} (INV-12).\n   */\n  readonly elapsedMs?: number;\n  /**\n   * Whether the failing call went through an external / off-chain gateway (CCIP-Read, Namechain L2\n   * path — SF-5). Biases an otherwise-ambiguous transport failure toward `EXTERNAL_GATEWAY_ERROR`\n   * and resolves the timeout-vs-gateway precedence: `true` dominates a bare timeout (INV-10).\n   */\n  readonly viaGateway?: boolean;\n}\n/** Forward lookup succeeded structurally but no record exists for this name. */\ndeclare const nameNotFound: (name: string) => Extract<NameResolutionError, {\n  code: \"NAME_NOT_FOUND\";\n}>;\n/** Reverse lookup succeeded structurally but no name maps back to this address. */\ndeclare const addressNotFound: (address: string) => Extract<NameResolutionError, {\n  code: \"ADDRESS_NOT_FOUND\";\n}>;\n/** Input is syntactically not a name in this system (wrong TLD, failed UTS-46, …). */\ndeclare const unsupportedName: (name: string, reason: string) => Extract<NameResolutionError, {\n  code: \"UNSUPPORTED_NAME\";\n}>;\n/** The active network does not support name resolution at all. */\ndeclare const unsupportedNetwork: (networkId: string) => Extract<NameResolutionError, {\n  code: \"UNSUPPORTED_NETWORK\";\n}>;\n/**\n * Convert a native failure raised by the resolution transport into a typed `NameResolutionError`.\n *\n * **Total over expected failures** (INV-6) — always returns a member of the closed union; never\n * throws for a transport / RPC / gateway / timeout failure. Any native error that cannot be\n * classified maps to `ADAPTER_ERROR` carrying the original value as an opaque `cause` (INV-7), so\n * no failure is silently swallowed and no invented code escapes the union (INV-1).\n *\n * The **one** exception to totality: genuine programmer / lifecycle errors on the closed allowlist\n * (INV-9, currently `RuntimeDisposedError`) are re-thrown unchanged, not classified — masking a\n * use-after-dispose bug as an expected failure code would hide a real defect. This is the\n * type-level guarantee behind UIKit INV-8.\n *\n * Pure and side-effect-free (INV-13/INV-14): reads no clock, performs no I/O, logs nothing, and\n * never mutates the caught error.\n *\n * @param error   - The caught native value, typed `unknown` (INV-4). viem's thrown values extend\n *                  `BaseError`, but any value is accepted; non-Error values fall through to\n *                  `ADAPTER_ERROR`.\n * @param context - Payload details the error itself cannot supply. Optional.\n * @returns A member of the closed seven-code `NameResolutionError` union.\n * @throws {RuntimeDisposedError} when `error` is (or wraps) a lifecycle/programmer error on the\n *   allowlist (INV-9). This is the sole `throw` in the module.\n */\ndeclare function mapNameResolutionError(error: unknown, context?: NameResolutionErrorContext): NameResolutionError;\n//#endregion\n//#region src/name-resolution/ens-provenance.d.ts\n/**\n * EVM-specific provenance carried on **every** ENS forward-resolution success — the mainnet-bound\n * CCIP-Read case (the primary v2 case) *and* the L1 cross-chain path (revised D-V9). Extends the\n * chain-agnostic {@link ResolutionProvenance} with facts the adapter can OBSERVE; never a claim the\n * resolution cannot substantiate (Research G4). Narrow to it downstream via {@link isEnsProvenance} —\n * never by string-matching `label`.\n */\ninterface EnsProvenance extends ResolutionProvenance {\n  /**\n   * Discriminant — ALWAYS the literal `'ens'`. The sole sanctioned narrowing key for\n   * {@link isEnsProvenance} (INV-5). Chosen over the stale `version: 'v1' | 'v2'` sketch because\n   * v1/v2 is not reliably observable from viem's `Address | null` return (the Universal Resolver is\n   * one entry point for both — G4). SF-5 sets it on every forward result.\n   */\n  readonly system: 'ens';\n  /**\n   * The ENSIP-9/11 `coinType` the resolution was performed for: `60` for a mainnet-bound (unscoped)\n   * resolution, or a chain-specific value (e.g. Base → `2147492101`) for a chain-scoped one. A JS\n   * `number` — ENSIP-11 EVM coinTypes are `< 2^32`, well within safe-integer range (INV-6). Always set.\n   */\n  readonly coinType: number;\n}\n/**\n * Narrow a base {@link ResolutionProvenance} to the EVM ENS extension (SC-005). Total, pure, and\n * sound: checks the always-present `system` discriminant (INV-10) — never `label`. Returns `true` for\n * every SF-5 forward result, `false` for SF-3's reverse base provenance (no `system`) and any non-EVM\n * adapter's provenance. After a `true`, `p.external` / `p.coinType` / `p.scopedToNetworkId` are safe\n * to read.\n */\ndeclare function isEnsProvenance(p: ResolutionProvenance): p is EnsProvenance;\n/**\n * The bound network's `networkId` **iff** the resolution is chain-scoped (`coinType !== 60`), else\n * `undefined` (INV-7 / D-V6). Single source of the \"scoped iff not mainnet\" rule that\n * {@link buildEnsProvenance} spreads — no coinType→chainId inverse is needed because the target chain\n * *is* the bound network (D-V2). A mainnet-bound result therefore omits the key entirely (key-absent,\n * not `undefined`), matching the base-type convention.\n */\ndeclare function scopedNetworkId(coinType: bigint, networkId: string): string | undefined;\n/**\n * Build the {@link EnsProvenance} for a forward resolution from observed facts (INV-3). `external`\n * comes from the per-call ccipRead observation (INV-9); `coinType` from the bound network (60 for\n * mainnet-bound); `scopedToNetworkId` is added **iff** the result is chain-scoped (INV-7). `label` is\n * a curated literal chosen from `external` — one of `'ENS'` / `'ENS via external gateway'`, never a\n * URL (INV-8). Freshly allocated on every call — never a shared/frozen singleton.\n */\ndeclare function buildEnsProvenance(args: {\n  readonly external: boolean;\n  readonly coinType: bigint;\n  readonly networkId: string;\n}): EnsProvenance;\n/**\n * ENSIP-9/11 forward map: a bound EVM chainId → its `coinType`. A thin wrapper over viem's\n * `toCoinType` (mainnet → `60n`). Throws viem's `EnsInvalidChainIdError` for a non-EVM / out-of-range\n * chainId — the service catches that synchronously and returns `UNSUPPORTED_NETWORK` (INV-16). No\n * coinType→chainId inverse is needed (Research G3 / D-V6): the target chain *is* the bound network.\n *\n * @throws {import('viem').EnsInvalidChainIdError} for a chainId outside the ENSIP-11 addressable range.\n */\ndeclare function deriveCoinType(chainId: number): bigint;\n//#endregion\n//#region src/name-resolution/name-validation.d.ts\n/**\n * Synchronous ENS name shape validation (SF-2).\n *\n * A **pure, synchronous, client-free** shape gate: is a string plausibly a resolvable ENS name?\n * `isValidName` is the UIKit's per-keystroke hot-path predicate (INV-21) and `resolveName`'s own\n * step-2 gate (INV-4) — so it lives here, with no dependency on the service or the injected viem\n * client, and never performs I/O (INV-3, INV-13).\n *\n * The check is **ENSIP-15/UTS-46 `normalize`-based, not a TLD allowlist regex** (Design D-`isValidName`):\n * a `/\\.(eth|xyz|…)$/` allowlist would wrongly reject legitimate wildcard / DNS / non-`.eth` names\n * (`.box`, offchain names) — exactly the resolvable inputs ENS-in-input must accept. A `true` is\n * **necessary but not sufficient** for resolution: it asserts shape, never existence of a record.\n *\n * @module name-resolution/name-validation\n */\n/**\n * Whether `name` is a plausibly-resolvable ENS name — a total, pure, synchronous boolean predicate\n * that **never throws** (INV-3). Three ordered, allocation-light checks (INV-4):\n *\n * 1. **Reject a raw EVM hex address** — an address is not a name; resolving it is a category error\n *    (and lets the UIKit skip a needless resolution round-trip on pasted addresses).\n * 2. **Require at least one `.`** — bare single labels are rejected (Design Open Q3 / INV-4). Cheap\n *    structural pre-filter before the (heavier) normalization step.\n * 3. **Require ENSIP-15/UTS-46 normalizability** — `normalize` throwing is caught and reported as\n *    `false`, never propagated (INV-3): the UIKit calls this inside a render path with no `try/catch`.\n *\n * @param name - Arbitrary user input.\n * @returns `true` iff all three checks pass. Never throws, never does I/O.\n */\ndeclare function isValidName(name: string): boolean;\n/**\n * ENSIP-15/UTS-46 normalization of an ENS name.\n *\n * **Throws** on a structurally-invalid name (viem/@adraffy `ens-normalize`) — unlike {@link isValidName}\n * it does not swallow the failure. `resolveName` calls it as a backstop *after* `isValidName` has\n * already passed, so a throw here is the rare case a name survives the shape gate yet fails deep\n * normalization; the caller maps that throw to `UNSUPPORTED_NAME` (Design D-D), never to the mapper's\n * fuzzy needle path.\n *\n * @param name - A name that has (typically) already passed {@link isValidName}.\n * @returns The ENSIP-15-normalized form, suitable for `getEnsAddress`.\n * @throws When `name` is not a normalizable ENS name.\n */\ndeclare function normalizeName(name: string): string;\n//#endregion\n//#region src/name-resolution/provenance.d.ts\n/**\n * Canonical mainnet repo network id — MUST match `ethereumMainnet.id` in\n * `@openzeppelin/adapter-evm` (`packages/adapter-evm/src/networks/mainnet.ts`).\n * Single source for `resolvedOnNetworkId` on 003 L1 miss-fallback successes (INV-6 / INV-24).\n */\ndeclare const MAINNET_NETWORK_ID: \"ethereum-mainnet\";\n/**\n * The three base fallback fields adapters spread onto any L1 miss-fallback success provenance.\n * Fresh object per call (INV-12). Does not set `label`, `external`, or `scopedToNetworkId` (INV-28).\n *\n * @param args.queriedOnNetworkId — bound adapter `networkConfig.id` that missed first (INV-7).\n * @param args.resolvedOnNetworkId — network where the record was found; 003 always {@link MAINNET_NETWORK_ID}.\n */\ndeclare function networkFallbackProvenanceFields(args: {\n  readonly queriedOnNetworkId: string;\n  readonly resolvedOnNetworkId: string;\n}): Pick<ResolutionProvenance, 'resolvedViaNetworkFallback' | 'queriedOnNetworkId' | 'resolvedOnNetworkId'>;\n/**\n * Spread fallback triplet onto an existing success provenance (forward SF-4 / reverse L1).\n * Preserves `label`, `external`, and `scopedToNetworkId` from the base object (INV-28).\n */\ndeclare function composeNetworkFallbackProvenance(provenance: ResolutionProvenance, args: {\n  readonly queriedOnNetworkId: string;\n  readonly resolvedOnNetworkId: string;\n}): ResolutionProvenance;\n/**\n * Base provenance for a v1 forward resolution: a freshly-allocated `{ label: 'ENS', external: false }`\n * on every call (INV-5).\n *\n * - `label` is the fixed, user-safe literal `'ENS'` — never a URL, gateway host, or keyed identifier\n *   (INV-19; a leak would fail SF-4's `label`-allowlist check). It is a **display** string, not a\n *   discriminant: downstream code must not branch on it.\n * - `external` is `false` on the v1 forward path. SF-2 does not (and per G4 cannot cheaply) detect\n *   incidental CCIP-Read traversal; accurate offchain detection is SF-5's `EnsProvenance` extension.\n * - `scopedToNetworkId` is deliberately **absent** — network-scoping is SF-5's.\n *\n * A fresh object per call (no shared/frozen singleton) so no two success results alias one provenance.\n *\n * @returns A new `ResolutionProvenance` for a canonical ENS v1 forward result.\n */\ndeclare function baseEnsProvenance(): ResolutionProvenance;\n/**\n * Provenance for a **non-mainnet bound-local** reverse hit (002 SF-1 / D-R7). Marks the name as\n * network-local via `scopedToNetworkId` so chain-agnostic consumers can gate display without EVM\n * imports (INV-5 / INV-28). Mainnet-bound hits keep {@link baseEnsProvenance} (absent scope).\n */\ndeclare function boundReverseProvenance(networkId: string): ResolutionProvenance;\n//#endregion\n//#region src/name-resolution/service.d.ts\n/**\n * EVM implementation of the `NameResolutionCapability` forward surface. Holds only the injected viem\n * client and the bound (read-only) network config — no resolution state, cache, or memo (INV-13):\n * repeated calls converge and concurrent calls never interfere.\n */\ndeclare class EvmNameResolutionService {\n  private readonly networkConfig;\n  private readonly publicClient;\n  private readonly ensL1Client?;\n  /**\n   * Frozen at construct time — only `=== true` enables miss-fallback (INV-2 / 003 SF-1).\n   */\n  private readonly enableMainnetL1MissFallback;\n  /**\n   * @param networkConfig - The bound (read-only) network config.\n   * @param publicClient  - The bound per-network viem client (D-A). Borrowed, never disposed (INV-21).\n   * @param ensL1Client   - SF-5, OPTIONAL. Mainnet client for non-UR forward chain-scoped resolution\n   *   and for L1 miss-fallback when {@link enableMainnetL1MissFallback} is explicitly `true`.\n   * @param enableMainnetL1MissFallback - 003 SF-1 opt-in; normalized to strict `true` only (INV-2).\n   */\n  constructor(networkConfig: TypedEvmNetworkConfig, publicClient: PublicClient, ensL1Client?: PublicClient | undefined, enableMainnetL1MissFallback?: boolean);\n  /**\n   * Synchronous ENSIP-15 shape check (INV-3/INV-4). No I/O; delegates to the client-free\n   * {@link isValidEnsName} helper so consumers and `resolveName` share one gate.\n   */\n  isValidName(name: string): boolean;\n  /**\n   * Forward resolution: name → address. Returns a discriminated {@link ResolutionResult}; **never\n   * throws for an expected failure** (INV-1/INV-11). Fixed classification precedence (INV-17):\n   *\n   * 0. use-after-dispose → `RuntimeDisposedError` (raised by the guard proxy, before this body)\n   * 1. CLIENT + coinType selection (sync, before any I/O — INV-16/INV-17):\n   *      a. bound chain carries a Universal Resolver → bound client, `coinType = 60` (mainnet-bound)\n   *      b. else an `ensL1Client` is wired → L1 client, `coinType = toCoinType(boundChainId)`\n   *         (chain-scoped); a non-ENSIP-11 chainId throws → `UNSUPPORTED_NETWORK` (INV-16)\n   *      c. else → `UNSUPPORTED_NETWORK` (D-B preserved — SF-2 parity when no L1 client is wired)\n   * 2. shape gate fails → `UNSUPPORTED_NAME`\n   * 3. normalize throws → `UNSUPPORTED_NAME`  (D-D backstop)\n   * 4–5. delegated to {@link resolveVia}: the one `getEnsAddress` call + ordered catch.\n   * 6. 003 SF-4 (UR bound only): bound `NAME_NOT_FOUND` + opt-in ON → single L1 `resolveVia` +\n   *    SF-2 fallback triplet on success; bound gateway/`UNSUPPORTED_NAME` → terminal (INV-10).\n   *\n   * The selection ladder runs **before** the shape/normalize gates so an unsupported network wins\n   * over a malformed name (SF-2 INV-12 precedence, preserved verbatim: a bad name on an unsupported\n   * network is `UNSUPPORTED_NETWORK`, not `UNSUPPORTED_NAME`). Gates 1–3 all run before any network\n   * round-trip (INV-22).\n   */\n  resolveName(name: string): Promise<ResolutionResult<ResolvedAddress>>;\n  /**\n   * True iff the bound-tier forward attempt is a definitive empty / no-record miss eligible for L1\n   * consult — NOT transport failure, NOT UNSUPPORTED_NAME (SF-4 INV-11 / D-S4-1).\n   */\n  private isForwardBoundMissEligibleForL1;\n  /**\n   * The shared forward success routine, run identically for both client selections (INV-1/INV-3).\n   * Performs the **one** `getEnsAddress` call under `strict: true` (INV-12) on a per-call observing\n   * client (INV-9/INV-18), builds an {@link EnsProvenance} on success from the observed `external`\n   * (INV-3), and classifies a caught failure through the same ordered catch as SF-2 — now feeding the\n   * **observed** `sawOffchain` as `viaGateway` (INV-13) so a gateway failure on either path dominates\n   * to `EXTERNAL_GATEWAY_ERROR` and never silently falls back (INV-14).\n   */\n  private resolveVia;\n  /**\n   * Reverse resolution: address → name (002 SF-1 / 003 SF-3 Option B miss-fallback). Returns a\n   * discriminated {@link ResolutionResult}; **never throws for an expected failure** (INV-7). The\n   * sole sanctioned throw is `RuntimeDisposedError`, raised by the factory's guard proxy *before*\n   * this body runs.\n   *\n   * 003 SF-3 ladder (inherits 002 Option B; L1 tiers gated by SF-1 `mayConsultL1ForMissFallback()`):\n   *\n   * 0. use-after-dispose → `RuntimeDisposedError` (guard proxy)\n   * 1. malformed address → `ADDRESS_NOT_FOUND` (sync, before I/O)\n   * 2. `supportsEns()` → bound `attemptReverse` first\n   *      - success → bound provenance per D-R7; stop (no L1)\n   *      - failure → typed error; stop (**no** miss-fallback — INV-9)\n   *      - empty + `mayConsultL1ForMissFallback()` → L1 `attemptReverse` (003 SF-1)\n   *      - empty + gate false → `ADDRESS_NOT_FOUND`\n   * 3. else `mayConsultL1ForMissFallback()` → L1 direct (non-UR)\n   * 4. else → `UNSUPPORTED_NETWORK` (sync, before I/O)\n   *\n   * L1 success after bound-empty miss: `buildEnsProvenance` + SF-2 fallback triplet\n   * (`precededByBoundMiss`). Non-UR direct L1: `buildEnsProvenance` only (001-1b parity).\n   * `scopedToNetworkId` absent on all L1 hits (002 D-R7). Opt-in OFF: bound-empty / non-UR\n   * terminate without L1 (SF-1 SC-001).\n   *\n   * Bound and L1 attempts use `strict: true`, Approach A suppress-on-mismatch, observing clients\n   * for truthful `viaGateway`, and selected-client avatar affinity (INV-18).\n   *\n   * @throws {RuntimeDisposedError} on use-after-dispose (guard proxy, before this body) — the sole throw.\n   */\n  resolveAddress(address: string): Promise<ResolutionResult<ResolvedName>>;\n  /**\n   * Terminal handling for an L1 reverse attempt (direct or miss-fallback). No further client exists\n   * after L1 — empty and failure both terminate here (INV-10).\n   *\n   * @param precededByBoundMiss - When true, bound UR tier returned definitive empty before this L1\n   *   consult — SF-2 triplet is emitted on success. False for non-UR direct L1 (001-1b parity).\n   */\n  private finishL1Attempt;\n  /**\n   * One reverse I/O against `client`: observing wrapper, strict `getEnsName`, Approach A catch table,\n   * avatar on success via the **same** client (D-R8 / INV-18). Returns success | empty | failure so\n   * the ladder can distinguish miss-fallback eligibility from typed transport failure (INV-9).\n   */\n  private attemptReverse;\n  /**\n   * Authoritative miss-fallback eligibility for both directions (003 SF-1 INV-5).\n   * L1 consult is permitted only when opt-in is strictly true, L1 client is wired, and the adapter\n   * is not mainnet-bound (INV-24).\n   */\n  private mayConsultL1ForMissFallback;\n  /** True when the bound chain is Ethereum mainnet — drives miss-fallback fence and D-R7 scope (INV-22). */\n  private isMainnetBound;\n  /**\n   * No-op teardown beyond a debug log. The injected `PublicClient` is owned by the composing runtime\n   * (D-A / INV-15): the capability BORROWS it and never closes its transport — after dispose the same\n   * client remains fully usable by the runtime and any capability sharing it. `cleanupStage` is\n   * `'general'` (not `'rpc'`) precisely because SF-2 releases no RPC resource of its own.\n   */\n  dispose(): void;\n  /**\n   * Whether the bound chain carries an ENS Universal Resolver — mirrors what viem's\n   * `getChainContractAddress` reads. Purely synchronous; the pre-I/O basis of D-B (INV-16) that\n   * pre-empts viem's own `ChainDoesNotSupportContract`/no-chain throws before the network call.\n   */\n  private supportsEns;\n  /**\n   * Best-effort, name-keyed avatar lookup (D-R5). Runs ONLY after a successful reverse and is fully\n   * failure- and latency-isolated (INV-17): a SECOND UR round-trip (`getEnsAvatar` → text `avatar`\n   * key) plus a possible THIRD hop inside viem's `parseAvatarRecord` (NFT/IPFS/HTTP asset resolution).\n   * ANY outcome — gateway error, unreachable asset host, malformed avatar record, timeout — yields\n   * `undefined`, never widening the reverse call's never-throw surface (INV-6) and never participating\n   * in error classification (INV-8/INV-10). viem itself swallows `parseAvatarRecord` errors → `null`;\n   * the `try/catch` here additionally absorbs the UR/text-lookup throws `strict: true` would raise, and\n   * `?? undefined` normalizes a `null` so the caller's conditional spread never emits `avatarUrl: null`\n   * (INV-4).\n   *\n   * The returned URL is untrusted, name-owner-controlled content (INV-19): passed through verbatim —\n   * the adapter neither fetches nor sanitizes the asset beyond what `getEnsAvatar` already did — and it\n   * (and the avatar record) is never logged. viem defaults are used; no custom gateway/host or deadline\n   * is hardcoded (INV-18/INV-20). No retry loop — a single bounded `await` (INV-18).\n   */\n  private tryGetAvatar;\n}\n/**\n * Factory for {@link EvmNameResolutionService}. Both clients are injected (not constructed here) so the\n * service inherits the runtime's transport / timeout / CCIP-Read config and stays trivially mockable\n * (D-A / INV-25). `ensL1Client` is optional: when omitted the service resolves mainnet-bound exactly\n * as SF-2 does, and an L2-bound resolve returns `UNSUPPORTED_NETWORK` (D-B preserved).\n */\ninterface CreateEvmNameResolutionServiceOptions {\n  readonly enableMainnetL1MissFallback?: boolean;\n}\ndeclare function createEvmNameResolutionService(networkConfig: TypedEvmNetworkConfig, publicClient: PublicClient, ensL1Client?: PublicClient, options?: CreateEvmNameResolutionServiceOptions): EvmNameResolutionService;\n//#endregion\n//#region src/profiles/index.d.ts\ndeclare function createRuntime(profile: ProfileName, config: NetworkConfig, factories: CapabilityFactoryMap, options?: {\n  uiKit?: string;\n}): EcosystemRuntime;\n//#endregion\nexport { type AbiComparisonResult, AbiComparisonService, type AbiDifference, type AbiItem, type AbiValidationResult, type AdapterExecutionStrategy, type AppInfo, type ConnectButtonProps, ConnectorDialog, type ContractLoadOptions, type CreateAccessControlOptions, type CreateERC3643Options, type CreateERC4626Options, type CreateEvmNameResolutionServiceOptions, type CreateIRSOptions, type CreateNameResolutionOptions, CustomAccountDisplay, CustomConnectButton, CustomNetworkSwitcher, DEFAULT_ADMIN_ROLE, DEFAULT_ADMIN_ROLE_LABEL, DEFAULT_DISCONNECTED_STATUS, type DeployOnchainIdConfirmedResult, type DeployOnchainIdOutcome, type DeployOnchainIdSubmittedResult, ELAPSED_UNMEASURED, EVM_PROVIDER_ORDER_DEFAULT, EVM_TYPE_TO_FIELD_TYPE, type EnsProvenance, EoaExecutionStrategy, type Erc3643ErrorContext, type Erc4626ErrorContext, type Erc4626Operation, type EtherscanAbiResult, type EvmAbiLoadResult, type EvmAccessControlContext, EvmAccessControlService, type EvmCompatibleNetworkConfig, type EvmContractArtifacts, type EvmContractDefinitionProviderKey, type EvmContractLoadResult, type EvmErc3643Executor, EvmErc3643Service, type EvmErc3643ServiceOptions, type EvmErc4626Executor, EvmErc4626Service, type EvmErc4626ServiceOptions, type EvmIRSAddresses, type EvmIRSExecutor, EvmIRSService, type EvmIRSServiceOptions, EvmIndexerClient, EvmNameResolutionService, EvmProviderKeys, type EvmProxyInfo, type EvmRelayerTransactionOptions, type EvmTransactionData, type EvmTransactionExecutor, type EvmWalletConnectionResult, type EvmWalletConnectionStatus, type EvmWalletDisconnectResult, type EvmWalletImplementation, type EvmWalletStatus, type GetWagmiConfigForRainbowKitFn, MAINNET_NETWORK_ID, type NameResolutionErrorContext, type ProxyDetectionResult, type RainbowKitAssetsResult, type RainbowKitConfigOptions, type RainbowKitConnectButtonProps, type RainbowKitCustomizations, type RainbowKitKitConfig, type RainbowKitProviderProps, RelayerExecutionStrategy, SafeWagmiComponent, type SourcifyAbiResult, type TypedEvmNetworkConfig, type UiKitManager, type UiKitManagerDependencies, type UiKitManagerState, type WagmiConfigChains, WagmiProviderInitializedContext, type WagmiWalletConfig, WagmiWalletImplementation, type WalletNetworkConfig, type WriteContractParameters, ZERO_ADDRESS, abiComparisonService, addressNotFound, assembleAcceptAdminTransferAction, assembleAcceptOwnershipAction, assembleBeginAdminTransferAction, assembleCancelAdminTransferAction, assembleChangeAdminDelayAction, assembleGrantRoleAction, assembleRenounceOwnershipAction, assembleRenounceRoleAction, assembleRevokeRoleAction, assembleRollbackAdminDelayAction, assembleTransferOwnershipAction, baseEnsProvenance, boundReverseProvenance, buildClaimPayload, buildEnsProvenance, buildRpcUrl, compareContractDefinitions, composeNetworkFallbackProvenance, connectAndEnsureCorrectNetworkCore, createAbiFunctionItem, createAccessControl, createAddressing, createComposerRuntime, createContractLoading, createDeclarativeRuntime, createERC3643, createERC4626, createEvmAccessControlService, createEvmErc3643Service, createEvmErc4626Service, createEvmIRSService, createEvmNameResolutionService, createEvmPublicClient, createExecution, createExplorer, createIRS, createIndexerClient, createNameResolution, createNetworkCatalog, createOperatorRuntime, createQuery, createRainbowKitComponents, createRainbowKitConnectButton, createRainbowKitWagmiConfig, createRelayer, createRuntime, createSchema, createTransactorRuntime, createTypeMapping, createUiKit, createUiKitManager, createUiLabels, createViewerRuntime, createWallet, deriveCoinType, detectAccessControlCapabilities, detectProxyFromAbi, ensureRainbowKitAssetsLoaded, executeEvmTransaction, extractRainbowKitCustomizations, filterWalletComponents, formatEvmFunctionResult, formatEvmTransactionData, formatInputName, formatMethodName, generateEvmDefaultField, generateRainbowKitConfigFile, generateRainbowKitExportables, getAdmin, getAdminAddress, getComponentExclusionsFromConfig, getCurrentBlock, getEvmCompatibleFieldTypes, getEvmCurrentBlock, getEvmExplorerAddressUrl, getEvmExplorerTxUrl, getEvmTypeMappingInfo, getImplementationAddress, getJurisdiction as getIrsJurisdiction, getOnchainId, getRawUserNativeConfig, getSourcifyContractAppUrl, getUserAccessControlIndexerUrl, getUserRpcUrl, getWagmiConfigForRainbowKit, gweiToWei, hashContractDefinition, isEnsProvenance, isEvmContractArtifacts, isEvmProviderKey, isEvmViewFunction, isVerified as isIrsVerified, isRainbowKitCustomizations, isTrustedIssuer, isValidAbiArray, isValidAbiItem, isValidEvmAddress, isValidName, loadAbiFromEtherscan, loadAbiFromEtherscanV1, loadAbiFromEtherscanV2, loadAbiFromSourcify, loadContractSchema, loadContractWithFullMetadata, loadEvmContract, mapErc3643Error, mapErc4626Error, mapEvmParamTypeToFieldType, mapNameResolutionError, nameNotFound, networkFallbackProvenanceFields, normalizeName, parseEvmInput, queryEvmViewFunction, readCurrentRoles, readOwnership, resolveAccessControlIndexerUrl, resolveAndInitializeKitConfig, resolveExplorerApiKeyFromAppConfig, resolveExplorerConfig, resolveFullUiKitConfiguration, resolveRpcUrl, scopedNetworkId, shouldUseV2Api, signAndBroadcastEvmTransaction, stringifyWithBigInt, testEtherscanV2Connection, testEvmExplorerConnection, testEvmNetworkServiceConnection, testEvmRpcConnection, transformAbiToSchema, unsupportedName, unsupportedNetwork, useIsWagmiProviderInitialized, useManagedWagmiDisconnect, validateAccessControlSupport, validateAddress, validateAndConvertEvmArtifacts, validateContractDefinition, validateEoaConfig, validateEvmEoaConfig, validateEvmExecutionConfig, validateEvmExplorerConfig, validateEvmNetworkServiceConfig, validateEvmRelayerConfig, validateEvmRpcEndpoint, validateRainbowKitConfig, validateRelayerConfig, validateRoleId, validateRoleIds, waitForEvmTransactionConfirmation, weiToGwei };\n//# sourceMappingURL=index.d.mts.map"],"mappings":";;;;;;;;;;;UAGUK,0BAAAA;gEACsDJ,0CAA0CG,mBAAmBD,6DAA6DG;;;;;;;;;;;;;;UCuIhLiC,4BAAAA;UACAtB;;;;;;;;;;;;;;;;;;;;;;UCmFAyM,mBAAAA;;;;eAIKC;;;;;;;;;UASLA,aAAAA;;;;;;;;;;;;;;;;;;;UAmBAC,mBAAAA;;;;;;;;kBAQQhF;;;;;;;;;;;cAeJmF,oBAAAA;;;;2CAI6BL;;;;kCAITE;;;;;;;;;;;;;;;;;;;;;cAqBpBI,sBAAsBD;;;;;;;;;;;;;;;;;;;;;;;;;KAkgB/B0C,OAAAA,GAAUC,KAAAA,CAAMC,sBAAsBrE;;;;;KAKtCsE,4BAAAA,GAA+BF,KAAAA,CAAMC,sBAAsBtE;;;;;UAKtDwE,uBAAAA;YACEJ;;;;;;;;KAQPK,mBAAAA,GAAsBC,QAAQN;kBACjBI;;;;;;;UAORG,wBAAAA;;;;;kBAKQD,QAAQH;;;;;iBAKTK,0BAAAA,uBAAiDD;;;;iBAIjDE,+BAAAA,YAA2C1D,sCAAsCwD;;;;;;;;;;;;;;;;;;;;;UA4lDxF6F,2BAAAA;;;;;;;;yBAQe9N;;;;;;;;;;yBAUAA;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBR+N,oBAAAA,SAA6B9L,wBAAwB6L,8BAA8BhM"}