@xyo-network/xl1-protocol-sdk 1.26.11 → 1.26.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/xl1-protocol-sdk",
-  "version": "1.26.11",
+  "version": "1.26.13",
   "description": "XYO Layer One SDK Protocol",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -22,17 +22,14 @@
   "exports": {
     ".": {
       "types": "./dist/neutral/index.d.ts",
-      "source": "./src/index.ts",
       "default": "./dist/neutral/index.mjs"
     },
     "./test": {
       "types": "./dist/neutral/test/index.d.ts",
-      "source": "./src/test/index.ts",
       "default": "./dist/neutral/test/index.mjs"
     },
     "./get": {
       "types": "./dist/neutral/getFileConfig.d.ts",
-      "source": "./src/getFileConfig.ts",
       "default": "./dist/neutral/getFileConfig.mjs"
     },
     "./package.json": "./package.json"
@@ -42,35 +39,50 @@
   "types": "./dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
-    "!**/*.test.*"
+    "!**/*.test.*",
+    "README.md"
   ],
   "dependencies": {
-    "@xyo-network/xl1-protocol-lib": "~1.26.11",
-    "@xyo-network/xl1-schema": "~1.26.11",
+    "@xyo-network/xl1-protocol-lib": "~1.26.13",
+    "@xyo-network/xl1-schema": "~1.26.13",
     "async-mutex": "~0.5.0",
     "cosmiconfig": "^9.0.1",
     "lru-cache": "^11.2.7"
   },
   "devDependencies": {
+    "@firebase/app": "0.x",
+    "@firebase/app-compat": "0.x",
+    "@firebase/app-types": "0.x",
+    "@firebase/util": "1.x",
+    "@metamask/providers": "^22",
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/sdk-js": "^5.0.90",
-    "@xylabs/ts-scripts-common": "~7.5.6",
-    "@xylabs/ts-scripts-yarn3": "~7.5.6",
-    "@xylabs/tsconfig": "~7.5.6",
-    "@xylabs/vitest-extended": "~5.0.90",
-    "@xyo-network/sdk-js": "^5.3.17",
-    "@xyo-network/xl1-network-model": "~1.26.11",
-    "axios": "^1.13.6",
+    "@xylabs/geo": "^5",
+    "@xylabs/sdk-js": "^5.0.91",
+    "@xylabs/ts-scripts-common": "~7.6.13",
+    "@xylabs/ts-scripts-yarn3": "~7.6.13",
+    "@xylabs/tsconfig": "~7.6.13",
+    "@xylabs/vitest-extended": "~5.0.91",
+    "@xyo-network/sdk-js": "^5.3.22",
+    "@xyo-network/xl1-network-model": "~1.26.13",
+    "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0",
+    "ajv": "^8",
+    "axios": "^1.14.0",
+    "esbuild": ">=0.18",
+    "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0",
     "ethers": "^6.16.0",
+    "firebase": "^12",
     "ky": "^1.14.3",
+    "mapbox-gl": "^3",
     "mongodb": "~7.1.1",
+    "rollup": "^3.29.4 || ^4",
     "tslib": "^2.8.1",
     "typescript": "~5.9.3",
+    "vite": "^8.0.3",
     "vitest": "~4.1.2",
+    "webextension-polyfill": "^0.10.0 || ^0.11.0 || ^0.12.0",
     "zod": "~4.3.6"
   },
   "peerDependencies": {
@@ -80,6 +92,7 @@
     "axios": "^1",
     "ethers": "^6",
     "mongodb": "^6 || ^7",
+    "typescript": ">=4.9.5",
     "zod": "^4"
   },
   "engines": {

package/src/ChainContextHelpers.ts

@@ -1,50 +0,0 @@
-import {
-  isDefined, isObject, isUndefined,
-  timeBudget,
-} from '@xylabs/sdk-js'
-import type { CachingContext, MapType } from '@xyo-network/xl1-protocol-lib'
-
-import { LruCacheMap, MemoryMap } from './driver/index.ts'
-
-/** Retrieves or creates a named cache from the caching context */
-export function contextCache<TCacheValue>(
-  context: CachingContext,
-  name: string,
-  create?: () => MapType<string, TCacheValue>,
-): MapType<string, TCacheValue> {
-  if (!isObject(context.caches)) {
-    throw new Error('Context does not have an appropriate caches property')
-  }
-  if (isUndefined(context.caches[name])) {
-    context.caches[name] = create?.() ?? new MemoryMap<string, TCacheValue>()
-  }
-  return context.caches[name] as MapType<string, TCacheValue>
-}
-
-/** Options for the withContextCacheResponse helper */
-export interface withContextCacheResponseOptions {
-  max?: number
-}
-
-/** Executes a function with LRU caching, returning the cached result if available */
-export async function withContextCacheResponse<T extends {} | string | number | bigint>(
-  context: CachingContext,
-  name: string,
-  key: string,
-  func: () => Promise<T extends {} | string | number | bigint ? T : never>,
-  { max = 10_000 }: withContextCacheResponseOptions = {},
-): Promise<T> {
-  const cache = contextCache<Promise<T>>(
-    context,
-    name,
-    () => new LruCacheMap<string, Promise<T>>({ max }),
-  )
-  const { timeBudgetLimit = 0 } = context
-  const cacheResult = await cache.get(key)
-  if (isDefined(cacheResult)) {
-    return cacheResult
-  }
-  const result = timeBudgetLimit > 0 ? timeBudget(name, context.logger, func, timeBudgetLimit) : func()
-  await cache.set(key, result)
-  return result
-}

package/src/CreatableProvider/AbstractCreatableProvider.ts

@@ -1,97 +0,0 @@
-import type { Logger } from '@xylabs/sdk-js'
-import {
-  AbstractCreatable, assertEx, IdLogger,
-} from '@xylabs/sdk-js'
-import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type {
-  CreatableProvider,
-  CreatableProviderEventData, CreatableProviderInstance, CreatableProviderParams,
-  ProviderMap,
-} from './CreatableProvider.ts'
-import { ProviderFactory } from './ProviderFactory.ts'
-
-/** Abstract base class for CreatableProvider implementations. */
-export abstract class AbstractCreatableProvider<TParams extends CreatableProviderParams = CreatableProviderParams,
-  TEventData extends CreatableProviderEventData = CreatableProviderEventData> extends AbstractCreatable<TParams, TEventData>
-  implements Omit<CreatableProviderInstance, 'moniker'> {
-  dependencies: ProviderMap = {}
-
-  protected _contextCache: TParams['context'] | undefined
-  protected _logger: Logger | undefined | null
-
-  abstract readonly moniker: ProviderMoniker
-
-  override get logger() {
-    // we use null as a way to know if it has been initialized to nothing
-    if (this._logger === undefined) {
-      const providedLogger = this.params.logger ?? this.context.logger
-      this._logger = providedLogger ? new IdLogger(providedLogger, () => `${this.moniker} [${this.constructor.name}]`) : null
-    }
-    return this._logger ?? undefined
-  }
-
-  override get meter() {
-    return this.context.meterProvider?.getMeter(this.name) ?? super.meter
-  }
-
-  override get tracer() {
-    return this.context.traceProvider?.getTracer(this.name) ?? super.tracer
-  }
-
-  protected get config() {
-    return this.context.config!
-  }
-
-  protected get context() {
-    return this.params.context!
-  }
-
-  protected get locator() {
-    return this.context.locator!
-  }
-
-  static factory<TInstance extends CreatableProviderInstance, TDependencies extends ProviderMoniker[] = ProviderMoniker[]>(
-    this: CreatableProvider<TInstance>,
-    dependencies: TDependencies,
-    params: Omit<TInstance['params'], 'context'>,
-  ) {
-    const factory = ProviderFactory.withParams<TInstance, TDependencies>(this, dependencies, params)
-    return factory
-  }
-
-  static override async paramsHandler<T extends CreatableProviderInstance>(
-    params: Partial<T['params']> = {},
-  ) {
-    const context = assertEx(params.context, () => new Error('Context is required'))
-    const config = assertEx(context.config, () => new Error('Context config is required'))
-    const locator = assertEx(context.locator, () => new Error('Context locator is required'))
-    return await super.paramsHandler<T>({
-      ...params,
-      statusReporter: params.statusReporter ?? context.statusReporter,
-      context: {
-        ...context, config, locator,
-      },
-      name: params.name ?? (this as unknown as CreatableProvider<T>).defaultMoniker,
-      logger: params.logger ?? context.logger,
-    })
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    if (this.tracer === undefined) {
-      this.logger?.warn('No tracer available in context')
-    }
-    if (this.meter === undefined) {
-      this.logger?.warn('No meter available in context')
-    }
-  }
-
-  async locateAndCreate<TProvider extends Provider<ProviderMoniker>>(moniker: TProvider['moniker']) {
-    return await this.locator.getInstance<TProvider>(moniker)
-  }
-
-  async tryLocateAndCreate<TProvider extends Provider<ProviderMoniker>>(moniker: TProvider['moniker']) {
-    return await this.locator.tryGetInstance<TProvider>(moniker)
-  }
-}

package/src/CreatableProvider/CreatableProvider.ts

@@ -1,102 +0,0 @@
-import type {
-  Creatable, CreatableInstance, CreatableParams,
-  EventData,
-  Labels, WithOptionalLabels,
-} from '@xylabs/sdk-js'
-import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderContext } from '../model/index.ts'
-import type { GetInstanceOptions } from './GetInstanceOptions.ts'
-import type { LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
-
-/** Parameters for CreatableProvider. */
-export interface CreatableProviderParams<TContext extends CreatableProviderContext = CreatableProviderContext> extends CreatableParams {
-  context: TContext
-}
-/** CreatableProviderEventData interface. */
-export interface CreatableProviderEventData extends EventData {}
-
-/** CreatableProviderInstance type. */
-export type CreatableProviderInstance<
-  TProvider extends Provider<ProviderMoniker> = Provider<ProviderMoniker>,
-  TDependencies extends ProviderMoniker[] = ProviderMoniker[],
-  TParams extends CreatableProviderParams = CreatableProviderParams,
-  TEventData extends CreatableProviderEventData = CreatableProviderEventData>
-  = CreatableInstance<TParams, TEventData> & TProvider & {
-    dependencies: ProviderMap<TDependencies[number]>
-  }
-
-/** ProviderFactoryScope type. */
-export type ProviderFactoryScope = 'global' | 'context' | 'local'
-
-/** CreatableProviderFactory interface. */
-export interface CreatableProviderFactory<T extends CreatableProviderInstance = CreatableProviderInstance,
-  TDependencies extends ProviderMoniker[] = ProviderMoniker[]>
-  extends Omit<CreatableProvider<T>, 'create' | 'createHandler' | 'paramsHandler'> {
-  creatableProvider: CreatableProvider<T>
-  defaultParams: Omit<T['params'], 'context'>
-
-  readonly dependencies: TDependencies
-
-  labels?: Labels
-  providerName: string
-  resolvedMoniker: string
-  scope: ProviderFactoryScope
-
-  uniqueId: symbol
-
-  getInstance(
-    this: CreatableProviderFactory<T>,
-    params: T['params'],
-    options?: GetInstanceOptions): Promise<T>
-
-  tryGetInstance(
-    this: CreatableProviderFactory<T>,
-    params: T['params'],
-    options?: GetInstanceOptions): Promise<T | undefined>
-
-}
-
-/** LabeledCreatableProvider interface. */
-export interface LabeledCreatableProvider<T extends CreatableProviderInstance = CreatableProviderInstance,
-  TDependencies extends ProviderMoniker[] = ProviderMoniker[]> extends CreatableProvider<T>, WithOptionalLabels {
-  factory(dependencies: TDependencies, params: Omit<T['params'], 'context'>): LabeledCreatableProviderFactory<T>
-}
-
-/** ProviderMap type. */
-export type ProviderMap<T extends ProviderMoniker = ProviderMoniker> = Partial<Record<T, CreatableProviderInstance<Provider<T>>>>
-
-/** CreatableProvider interface. */
-export interface CreatableProvider<T extends CreatableProviderInstance = CreatableProviderInstance,
-  TDependencies extends ProviderMoniker[] = ProviderMoniker[]> extends Creatable<T> {
-  readonly defaultMoniker: ProviderMoniker
-  readonly dependencies: TDependencies
-  readonly monikers: ProviderMoniker[]
-  factory(dependencies: TDependencies, params: Omit<T['params'], 'context'>): CreatableProviderFactory<T>
-}
-
-/**
- * Class annotation to be used to decorate Providers which support
- * an asynchronous creation pattern
- * @returns The decorated Provider requiring it implement the members
- * of the CreatableProvider as statics properties/methods
- */
-export function creatableProvider<TProvider extends CreatableProviderInstance = CreatableProviderInstance>() {
-  return <U extends CreatableProvider<TProvider>>(constructor: U) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    constructor
-  }
-}
-
-/**
- * Class annotation to be used to decorate Providers which support
- * an asynchronous creation pattern
- * @returns The decorated Provider requiring it implement the members
- * of the CreatableProvider as statics properties/methods
- */
-export function labeledCreatableProvider<TProvider extends CreatableProviderInstance = CreatableProviderInstance>() {
-  return <U extends LabeledCreatableProvider<TProvider>>(constructor: U) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    constructor
-  }
-}

package/src/CreatableProvider/CreatableProviderRegistry.ts

@@ -1,94 +0,0 @@
-import type { Labels } from '@xylabs/sdk-js'
-import { isTruthy } from '@xylabs/sdk-js'
-import type { ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
-import type { LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
-import { providerFactoryDescription } from './ProviderFactory.ts'
-
-/** CreatableProviderRegistry type. */
-export type CreatableProviderRegistry<TMonikers extends ProviderMoniker[] = ProviderMoniker[]>
-  = Record<TMonikers[number], (CreatableProviderFactory | LabeledCreatableProviderFactory)[] | undefined>
-
-const buildProviderFactory = <TProvider extends CreatableProviderInstance>(
-  provider: CreatableProviderFactory<TProvider>,
-  defaultParams: Omit<TProvider['params'], 'context'>,
-  labels?: Labels,
-): LabeledCreatableProviderFactory<TProvider> => {
-  const factory = {
-    monikers: provider.monikers,
-    uniqueId: Symbol(providerFactoryDescription(provider, labels)),
-    // Merge module & supplied labels
-    labels: { ...(provider as LabeledCreatableProviderFactory).labels, ...labels },
-    creatableProvider: provider.creatableProvider,
-    dependencies: provider.dependencies,
-    resolvedMoniker: provider.resolvedMoniker,
-    providerName: provider.providerName,
-    scope: provider.scope,
-    defaultParams,
-    getInstance: provider.getInstance.bind(provider) as LabeledCreatableProviderFactory<TProvider>['getInstance'],
-    tryGetInstance: provider.tryGetInstance?.bind(provider) as LabeledCreatableProviderFactory<TProvider>['tryGetInstance'],
-    defaultMoniker: provider.defaultMoniker,
-    factory: provider.factory.bind(provider) as LabeledCreatableProviderFactory<TProvider>['factory'],
-  } satisfies LabeledCreatableProviderFactory<TProvider>
-  return factory
-}
-
-/** registerCreatableProviderFactory constant. */
-export const registerCreatableProviderFactory = <TProvider extends CreatableProviderInstance>(
-  registry: CreatableProviderRegistry,
-  factory: CreatableProviderFactory<TProvider> | LabeledCreatableProviderFactory<TProvider>,
-  labels?: Labels,
-  /** register this as the primary factory for every schema it supports */
-  primary: boolean | ProviderMoniker | ProviderMoniker[] = false,
-) => {
-  const primaryMonikers
-    = primary !== true && isTruthy(primary)
-      ? Array.isArray(primary)
-        ? primary
-        : [primary]
-      : []
-
-  for (const primaryMoniker of primaryMonikers) {
-    if (!factory.monikers.includes(primaryMoniker)) {
-      console.warn(`Primary moniker ${primary} not found in factory monikers`)
-    }
-  }
-
-  const isPrimaryForMoniker = (moniker: ProviderMoniker) => {
-    switch (typeof primary) {
-      case 'boolean': {
-        return primary
-      }
-      case 'string': {
-        return moniker === primary
-      }
-      case 'object': {
-        if (Array.isArray(primary)) {
-          return primary.includes(moniker)
-        }
-      }
-    }
-    throw new Error(`Invalid primary value: ${primary}`)
-  }
-
-  const factoryClone: LabeledCreatableProviderFactory<TProvider> = buildProviderFactory(factory, factory.defaultParams, labels)
-
-  // add this default moniker as the first entry
-  registry[factoryClone.defaultMoniker] = [factoryClone, ...(registry[factoryClone.defaultMoniker] ?? [])]
-  for (const moniker of factoryClone.monikers) {
-    registry[moniker] = isPrimaryForMoniker(moniker) ? [factoryClone, ...(registry[moniker] ?? [])] : [...(registry[moniker] ?? []), factoryClone]
-  }
-}
-
-/** registerCreatableProviderFactories constant. */
-export const registerCreatableProviderFactories = (
-  factories: (CreatableProviderFactory | LabeledCreatableProviderFactory)[],
-  registry: CreatableProviderRegistry = {},
-  primary = false,
-) => {
-  for (const factory of factories) {
-    registerCreatableProviderFactory(registry, factory, undefined, primary)
-  }
-  return registry
-}

package/src/CreatableProvider/GetInstanceOptions.ts

@@ -1,11 +0,0 @@
-import type { Labels } from '@xylabs/sdk-js'
-
-/** Options for GetInstance. */
-export interface GetInstanceOptions {
-  start?: boolean
-}
-
-/** Options for ProviderFactoryGetInstance. */
-export interface ProviderFactoryGetInstanceOptions extends GetInstanceOptions {
-  labels?: Labels
-}

package/src/CreatableProvider/LabeledCreatableProviderFactory.ts

@@ -1,24 +0,0 @@
-import type { WithOptionalLabels } from '@xylabs/sdk-js'
-
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
-
-/** LabeledCreatableProviderFactory type. */
-export type LabeledCreatableProviderFactory<T extends CreatableProviderInstance = CreatableProviderInstance> = CreatableProviderFactory<T> & WithOptionalLabels
-
-/** hasLabels constant. */
-export const hasLabels = (factory: CreatableProviderFactory | LabeledCreatableProviderFactory): factory is LabeledCreatableProviderFactory => {
-  return (factory as LabeledCreatableProviderFactory).labels !== undefined
-}
-
-/**
- * Class annotation to be used to decorate Providers which support
- * an asynchronous labeled creation factory pattern
- * @returns The decorated Provider requiring it implement the members
- * of the CreatableProvider as statics properties/methods
- */
-export function labeledCreatableProviderFactory<TProvider extends CreatableProviderInstance = CreatableProviderInstance>() {
-  return <U extends LabeledCreatableProviderFactory<TProvider>>(constructor: U) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    constructor
-  }
-}

package/src/CreatableProvider/ProviderFactory.ts

@@ -1,138 +0,0 @@
-import type { Labels, WithOptionalLabels } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type {
-  CreatableProvider, CreatableProviderFactory, CreatableProviderInstance,
-  ProviderFactoryScope,
-} from './CreatableProvider.ts'
-import type { GetInstanceOptions } from './GetInstanceOptions.ts'
-
-declare global {
-  var xyoServiceSingletons: Record<string, unknown>
-}
-
-/** ProviderFactoryDescription helper function. */
-export function providerFactoryDescription(factory: CreatableProviderFactory, labels?: Labels) {
-  return `${factory.providerName}:${factory.defaultMoniker}:${JSON.stringify(labels ?? (factory as WithOptionalLabels).labels ?? {})}`
-}
-
-/** ProviderFactory implementation. */
-export class ProviderFactory<TProvider extends CreatableProviderInstance,
-  TDependencies extends ProviderMoniker[]> implements CreatableProviderFactory<TProvider> {
-  creatableProvider: CreatableProvider<TProvider>
-
-  defaultMoniker: CreatableProvider<TProvider>['monikers'][number]
-
-  defaultParams: Omit<TProvider['params'], 'context'>
-
-  dependencies: TDependencies
-
-  labels?: Labels
-
-  monikers: CreatableProvider<TProvider>['monikers']
-
-  providerName: string
-
-  scope: ProviderFactoryScope
-
-  private _uniqueId: symbol
-
-  constructor(
-    creatableProvider: CreatableProvider<TProvider>,
-    dependencies: TDependencies,
-    params: Omit<TProvider['params'], 'context'>,
-    labels: Labels = {},
-    scope: ProviderFactoryScope = 'context',
-  ) {
-    this.creatableProvider = creatableProvider
-    this.defaultParams = params
-    this.defaultMoniker = creatableProvider.defaultMoniker
-    this.dependencies = dependencies
-    this.monikers = creatableProvider.monikers
-    this.scope = scope
-    assertEx(this.monikers.includes(this.defaultMoniker), () => 'defaultMoniker must be in monikers')
-    this.labels = Object.assign({}, (creatableProvider as WithOptionalLabels).labels ?? {}, labels ?? {})
-    this.providerName = creatableProvider.name
-    this._uniqueId = Symbol(providerFactoryDescription(this))
-  }
-
-  get resolvedMoniker() {
-    const labels: Labels = this.labels ?? {}
-    const labelString = Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(',')
-    return labelString.length === 0 ? `${this.defaultMoniker}` : `${this.defaultMoniker}|${labelString}`
-  }
-
-  get uniqueId(): symbol {
-    return this._uniqueId
-  }
-
-  static withParams<TInstance extends CreatableProviderInstance, TDependencies extends ProviderMoniker[]>(
-    creatableProvider: CreatableProvider<TInstance>,
-    dependencies: TDependencies,
-    params: Omit<TInstance['params'], 'context'>,
-    labels: Labels = {},
-  ) {
-    return new ProviderFactory<TInstance, TDependencies>(creatableProvider, dependencies, params, labels)
-  }
-
-  factory<TInstance extends CreatableProviderInstance, TDependencies extends ProviderMoniker[]>(
-    this: CreatableProviderFactory<TInstance, TDependencies>,
-    dependencies: TDependencies,
-    params: Omit<TInstance['params'], 'context'>,
-    labels: Labels = {},
-  ) {
-    return new ProviderFactory<TInstance, TDependencies>(this.creatableProvider, dependencies, params, labels)
-  }
-
-  async getInstance(this: CreatableProviderFactory<TProvider>, params: TProvider['params'], { start = true }: GetInstanceOptions): Promise<TProvider> {
-    let scopeObject: Record<string, unknown> = {}
-    switch (this.scope) {
-      case 'global': {
-        if (globalThis.xyoServiceSingletons === undefined) {
-          globalThis.xyoServiceSingletons = {}
-        }
-        scopeObject = globalThis.xyoServiceSingletons
-        break
-      }
-      case 'context': {
-        const context = assertEx(
-          params?.context,
-          () => 'Context is required for context-scoped providers',
-        )
-        if (context.singletons === undefined) {
-          context.singletons = {}
-        }
-        scopeObject = context.singletons
-        break
-      }
-      default: {
-        scopeObject = {}
-        break
-      }
-    }
-    const mergedParams: TProvider['params'] = {
-      ...this.defaultParams,
-      ...params,
-    } as TProvider['params']
-    const resultPromise = scopeObject[this.resolvedMoniker] as Promise<TProvider> ?? this.creatableProvider.create<TProvider>(mergedParams)
-    scopeObject[this.resolvedMoniker] = resultPromise
-    const result = await resultPromise
-    if (start) {
-      assertEx(await result.start(), () => `Failed to start provider instance [${this.resolvedMoniker}]`)
-    }
-    return result
-  }
-
-  async tryGetInstance(
-    this: CreatableProviderFactory<TProvider>,
-    params: TProvider['params'],
-    options?: GetInstanceOptions,
-  ): Promise<TProvider | undefined> {
-    try {
-      return await this.getInstance(params, options)
-    } catch {
-      return
-    }
-  }
-}