{"version":3,"file":"shared-B3Mu3EYd.cjs","names":["createEvmPublicClient","resolveRpcUrl","mainnet","ethereumMainnet","createAddressing","createExplorer","createNetworkCatalog","createUiLabels","createContractLoading","createSchema","createTypeMapping","createQuery","createExecution","createWallet","createUiKit","createRelayer","createNameResolution","createAccessControl","createCoreRuntime"],"sources":["../../adapter-runtime-utils/src/runtime-factories.ts","../../adapter-runtime-utils/src/runtime-capability.ts","../src/profiles/shared.ts"],"sourcesContent":["import type { CapabilityFactoryMap, NetworkConfig } from '@openzeppelin/ui-types';\n\ntype RuntimeCapabilityInstance = ReturnType<\n NonNullable\n>;\n\ntype GetRuntimeCapability = (\n key: K\n) => RuntimeCapabilityInstance;\n\n/**\n * Creates one runtime-scoped capability instance, with access to other lazily\n * memoized capabilities in the same runtime graph.\n */\nexport type RuntimeCapabilityCreator<\n TConfig extends NetworkConfig,\n K extends keyof CapabilityFactoryMap,\n> = (config: TConfig, getCapability: GetRuntimeCapability) => RuntimeCapabilityInstance;\n\n/**\n * Partial set of runtime capability creators used to assemble a lazily resolved\n * `CapabilityFactoryMap` for a concrete network configuration.\n */\nexport type RuntimeCapabilityCreatorMap = {\n [K in keyof CapabilityFactoryMap]?: RuntimeCapabilityCreator;\n};\n\n/**\n * Converts runtime-scoped capability creators into the factory surface expected\n * by adapter profile composition, while memoizing each capability per runtime.\n */\nexport function createLazyRuntimeCapabilityFactories(\n config: TConfig,\n creators: RuntimeCapabilityCreatorMap\n): CapabilityFactoryMap {\n const capabilityCache = new Map();\n\n const getCapability: GetRuntimeCapability = (\n key: K\n ): RuntimeCapabilityInstance => {\n if (capabilityCache.has(key)) {\n return capabilityCache.get(key) as RuntimeCapabilityInstance;\n }\n\n const creator = creators[key];\n if (!creator) {\n throw new Error(`Capability factory \"${String(key)}\" is not defined.`);\n }\n\n const capability = creator(config, getCapability);\n capabilityCache.set(key, capability);\n return capability;\n };\n\n return {\n addressing: creators.addressing\n ? (_config?: NetworkConfig) => getCapability('addressing')\n : undefined,\n explorer: creators.explorer\n ? (_config?: NetworkConfig) => getCapability('explorer')\n : undefined,\n networkCatalog: creators.networkCatalog ? () => getCapability('networkCatalog') : undefined,\n uiLabels: creators.uiLabels ? () => getCapability('uiLabels') : undefined,\n contractLoading: creators.contractLoading\n ? (_config: NetworkConfig) => getCapability('contractLoading')\n : undefined,\n schema: creators.schema ? (_config: NetworkConfig) => getCapability('schema') : undefined,\n typeMapping: creators.typeMapping\n ? (_config: NetworkConfig) => getCapability('typeMapping')\n : undefined,\n query: creators.query ? (_config: NetworkConfig) => getCapability('query') : undefined,\n execution: creators.execution\n ? (_config: NetworkConfig) => getCapability('execution')\n : undefined,\n wallet: creators.wallet ? (_config: NetworkConfig) => getCapability('wallet') : undefined,\n uiKit: creators.uiKit ? (_config: NetworkConfig) => getCapability('uiKit') : undefined,\n relayer: creators.relayer ? (_config: NetworkConfig) => getCapability('relayer') : undefined,\n accessControl: creators.accessControl\n ? (_config: NetworkConfig) => getCapability('accessControl')\n : undefined,\n nameResolution: creators.nameResolution\n ? (_config: NetworkConfig) => getCapability('nameResolution')\n : undefined,\n };\n}\n","import type { NetworkConfig, RuntimeCapability } from '@openzeppelin/ui-types';\nimport { RuntimeDisposedError } from '@openzeppelin/ui-types';\n\n/**\n * Ordered cleanup buckets for runtime-backed capabilities.\n * Earlier stages release observers and subscriptions before stateful resources\n * such as wallets or RPC clients are torn down.\n */\nexport type RuntimeCleanupStage = 'listener' | 'subscription' | 'general' | 'wallet' | 'rpc';\n\n/**\n * Disposal order for registered cleanup hooks.\n * Tests assert this sequence because downstream adapters rely on listeners and\n * subscriptions being removed before heavier resources are released.\n */\nconst CLEANUP_STAGE_ORDER: RuntimeCleanupStage[] = [\n 'listener',\n 'subscription',\n 'general',\n 'wallet',\n 'rpc',\n];\n\ninterface RuntimeCapabilityLifecycle {\n isDisposed(): boolean;\n dispose(): void;\n registerCleanup(stage: RuntimeCleanupStage, cleanup: () => void | Promise): void;\n trackPromise(promise: Promise): Promise;\n}\n\nconst runtimeCapabilityLifecycleSymbol = Symbol('runtimeCapabilityLifecycle');\n\ntype RuntimeCapabilityTarget = RuntimeCapability & {\n [runtimeCapabilityLifecycleSymbol]?: RuntimeCapabilityLifecycle;\n};\n\nfunction isPromiseLike(value: unknown): value is PromiseLike {\n return (\n typeof value === 'object' &&\n value !== null &&\n 'then' in value &&\n typeof (value as { then: unknown }).then === 'function'\n );\n}\n\nfunction safelyRunCleanup(cleanup: () => void | Promise): void {\n try {\n void Promise.resolve(cleanup()).catch(() => undefined);\n } catch {\n // Swallow teardown failures to keep dispose idempotent.\n }\n}\n\nfunction createRuntimeCapabilityLifecycle(capabilityName: string): RuntimeCapabilityLifecycle {\n let disposed = false;\n const pending = new Set<{\n reject: (error: RuntimeDisposedError) => void;\n settle: () => void;\n }>();\n const cleanups: Record void | Promise>> = {\n listener: [],\n subscription: [],\n general: [],\n wallet: [],\n rpc: [],\n };\n\n return {\n isDisposed() {\n return disposed;\n },\n\n dispose() {\n if (disposed) {\n return;\n }\n\n disposed = true;\n\n const disposalError = new RuntimeDisposedError(capabilityName);\n for (const operation of [...pending]) {\n operation.reject(disposalError);\n }\n\n for (const stage of CLEANUP_STAGE_ORDER) {\n for (const cleanup of cleanups[stage]) {\n safelyRunCleanup(cleanup);\n }\n }\n },\n\n registerCleanup(stage: RuntimeCleanupStage, cleanup: () => void | Promise) {\n cleanups[stage].push(cleanup);\n },\n\n trackPromise(promise: Promise): Promise {\n if (disposed) {\n return Promise.reject(new RuntimeDisposedError(capabilityName));\n }\n\n return new Promise((resolve, reject) => {\n let settled = false;\n\n const operation = {\n reject(error: RuntimeDisposedError) {\n if (settled) {\n return;\n }\n\n settled = true;\n pending.delete(operation);\n reject(error);\n },\n settle() {\n if (settled) {\n return;\n }\n\n settled = true;\n pending.delete(operation);\n },\n };\n\n pending.add(operation);\n\n void promise.then(\n (result) => {\n if (settled) {\n return;\n }\n\n operation.settle();\n resolve(result);\n },\n (error) => {\n if (settled) {\n return;\n }\n\n operation.settle();\n reject(error);\n }\n );\n });\n },\n };\n}\n\nfunction createRuntimeCapabilityProxy(\n target: T,\n networkConfig: TNetworkConfig,\n capabilityName: string,\n lifecycle: RuntimeCapabilityLifecycle\n): T & RuntimeCapability {\n const capabilityTarget = target as T & RuntimeCapabilityTarget;\n\n Object.defineProperties(capabilityTarget, {\n networkConfig: {\n configurable: true,\n enumerable: true,\n get() {\n if (lifecycle.isDisposed()) {\n throw new RuntimeDisposedError(capabilityName);\n }\n\n return networkConfig;\n },\n },\n dispose: {\n configurable: true,\n enumerable: false,\n value() {\n lifecycle.dispose();\n },\n },\n [runtimeCapabilityLifecycleSymbol]: {\n configurable: false,\n enumerable: false,\n value: lifecycle,\n },\n });\n\n let capabilityProxy: (T & RuntimeCapability) | undefined;\n\n capabilityProxy = new Proxy(capabilityTarget as T & RuntimeCapability, {\n get(currentTarget, property, receiver) {\n if (property === runtimeCapabilityLifecycleSymbol) {\n return lifecycle;\n }\n\n if (property === 'dispose') {\n return Reflect.get(currentTarget, property, receiver);\n }\n\n const value = Reflect.get(currentTarget, property, receiver);\n\n if (typeof value === 'function') {\n return (...args: unknown[]) => {\n if (lifecycle.isDisposed()) {\n throw new RuntimeDisposedError(capabilityName);\n }\n\n const result = Reflect.apply(value, capabilityProxy, args);\n return isPromiseLike(result) ? lifecycle.trackPromise(Promise.resolve(result)) : result;\n };\n }\n\n if (lifecycle.isDisposed()) {\n throw new RuntimeDisposedError(capabilityName);\n }\n\n return value;\n },\n });\n\n return capabilityProxy;\n}\n\n/**\n * Creates a minimal runtime capability shell that can be extended with methods\n * while still enforcing disposal semantics and pending-promise rejection.\n */\nexport function withRuntimeCapability(\n networkConfig: TNetworkConfig,\n capabilityName = 'capability'\n): RuntimeCapability {\n return createRuntimeCapabilityProxy({}, networkConfig, capabilityName, {\n ...createRuntimeCapabilityLifecycle(capabilityName),\n });\n}\n\n/**\n * Wraps an existing capability object with runtime disposal guards.\n * Optional cleanup hooks are registered on the same lifecycle so composed\n * services can tear down external resources alongside the capability.\n */\nexport function guardRuntimeCapability(\n capability: T,\n networkConfig: TNetworkConfig,\n capabilityName: string,\n onDispose?: () => void | Promise,\n cleanupStage: RuntimeCleanupStage = 'general'\n): T & RuntimeCapability {\n const lifecycle = createRuntimeCapabilityLifecycle(capabilityName);\n\n if (onDispose) {\n lifecycle.registerCleanup(cleanupStage, onDispose);\n }\n\n return createRuntimeCapabilityProxy(capability, networkConfig, capabilityName, lifecycle);\n}\n\n/**\n * Registers cleanup work on a runtime capability lifecycle.\n * No-op when the capability was not created through the runtime lifecycle helpers.\n */\nexport function registerRuntimeCapabilityCleanup(\n capability: RuntimeCapability,\n cleanup: () => void | Promise,\n cleanupStage: RuntimeCleanupStage = 'general'\n): void {\n const lifecycle = (capability as RuntimeCapabilityTarget)[runtimeCapabilityLifecycleSymbol];\n lifecycle?.registerCleanup(cleanupStage, cleanup);\n}\n","import { mainnet } from 'viem/chains';\n\nimport type { TypedEvmNetworkConfig } from '@openzeppelin/adapter-evm-core';\nimport {\n createRuntime as createCoreRuntime,\n createEvmPublicClient,\n resolveRpcUrl,\n} from '@openzeppelin/adapter-evm-core';\nimport {\n createLazyRuntimeCapabilityFactories,\n registerRuntimeCapabilityCleanup,\n} from '@openzeppelin/adapter-runtime-utils';\nimport type {\n CapabilityFactoryMap,\n CreateRuntimeOptions,\n EcosystemRuntime,\n ExecutionConfig,\n NetworkConfig,\n ProfileName,\n TransactionStatusUpdate,\n TxStatus,\n} from '@openzeppelin/ui-types';\n\nimport {\n createAccessControl,\n createAddressing,\n createContractLoading,\n createExecution,\n createExplorer,\n createNameResolution,\n createNetworkCatalog,\n createQuery,\n createRelayer,\n createSchema,\n createTypeMapping,\n createUiKit,\n createUiLabels,\n createWallet,\n} from '../capabilities';\nimport { ethereumMainnet } from '../networks';\n\nfunction toTypedEvmNetworkConfig(config: NetworkConfig): TypedEvmNetworkConfig {\n if (config.ecosystem !== 'evm') {\n throw new Error(`Expected an EVM network configuration, received ${config.ecosystem}.`);\n }\n\n return config as TypedEvmNetworkConfig;\n}\n\n/**\n * Build the viem `PublicClient` injected into the name-resolution capability (SF-2, D-A). Constructed\n * here — the composition layer, where `config.viemChain` is in scope — and injected at the capability\n * boundary. `config.viemChain` for ENS-supporting networks carries `contracts.ensUniversalResolver`;\n * where it does not, `createEvmPublicClient` falls back to a minimal chain with no contracts, so the\n * capability's sync support-check reports `UNSUPPORTED_NETWORK` rather than crashing (D-B). Relies on\n * viem's default CCIP-Read; SF-5 introduces a dedicated ENS client builder if it needs custom gateways.\n */\nfunction ensClient(config: TypedEvmNetworkConfig) {\n return createEvmPublicClient(resolveRpcUrl(config), config.viemChain);\n}\n\n/**\n * RPC endpoint for the dedicated **mainnet** ENS L1 client (SF-5, Design Open Q4).\n *\n * Precedence mirrors {@link resolveRpcUrl} — user config → app-config override → default — but keyed\n * on the ETHEREUM MAINNET network, never the bound L2: reusing the bound config would resolve the\n * L2's OWN RPC endpoint, the wrong chain for the L1 cross-chain path. When the bound network already\n * *is* Ethereum mainnet, its exact configured endpoint is honored directly; otherwise resolution runs\n * against the canonical {@link ethereumMainnet} record, whose `rpcUrl` is viem's public default and\n * thus the last-resort fallback — so an operator can point the L1 client at a keyed mainnet RPC via\n * the same override mechanism instead of being pinned to the rate-limited public transport. No secret\n * is hardcoded (Principle II), and the resolved URL is never threaded into provenance or errors (INV-24).\n */\n// Exported for unit-testing the mainnet-keyed override precedence. NOT part of the package's public\n// surface: `profiles/index.ts` re-exports only `createRuntime` / `capabilityFactories`, so this\n// helper stays module-internal and is reachable only via the deep `../profiles/shared` path.\nexport function resolveMainnetRpcUrl(config: TypedEvmNetworkConfig): string {\n return config.chainId === mainnet.id ? resolveRpcUrl(config) : resolveRpcUrl(ethereumMainnet);\n}\n\n/**\n * Build the dedicated **mainnet** L1 client injected into name resolution (SF-5, D-V1) — the ENS v2\n * Universal-Resolver entry point. `mainnet` always carries `contracts.ensUniversalResolver` (the\n * DAO-owned UR proxy), so the L1 cross-chain path resolves an L2-bound name chain-scoped via L1\n * (`coinType = toCoinType(boundChainId)`). Borrowed by the capability, never disposed (INV-21). The\n * bound per-network `ensClient` above is unchanged.\n */\nfunction ensL1Client(config: TypedEvmNetworkConfig) {\n return createEvmPublicClient(resolveMainnetRpcUrl(config), mainnet);\n}\n\n/**\n * Shared `createNameResolution` options for profile factories (003 SF-1).\n *\n * Static {@link capabilityFactories} omit runtime options — miss-fallback stays OFF (INV-12).\n * {@link createRuntime} threads `CreateRuntimeOptions.nameResolution.enableMainnetL1MissFallback`\n * when strictly `=== true` (INV-2).\n */\nfunction buildNameResolutionCreateOptions(\n config: TypedEvmNetworkConfig,\n runtimeOptions?: CreateRuntimeOptions\n) {\n const enableMainnetL1MissFallback = runtimeOptions?.nameResolution?.enableMainnetL1MissFallback;\n\n return {\n publicClient: ensClient(config),\n // ensL1Client is only useful for L2→L1 cross-chain; on mainnet-bound the bound client already\n // has the Universal Resolver, so building a second mainnet client is waste-only.\n // Obs: hand-rolled chainId:1 whose viemChain lacks ensUniversalResolver now → UNSUPPORTED_NETWORK (was L1 path); unreachable for shipped configs (viem `mainnet` defines the UR).\n ...(config.chainId === mainnet.id ? {} : { ensL1Client: ensL1Client(config) }), // SF-5 / D-V1\n ...(enableMainnetL1MissFallback === true ? { enableMainnetL1MissFallback } : {}),\n };\n}\n\nfunction bridgeSignAndBroadcast(\n execution: ReturnType\n): (\n transactionData: unknown,\n executionConfig: ExecutionConfig,\n onStatusChange: (status: TxStatus, details: TransactionStatusUpdate) => void,\n runtimeApiKey?: string\n) => Promise<{ txHash: string; result?: unknown }> {\n return (transactionData, executionConfig, onStatusChange, runtimeApiKey) =>\n execution.signAndBroadcast(\n transactionData,\n executionConfig,\n onStatusChange as (status: string, details: TransactionStatusUpdate) => void,\n runtimeApiKey\n );\n}\n\nexport const capabilityFactories: CapabilityFactoryMap = {\n addressing: (_config?: NetworkConfig) => createAddressing(),\n explorer: (config?: NetworkConfig) =>\n createExplorer(config ? toTypedEvmNetworkConfig(config) : undefined),\n networkCatalog: createNetworkCatalog,\n uiLabels: createUiLabels,\n contractLoading: (config: NetworkConfig) =>\n createContractLoading(toTypedEvmNetworkConfig(config)),\n schema: (config: NetworkConfig) => createSchema(toTypedEvmNetworkConfig(config)),\n typeMapping: (config: NetworkConfig) => createTypeMapping(toTypedEvmNetworkConfig(config)),\n query: (config: NetworkConfig) => createQuery(toTypedEvmNetworkConfig(config)),\n execution: (config: NetworkConfig) => createExecution(toTypedEvmNetworkConfig(config)),\n wallet: (config: NetworkConfig) => createWallet(toTypedEvmNetworkConfig(config)),\n uiKit: (config: NetworkConfig) => createUiKit(toTypedEvmNetworkConfig(config)),\n relayer: (config: NetworkConfig) => createRelayer(toTypedEvmNetworkConfig(config)),\n nameResolution: (config: NetworkConfig) => {\n const typedConfig = toTypedEvmNetworkConfig(config);\n return createNameResolution(typedConfig, buildNameResolutionCreateOptions(typedConfig));\n },\n accessControl: (config: NetworkConfig) => {\n const typedConfig = toTypedEvmNetworkConfig(config);\n const execution = createExecution(typedConfig);\n const ac = createAccessControl(typedConfig, {\n signAndBroadcast: bridgeSignAndBroadcast(execution),\n });\n\n registerRuntimeCapabilityCleanup(ac, () => execution.dispose());\n\n return ac;\n },\n};\n\nfunction createRuntimeCapabilityFactories(\n config: TypedEvmNetworkConfig,\n runtimeOptions?: CreateRuntimeOptions\n): CapabilityFactoryMap {\n return createLazyRuntimeCapabilityFactories(config, {\n addressing: () => createAddressing(),\n explorer: () => createExplorer(config),\n networkCatalog: () => createNetworkCatalog(),\n uiLabels: () => createUiLabels(),\n contractLoading: () => createContractLoading(config),\n schema: () => createSchema(config),\n typeMapping: () => createTypeMapping(config),\n query: (_runtimeConfig, getCapability) =>\n createQuery(config, {\n loadContract: (source) => getCapability('contractLoading').loadContract(source),\n }),\n execution: () => createExecution(config),\n wallet: () => createWallet(config),\n uiKit: () => createUiKit(config),\n relayer: () => createRelayer(config),\n nameResolution: () =>\n createNameResolution(config, buildNameResolutionCreateOptions(config, runtimeOptions)),\n accessControl: (_runtimeConfig, getCapability) =>\n createAccessControl(config, {\n signAndBroadcast: bridgeSignAndBroadcast(\n getCapability('execution') as ReturnType\n ),\n }),\n });\n}\n\nexport function createRuntime(\n profile: ProfileName,\n config: TypedEvmNetworkConfig,\n options?: CreateRuntimeOptions\n): EcosystemRuntime {\n return createCoreRuntime(\n profile,\n config,\n createRuntimeCapabilityFactories(config, options),\n options\n );\n}\n"],"mappings":"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"}