@xyo-network/module-abstract 2.51.10

package/src/ModuleWrapper.ts

@@ -0,0 +1,330 @@
+import { assertEx } from '@xylabs/assert'
+import { Account } from '@xyo-network/account'
+import { AccountInstance } from '@xyo-network/account-model'
+import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
+import { BoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
+import { BaseParams } from '@xyo-network/core'
+import { EventAnyListener, EventListener } from '@xyo-network/module-events'
+import {
+  Module,
+  ModuleDescription,
+  ModuleDiscoverQuery,
+  ModuleDiscoverQuerySchema,
+  ModuleFilter,
+  ModuleQueryResult,
+  XyoQuery,
+  XyoQueryBoundWitness,
+} from '@xyo-network/module-model'
+import { XyoPayload, XyoPayloads } from '@xyo-network/payload-model'
+import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+import { Promisable, PromiseEx } from '@xyo-network/promise'
+import compact from 'lodash/compact'
+
+import { BaseEmitter } from './BaseEmitter'
+import { XyoError, XyoErrorSchema } from './Error'
+import { duplicateModules } from './lib'
+import { QueryBoundWitnessBuilder, QueryBoundWitnessWrapper } from './Query'
+
+export interface WrapperError extends Error {
+  errors: (XyoError | null)[]
+  query: [XyoQueryBoundWitness, XyoPayloads]
+  result: ModuleQueryResult | undefined
+}
+
+export type ModuleConstructable<TModule extends Module = Module, TWrapper extends ModuleWrapper<TModule> = ModuleWrapper<TModule>> = {
+  new (params: ModuleWrapperParams): TWrapper
+}
+
+export function moduleConstructable<TModule extends Module = Module, TWrapper extends ModuleWrapper<TModule> = ModuleWrapper<TModule>>() {
+  return <U extends ModuleConstructable<TModule, TWrapper>>(constructor: U) => {
+    constructor
+  }
+}
+
+export type ModuleWrapperParams<TWrappedModule extends Module = Module> = BaseParams<{
+  account?: AccountInstance
+  module: TWrappedModule
+}>
+
+@moduleConstructable()
+export class ModuleWrapper<TWrappedModule extends Module = Module>
+  extends BaseEmitter<TWrappedModule['params']>
+  implements Module<TWrappedModule['params']>
+{
+  static requiredQueries: string[] = [ModuleDiscoverQuerySchema]
+
+  protected readonly wrapperParams: ModuleWrapperParams<TWrappedModule>
+
+  constructor(params: ModuleWrapperParams<TWrappedModule>) {
+    const mutatedParams = { ...params } as ModuleWrapperParams<TWrappedModule>
+    //unwrap it if already wrapped
+    const wrapper = params.module as unknown as ModuleWrapper<TWrappedModule>
+    if (wrapper.module) {
+      mutatedParams.module = wrapper.module
+    }
+
+    //set the root params to the wrapped module params
+    super(params.module.params)
+    this.wrapperParams = params
+  }
+
+  get account() {
+    return this.wrapperParams.account
+  }
+
+  get address() {
+    return this.module.address
+  }
+
+  get config(): TWrappedModule['config'] {
+    return this.module.config
+  }
+
+  get downResolver() {
+    return this.module.downResolver
+  }
+
+  get module() {
+    return this.wrapperParams.module
+  }
+
+  get queries(): string[] {
+    return this.module.queries
+  }
+
+  get upResolver() {
+    return this.module.upResolver
+  }
+
+  static canWrap(module?: Module) {
+    return !!module && this.missingRequiredQueries(module).length === 0
+  }
+
+  static hasRequiredQueries(module: Module) {
+    return this.missingRequiredQueries(module).length === 0
+  }
+
+  static missingRequiredQueries(module: Module): string[] {
+    const moduleQueries = module.queries
+    return compact(
+      this.requiredQueries.map((query) => {
+        return moduleQueries.find((item) => item === query) ? null : query
+      }),
+    )
+  }
+
+  static tryWrap(module?: Module, account?: AccountInstance): ModuleWrapper | undefined {
+    if (this.canWrap(module)) {
+      if (!account) {
+        this.defaultLogger?.info('Anonymous Module Wrapper Created')
+      }
+      return new ModuleWrapper({ account, module: module as Module })
+    }
+  }
+
+  static wrap(module?: Module, account?: AccountInstance): ModuleWrapper {
+    return assertEx(this.tryWrap(module, account), 'Unable to wrap module as ModuleWrapper')
+  }
+
+  override clearListeners(eventNames: keyof TWrappedModule['params']['eventData'] | keyof TWrappedModule['params']['eventData'][]) {
+    return this.module.clearListeners(eventNames)
+  }
+
+  async describe(): Promise<Promise<Promisable<ModuleDescription>>> {
+    const description: ModuleDescription = {
+      address: this.module.address,
+      queries: this.module.queries,
+    }
+    if (this.config.name) {
+      description.name = this.config.name
+    }
+
+    const discover = await this.discover()
+
+    description.children = compact(
+      discover?.map((payload) => {
+        const address = payload.schema === AddressSchema ? (payload as AddressPayload).address : undefined
+        return address != this.module.address ? address : undefined
+      }) ?? [],
+    )
+
+    return description
+  }
+
+  discover(): Promise<XyoPayload[]> {
+    const queryPayload = PayloadWrapper.parse<ModuleDiscoverQuery>({ schema: ModuleDiscoverQuerySchema })
+    return this.sendQuery(queryPayload)
+  }
+
+  override emit(
+    eventName: keyof TWrappedModule['params']['eventData'],
+    eventArgs?: TWrappedModule['params']['eventData'][keyof TWrappedModule['params']['eventData']],
+  ) {
+    return this.module.emit(eventName, eventArgs)
+  }
+
+  override emitSerial(
+    eventName: keyof TWrappedModule['params']['eventData'],
+    eventArgs?: TWrappedModule['params']['eventData'][keyof TWrappedModule['params']['eventData']],
+  ) {
+    return this.module.emitSerial(eventName, eventArgs)
+  }
+
+  override listenerCount(eventNames: keyof TWrappedModule['params']['eventData'] | keyof TWrappedModule['params']['eventData'][]) {
+    return this.module.listenerCount(eventNames)
+  }
+
+  override off(
+    eventNames: keyof TWrappedModule['params']['eventData'] | keyof TWrappedModule['params']['eventData'][],
+    listener: EventListener<TWrappedModule['params']['eventData']>,
+  ) {
+    return this.module.off(eventNames, listener)
+  }
+
+  override offAny(listener: EventAnyListener<TWrappedModule['params']['eventData']>) {
+    return this.module.offAny(listener)
+  }
+
+  override on(
+    eventNames: keyof TWrappedModule['params']['eventData'] | keyof TWrappedModule['params']['eventData'][],
+    listener: EventListener<TWrappedModule['params']['eventData']>,
+  ) {
+    return this.module.on(eventNames, listener)
+  }
+
+  override onAny(listener: EventAnyListener<TWrappedModule['params']['eventData']>) {
+    return this.module.onAny(listener)
+  }
+
+  override once(
+    eventNames: keyof TWrappedModule['params']['eventData'] | keyof TWrappedModule['params']['eventData'][],
+    listener: EventListener<TWrappedModule['params']['eventData']>,
+  ) {
+    return this.module.once(eventNames, listener)
+  }
+
+  async query<T extends XyoQueryBoundWitness = XyoQueryBoundWitness>(query: T, payloads?: XyoPayload[]): Promise<ModuleQueryResult> {
+    return await this.module.query(query, payloads)
+  }
+
+  queryable<T extends XyoQueryBoundWitness = XyoQueryBoundWitness>(query: T, payloads?: XyoPayload[]) {
+    return this.module.queryable(query, payloads)
+  }
+
+  async resolve<TModule extends Module = Module>(filter?: ModuleFilter): Promise<TModule[]>
+  async resolve<TModule extends Module = Module>(nameOrAddress: string): Promise<TModule | undefined>
+  async resolve<TModule extends Module = Module>(nameOrAddressOrFilter?: ModuleFilter | string): Promise<TModule | TModule[] | undefined> {
+    switch (typeof nameOrAddressOrFilter) {
+      case 'string': {
+        const byAddress = Account.isAddress(nameOrAddressOrFilter)
+          ? (await this.resolve<TModule>({ address: [nameOrAddressOrFilter] })).pop()
+          : undefined
+        return byAddress ?? (await this.resolve<TModule>({ name: [nameOrAddressOrFilter] })).pop()
+      }
+      default: {
+        const filter: ModuleFilter | undefined = nameOrAddressOrFilter
+        return [...(await this.module.downResolver.resolve<TModule>(filter)), ...(await this.module.upResolver.resolve<TModule>(filter))].filter(
+          duplicateModules,
+        )
+      }
+    }
+  }
+
+  /**
+   * Resolves the supplied filter into wrapped modules
+   * @example <caption>Example using ArchivistWrapper</caption>
+   * const filter = { address: [address] }
+   * const mods: ArchivistWrapper[] = await node.resolveWrapped(ArchivistWrapper, filter)
+   * @param wrapper The ModuleWrapper class (ArchivistWrapper,
+   * DivinerWrapper, etc.)
+   * @param filter The ModuleFilter
+   * @returns An array of ModuleWrapper instances corresponding to
+   * the underlying modules matching the supplied filter
+   */
+  async resolveWrapped<T extends ModuleWrapper<Module> = ModuleWrapper<Module>>(
+    wrapper: ModuleConstructable<Module, T>,
+    filter?: ModuleFilter,
+  ): Promise<T[]>
+  async resolveWrapped<T extends ModuleWrapper<Module> = ModuleWrapper<Module>>(
+    wrapper: ModuleConstructable<Module, T>,
+    nameOrAddress: string,
+  ): Promise<T | undefined>
+  async resolveWrapped<T extends ModuleWrapper<Module> = ModuleWrapper<Module>>(
+    wrapper: ModuleConstructable<Module, T>,
+    nameOrAddressOrFilter?: ModuleFilter | string,
+  ): Promise<T[] | T | undefined> {
+    switch (typeof nameOrAddressOrFilter) {
+      case 'string': {
+        const nameOrAddress: string = nameOrAddressOrFilter
+        const mod = await this.resolve<T['module']>(nameOrAddress)
+        return mod ? new wrapper({ account: this.account, module: mod }) : undefined
+      }
+      default: {
+        const filter: ModuleFilter | undefined = nameOrAddressOrFilter
+        return (await this.resolve<T['module']>(filter)).map((mod) => new wrapper({ account: this.account, module: mod }))
+      }
+    }
+  }
+
+  protected bindQuery<T extends XyoQuery | PayloadWrapper<XyoQuery>>(
+    query: T,
+    payloads?: XyoPayload[],
+    account: AccountInstance | undefined = this.account,
+  ): PromiseEx<[XyoQueryBoundWitness, XyoPayload[]], AccountInstance> {
+    const promise = new PromiseEx<[XyoQueryBoundWitness, XyoPayload[]], AccountInstance>((resolve) => {
+      const result = this.bindQueryInternal(query, payloads, account)
+      resolve?.(result)
+      return result
+    }, account)
+    return promise
+  }
+
+  protected bindQueryInternal<T extends XyoQuery | PayloadWrapper<XyoQuery>>(
+    query: T,
+    payloads?: XyoPayload[],
+    account: AccountInstance | undefined = this.account,
+  ): [XyoQueryBoundWitness, XyoPayload[]] {
+    const builder = new QueryBoundWitnessBuilder().payloads(payloads).query(query)
+    const result = (account ? builder.witness(account) : builder).build()
+    return result
+  }
+
+  protected filterErrors(query: [XyoQueryBoundWitness, XyoPayloads], result: ModuleQueryResult | undefined): (XyoError | null)[] {
+    return (result?.[1]?.filter((payload) => {
+      if (payload?.schema === XyoErrorSchema) {
+        const wrapper = new QueryBoundWitnessWrapper(query[0])
+        return payload.sources?.includes(wrapper.hash)
+      }
+      return false
+    }) ?? []) as XyoError[]
+  }
+
+  protected async sendQuery<T extends XyoQuery | PayloadWrapper<XyoQuery>>(queryPayload: T, payloads?: XyoPayloads): Promise<XyoPayload[]> {
+    //make sure we did not get wrapped payloads
+    const unwrappedPayloads = payloads?.map((payload) => assertEx(PayloadWrapper.unwrap(payload), 'Unable to parse payload'))
+    const unwrappedQueryPayload = assertEx(BoundWitnessWrapper.unwrap<XyoQueryBoundWitness>(queryPayload), 'Unable to parse queryPayload')
+
+    // Bind them
+    const query = await this.bindQuery(unwrappedQueryPayload, unwrappedPayloads)
+
+    // Send them off
+    const result = await this.module.query(query[0], query[1])
+
+    this.throwErrors(query, result)
+    return result[1]
+  }
+
+  protected throwErrors(query: [XyoQueryBoundWitness, XyoPayloads], result: ModuleQueryResult | undefined) {
+    const errors = this.filterErrors(query, result)
+    if (errors?.length > 0) {
+      const error: WrapperError = {
+        errors,
+        message: errors.reduce((message, error) => `${message}${message.length > 0 ? '|' : ''}${error?.message}`, ''),
+        name: 'XyoError',
+        query,
+        result,
+      }
+      throw error
+    }
+  }
+}

package/src/Query/QueryBoundWitnessBuilder.ts

@@ -0,0 +1,29 @@
+import { assertEx } from '@xylabs/assert'
+import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
+import { XyoQuery, XyoQueryBoundWitness, XyoQueryBoundWitnessSchema } from '@xyo-network/module-model'
+import { PayloadSetPayload } from '@xyo-network/payload-model'
+import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+
+export class QueryBoundWitnessBuilder<
+  TBoundWitness extends XyoQueryBoundWitness = XyoQueryBoundWitness,
+  TQuery extends XyoQuery = XyoQuery,
+> extends BoundWitnessBuilder<TBoundWitness> {
+  private _query: PayloadWrapper<TQuery> | undefined
+  private _resultSet: PayloadWrapper<PayloadSetPayload> | undefined
+
+  override hashableFields(): TBoundWitness {
+    return { ...super.hashableFields(), query: assertEx(this._query?.hash, 'No Query Specified'), schema: XyoQueryBoundWitnessSchema }
+  }
+
+  query<T extends TQuery | PayloadWrapper<TQuery>>(query: T) {
+    this._query = PayloadWrapper.parse(query)
+    this.payload(this._query.payload)
+    return this
+  }
+
+  resultSet<T extends PayloadSetPayload | PayloadWrapper<PayloadSetPayload>>(payloadSet: T) {
+    this._resultSet = PayloadWrapper.parse(payloadSet)
+    this.payload(this._resultSet.payload)
+    return this
+  }
+}

package/src/Query/QueryBoundWitnessValidator.ts

@@ -0,0 +1,41 @@
+import { BoundWitnessValidator } from '@xyo-network/boundwitness-validator'
+import { XyoQuery, XyoQueryBoundWitness, XyoQueryBoundWitnessSchema } from '@xyo-network/module-model'
+import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+
+import { QueryBoundWitnessWrapper } from './QueryBoundWitnessWrapper'
+
+export class QueryBoundWitnessValidator<T extends XyoQuery = XyoQuery> extends BoundWitnessValidator<XyoQueryBoundWitness> {
+  private _query: PayloadWrapper<T> | undefined
+
+  protected override get expectedSchema(): string {
+    return XyoQueryBoundWitnessSchema
+  }
+
+  static isQueryBoundWitnessValidator(obj: unknown) {
+    return (obj as QueryBoundWitnessValidator)?.constructor === QueryBoundWitnessValidator
+  }
+
+  override validate() {
+    return [
+      ...super.validate(),
+      // ...this.validateResultSet()
+    ]
+  }
+
+  validateResultSet() {
+    const errors: Error[] = []
+    const wrapper = new QueryBoundWitnessWrapper(this.obj)
+    const required = wrapper.resultSet.payload.required
+    if (required) {
+      Object.entries(required).forEach(([key, value]) => {
+        const found = wrapper.payloadSchemas.reduce((count, schema) => {
+          return count + (schema === key ? 1 : 0)
+        }, 0)
+        if (found !== value) {
+          errors.push(Error(`validateResultSet: Missing Schema [${key}:${found}:${value}]`))
+        }
+      })
+    }
+    return errors
+  }
+}

package/src/Query/QueryBoundWitnessWrapper.ts

@@ -0,0 +1,55 @@
+import { assertEx } from '@xylabs/assert'
+import { BoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
+import { XyoQuery, XyoQueryBoundWitness } from '@xyo-network/module-model'
+import { PayloadSetPayload, XyoPayloads } from '@xyo-network/payload-model'
+import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+
+import { QueryBoundWitnessValidator } from './QueryBoundWitnessValidator'
+
+export class QueryBoundWitnessWrapper<T extends XyoQuery = XyoQuery> extends BoundWitnessWrapper<XyoQueryBoundWitness> {
+  private _query: PayloadWrapper<T> | undefined
+  private _resultSet: PayloadWrapper<PayloadSetPayload> | undefined
+
+  private isQueryBoundWitnessWrapper = true
+
+  override get errors() {
+    return new QueryBoundWitnessValidator(this.boundwitness).validate()
+  }
+
+  get query() {
+    return assertEx(
+      (this._query =
+        this._query ?? this.payloads[this.boundwitness.query] ? PayloadWrapper.parse<T>(this.payloads[this.boundwitness.query]) : undefined),
+      `Missing Query [${this.boundwitness}, ${JSON.stringify(this.payloads, null, 2)}]`,
+    )
+  }
+
+  get resultSet() {
+    const resultSetHash = this.boundwitness.resultSet
+    return assertEx(
+      (this._resultSet =
+        this._resultSet ??
+        (resultSetHash
+          ? this.payloads[resultSetHash]
+            ? PayloadWrapper.parse<PayloadSetPayload>(this.payloads[resultSetHash])
+            : undefined
+          : undefined)),
+      `Missing resultSet [${resultSetHash}, ${JSON.stringify(this.payloads, null, 2)}]`,
+    )
+  }
+
+  static parseQuery<T extends XyoQuery = XyoQuery>(obj: unknown, payloads?: XyoPayloads): QueryBoundWitnessWrapper<T> {
+    assertEx(!Array.isArray(obj), 'Array can not be converted to QueryBoundWitnessWrapper')
+    switch (typeof obj) {
+      case 'object': {
+        const castWrapper = obj as QueryBoundWitnessWrapper<T>
+        const wrapper = castWrapper?.isQueryBoundWitnessWrapper ? castWrapper : new QueryBoundWitnessWrapper<T>(obj as XyoQueryBoundWitness, payloads)
+        if (!wrapper.valid) {
+          console.warn(`Parsed invalid QueryBoundWitness ${JSON.stringify(wrapper.errors.map((error) => error.message))}`)
+        }
+        return wrapper
+      }
+    }
+    throw Error(`Unable to parse [${typeof obj}]`)
+  }
+}

package/src/Query/index.ts

@@ -0,0 +1,3 @@
+export * from './QueryBoundWitnessBuilder'
+export * from './QueryBoundWitnessValidator'
+export * from './QueryBoundWitnessWrapper'

package/src/QueryValidator/ModuleConfigQueryValidator.ts

@@ -0,0 +1,67 @@
+import { AddressString, AnyConfigSchema, CosigningAddressSet, ModuleConfig, ModuleQuery, SchemaString } from '@xyo-network/module-model'
+
+import { QueryBoundWitnessWrapper } from '../Query'
+import { Queryable, QueryValidator } from './QueryValidator'
+
+export type SortedPipedAddressesString = string
+
+const delimiter = ''
+
+export class ModuleConfigQueryValidator<TConfig extends AnyConfigSchema<ModuleConfig>> implements QueryValidator {
+  protected allowed: Record<SchemaString, SortedPipedAddressesString[]> = {}
+  protected disallowed: Record<SchemaString, AddressString[]> = {}
+  protected readonly hasAllowedRules: boolean
+  protected readonly hasDisallowedRules: boolean
+  protected readonly hasRules: boolean
+
+  constructor(config?: TConfig) {
+    if (config?.security?.allowed) {
+      Object.entries(config.security?.allowed).forEach(([schema, addresses]) => {
+        this.allowed[schema] = addresses.map(toAddressesString)
+      })
+    }
+    if (config?.security?.disallowed) {
+      Object.entries(config.security?.disallowed).forEach(([schema, addresses]) => {
+        this.disallowed[schema] = addresses.map(toAddressesString)
+      })
+    }
+    this.hasAllowedRules = Object.keys(this.allowed).length > 0
+    this.hasDisallowedRules = Object.keys(this.disallowed).length > 0
+    this.hasRules = this.hasAllowedRules || this.hasDisallowedRules
+  }
+
+  queryable: Queryable = (query, payloads) => {
+    if (!this.hasRules) return true
+    const addresses = query.addresses
+    if (!addresses.length) return false
+    const wrapper = QueryBoundWitnessWrapper.parseQuery<ModuleQuery>(query, payloads)
+    const schema = wrapper.query.schema
+    return this.queryAllowed(schema, addresses) && !this.queryDisallowed(schema, addresses)
+  }
+
+  protected queryAllowed = (schema: SchemaString, addresses: string[]): boolean => {
+    if (!this.hasAllowedRules) return true
+    // All cosigners must sign
+    if (addresses.length > 1) {
+      const signatories = toAddressesString(addresses)
+      const validCosigners = this.allowed?.[schema]?.includes(signatories)
+      if (validCosigners) return true
+    }
+    // OR all signers have to be allowed individually
+    return addresses.every((address) => this.allowed?.[schema]?.includes(address) || false)
+  }
+  protected queryDisallowed = (schema: SchemaString, addresses: string[]): boolean => {
+    if (!this.hasDisallowedRules) return false
+    return addresses.some((address) => this.disallowed?.[schema]?.includes(address))
+  }
+}
+
+// TODO: Handle 0x prefix
+const toAddressesString = (addresses: string | CosigningAddressSet): SortedPipedAddressesString => {
+  return Array.isArray(addresses)
+    ? addresses
+        .sort()
+        .map((address) => address.toLowerCase())
+        .join(delimiter)
+    : addresses.toLowerCase()
+}

package/src/QueryValidator/QueryValidator.ts

@@ -0,0 +1,8 @@
+import { XyoQueryBoundWitness } from '@xyo-network/module-model'
+import { XyoPayload } from '@xyo-network/payload-model'
+
+export type Queryable<T extends XyoQueryBoundWitness = XyoQueryBoundWitness> = (query: T, payloads?: XyoPayload[]) => boolean
+
+export interface QueryValidator<T extends XyoQueryBoundWitness = XyoQueryBoundWitness> {
+  queryable: Queryable<T>
+}

package/src/QueryValidator/SupportedQueryValidator.ts

@@ -0,0 +1,22 @@
+import { Module, ModuleQuery, XyoQueryBoundWitness } from '@xyo-network/module-model'
+import { XyoPayload } from '@xyo-network/payload-model'
+
+import { QueryBoundWitnessWrapper } from '../Query'
+import { Queryable, QueryValidator } from './QueryValidator'
+
+export const isQuerySupportedByModule = <T extends XyoQueryBoundWitness = XyoQueryBoundWitness>(
+  mod: Module,
+  query: T,
+  payloads?: XyoPayload[],
+): boolean => {
+  const wrapper = QueryBoundWitnessWrapper.parseQuery<ModuleQuery>(query, payloads)
+  const schema = wrapper.query.schema
+  return mod.queries.includes(schema)
+}
+
+export class SupportedQueryValidator implements QueryValidator {
+  constructor(protected readonly mod: Module) {}
+  queryable: Queryable = (query, payloads) => {
+    return isQuerySupportedByModule(this.mod, query, payloads)
+  }
+}

package/src/QueryValidator/index.ts

@@ -0,0 +1,3 @@
+export * from './ModuleConfigQueryValidator'
+export * from './QueryValidator'
+export * from './SupportedQueryValidator'

package/src/Resolver/CompositeModuleResolver.ts

@@ -0,0 +1,70 @@
+import { fulfilled } from '@xylabs/promise'
+import { Module, ModuleFilter, ModuleRepository, ModuleResolver } from '@xyo-network/module-model'
+
+import { duplicateModules } from '../lib'
+import { SimpleModuleResolver } from './SimpleModuleResolver'
+
+export class CompositeModuleResolver implements ModuleRepository, ModuleResolver {
+  protected resolvers: ModuleResolver[] = []
+  private localResolver: SimpleModuleResolver
+
+  constructor() {
+    const localResolver = new SimpleModuleResolver()
+    this.addResolver(localResolver)
+    this.localResolver = localResolver
+  }
+
+  get isModuleResolver() {
+    return true
+  }
+
+  add(module: Module): this
+  add(module: Module[]): this
+  add(module: Module | Module[]): this {
+    if (Array.isArray(module)) {
+      module.forEach((module) => this.addSingleModule(module))
+    } else {
+      this.addSingleModule(module)
+    }
+    return this
+  }
+
+  addResolver(resolver: ModuleResolver): this {
+    this.resolvers.push(resolver)
+    return this
+  }
+
+  remove(addressOrName: string | string[]): this {
+    if (Array.isArray(addressOrName)) {
+      addressOrName.forEach((address) => this.removeSingleModule(address))
+    } else {
+      this.removeSingleModule(addressOrName)
+    }
+    return this
+  }
+
+  removeResolver(resolver: ModuleResolver): this {
+    this.resolvers = this.resolvers.filter((item) => item !== resolver)
+    return this
+  }
+
+  async resolve<T extends Module = Module>(filter?: ModuleFilter): Promise<T[]> {
+    const modules = this.resolvers.map((resolver) => resolver.resolve(filter))
+    const settled = await Promise.allSettled(modules)
+    const result = settled
+      .filter(fulfilled)
+      .map((r) => r.value)
+      .flat()
+      .filter(duplicateModules)
+    return result as T[]
+  }
+
+  private addSingleModule(module?: Module) {
+    if (module) {
+      this.localResolver.add(module)
+    }
+  }
+  private removeSingleModule(addressOrName: string) {
+    this.localResolver.remove(addressOrName)
+  }
+}

package/src/Resolver/ResolverEventEmitter.ts

@@ -0,0 +1,46 @@
+import { Module, ModuleFilter, ModuleResolver } from '@xyo-network/module-model'
+
+export interface ModuleResolvedEventArgs {
+  filter?: ModuleFilter
+  module: Module
+}
+
+export interface ResolverEventEmitter {
+  on(event: 'moduleResolved', listener: (args: ModuleResolvedEventArgs) => void): void
+}
+
+type ListenerFunction = (args: ModuleResolvedEventArgs) => void
+
+const getMixin = <T extends ModuleResolver = ModuleResolver>(resolver: T) => {
+  const listeners: ListenerFunction[] = []
+  const emit = (event: 'moduleResolved', args: ModuleResolvedEventArgs): boolean => {
+    if (listeners.length < 1) return false
+    listeners.map((listener) => listener(args))
+    return true
+  }
+  const onModuleResolved = (module: Module, filter?: ModuleFilter) => {
+    const args = { filter, module }
+    emit('moduleResolved', args)
+  }
+  const { resolve } = resolver
+  function originalResolve(filter?: ModuleFilter) {
+    return resolve.bind(resolver)(filter)
+  }
+
+  return {
+    on: (event: 'moduleResolved', listener: (args: ModuleResolvedEventArgs) => void) => {
+      listeners.push(listener)
+    },
+    resolve: async (filter?: ModuleFilter): Promise<Module[]> => {
+      const modules: Module[] = await originalResolve(filter)
+      await Promise.allSettled(modules.map((mod) => onModuleResolved(mod, filter)))
+      return modules
+    },
+  }
+}
+
+export const mixinResolverEventEmitter = <T extends ModuleResolver = ModuleResolver>(resolver: T): T & ResolverEventEmitter => {
+  const mixin = getMixin(resolver)
+  const ret = Object.assign(resolver, mixin)
+  return ret
+}