@xyo-network/bridge-abstract 5.3.22 → 5.3.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/bridge-abstract",
-  "version": "5.3.22",
+  "version": "5.3.24",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,79 +30,75 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
     "!**/*.test.*",
     "README.md"
   ],
   "dependencies": {
-    "@xyo-network/account": "~5.3.22",
-    "@xyo-network/account-model": "~5.3.22",
-    "@xyo-network/archivist-model": "~5.3.22",
-    "@xyo-network/archivist-wrapper": "~5.3.22",
-    "@xyo-network/boundwitness-model": "~5.3.22",
-    "@xyo-network/boundwitness-wrapper": "~5.3.22",
-    "@xyo-network/bridge-model": "~5.3.22",
-    "@xyo-network/diviner-model": "~5.3.22",
-    "@xyo-network/diviner-wrapper": "~5.3.22",
-    "@xyo-network/manifest-model": "~5.3.22",
-    "@xyo-network/module-abstract": "~5.3.22",
-    "@xyo-network/module-model": "~5.3.22",
-    "@xyo-network/module-resolver": "~5.3.22",
-    "@xyo-network/module-wrapper": "~5.3.22",
-    "@xyo-network/node-model": "~5.3.22",
-    "@xyo-network/node-wrapper": "~5.3.22",
-    "@xyo-network/payload-builder": "~5.3.22",
-    "@xyo-network/payload-model": "~5.3.22",
-    "@xyo-network/query-payload-plugin": "~5.3.22",
-    "@xyo-network/sentinel-model": "~5.3.22",
-    "@xyo-network/sentinel-wrapper": "~5.3.22",
-    "@xyo-network/witness-model": "~5.3.22",
-    "@xyo-network/witness-wrapper": "~5.3.22",
-    "lru-cache": "~11.2.7"
+    "lru-cache": "~11.2.7",
+    "@xyo-network/account-model": "~5.3.24",
+    "@xyo-network/archivist-model": "~5.3.24",
+    "@xyo-network/boundwitness-model": "~5.3.24",
+    "@xyo-network/archivist-wrapper": "~5.3.24",
+    "@xyo-network/boundwitness-wrapper": "~5.3.24",
+    "@xyo-network/bridge-model": "~5.3.24",
+    "@xyo-network/manifest-model": "~5.3.24",
+    "@xyo-network/module-resolver": "~5.3.24",
+    "@xyo-network/diviner-model": "~5.3.24",
+    "@xyo-network/module-model": "~5.3.24",
+    "@xyo-network/account": "~5.3.24",
+    "@xyo-network/module-wrapper": "~5.3.24",
+    "@xyo-network/node-model": "~5.3.24",
+    "@xyo-network/diviner-wrapper": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24",
+    "@xyo-network/module-abstract": "~5.3.24",
+    "@xyo-network/payload-builder": "~5.3.24",
+    "@xyo-network/node-wrapper": "~5.3.24",
+    "@xyo-network/query-payload-plugin": "~5.3.24",
+    "@xyo-network/sentinel-model": "~5.3.24",
+    "@xyo-network/witness-wrapper": "~5.3.24",
+    "@xyo-network/sentinel-wrapper": "~5.3.24",
+    "@xyo-network/witness-model": "~5.3.24"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/sdk-js": "^5.0.91",
-    "@xylabs/ts-scripts-common": "~7.6.8",
-    "@xylabs/ts-scripts-yarn3": "~7.6.8",
-    "@xylabs/tsconfig": "~7.6.8",
-    "@xyo-network/account": "~5.3.22",
-    "@xyo-network/account-model": "~5.3.22",
-    "@xyo-network/archivist-model": "~5.3.22",
-    "@xyo-network/archivist-wrapper": "~5.3.22",
-    "@xyo-network/boundwitness-model": "~5.3.22",
-    "@xyo-network/boundwitness-wrapper": "~5.3.22",
-    "@xyo-network/bridge-model": "~5.3.22",
-    "@xyo-network/diviner-model": "~5.3.22",
-    "@xyo-network/diviner-wrapper": "~5.3.22",
-    "@xyo-network/manifest-model": "~5.3.22",
-    "@xyo-network/module-abstract": "~5.3.22",
-    "@xyo-network/module-model": "~5.3.22",
-    "@xyo-network/module-resolver": "~5.3.22",
-    "@xyo-network/module-wrapper": "~5.3.22",
-    "@xyo-network/node-model": "~5.3.22",
-    "@xyo-network/node-wrapper": "~5.3.22",
-    "@xyo-network/payload-builder": "~5.3.22",
-    "@xyo-network/payload-model": "~5.3.22",
-    "@xyo-network/query-payload-plugin": "~5.3.22",
-    "@xyo-network/sentinel-model": "~5.3.22",
-    "@xyo-network/sentinel-wrapper": "~5.3.22",
-    "@xyo-network/witness-model": "~5.3.22",
-    "@xyo-network/witness-wrapper": "~5.3.22",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.16",
+    "@xylabs/ts-scripts-pnpm": "~7.6.16",
+    "@xylabs/tsconfig": "~7.6.16",
     "acorn": "^8.16.0",
     "axios": "^1.14.0",
-    "cosmiconfig": "^9.0.1",
-    "esbuild": "^0.27.4",
-    "eslint": "^10.1.0",
+    "esbuild": "^0.28.0",
     "ethers": "^6.16.0",
-    "lru-cache": "^11.2.7",
-    "rollup": "^4.60.1",
+    "lru-cache": "~11.2.7",
     "tslib": "^2.8.1",
     "typescript": "~5.9.3",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@xyo-network/account": "~5.3.24",
+    "@xyo-network/account-model": "~5.3.24",
+    "@xyo-network/archivist-wrapper": "~5.3.24",
+    "@xyo-network/boundwitness-model": "~5.3.24",
+    "@xyo-network/archivist-model": "~5.3.24",
+    "@xyo-network/boundwitness-wrapper": "~5.3.24",
+    "@xyo-network/bridge-model": "~5.3.24",
+    "@xyo-network/diviner-model": "~5.3.24",
+    "@xyo-network/manifest-model": "~5.3.24",
+    "@xyo-network/module-resolver": "~5.3.24",
+    "@xyo-network/node-model": "~5.3.24",
+    "@xyo-network/node-wrapper": "~5.3.24",
+    "@xyo-network/module-wrapper": "~5.3.24",
+    "@xyo-network/payload-builder": "~5.3.24",
+    "@xyo-network/module-abstract": "~5.3.24",
+    "@xyo-network/diviner-wrapper": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24",
+    "@xyo-network/query-payload-plugin": "~5.3.24",
+    "@xyo-network/sentinel-model": "~5.3.24",
+    "@xyo-network/sentinel-wrapper": "~5.3.24",
+    "@xyo-network/witness-model": "~5.3.24",
+    "@xyo-network/module-model": "~5.3.24",
+    "@xyo-network/witness-wrapper": "~5.3.24"
   },
   "peerDependencies": {
     "@xylabs/sdk-js": "^5",
@@ -113,4 +109,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/AbstractBridge.ts

@@ -1,213 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import {
-  assertEx, exists, forget,
-  globallyUnique,
-} from '@xylabs/sdk-js'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import { asArchivistInstance } from '@xyo-network/archivist-model'
-import type { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import type {
-  AttachableBridgeInstance,
-  BridgeExposeOptions,
-  BridgeModuleEventData,
-  BridgeParams,
-  BridgeQueries,
-  BridgeUnexposeOptions,
-  ModuleFilterPayload,
-} from '@xyo-network/bridge-model'
-import {
-  BridgeConfigSchema,
-  BridgeConnectQuerySchema,
-  BridgeDisconnectQuerySchema,
-  BridgeExposeQuerySchema,
-  BridgeUnexposeQuerySchema,
-  ModuleFilterPayloadSchema,
-} from '@xyo-network/bridge-model'
-import { AbstractModuleInstance } from '@xyo-network/module-abstract'
-import type {
-  AddressPayload,
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleInstance,
-  ModuleQueryHandlerResult,
-  ModuleResolverInstance,
-} from '@xyo-network/module-model'
-import {
-  AddressSchema,
-  resolveAddressToInstance,
-  resolvePathToAddress,
-  transformModuleIdentifier,
-} from '@xyo-network/module-model'
-import type { Payload, Schema } from '@xyo-network/payload-model'
-import { isPayloadOfSchemaType } from '@xyo-network/payload-model'
-
-export abstract class AbstractBridge<TParams extends BridgeParams = BridgeParams>
-  extends AbstractModuleInstance<TParams, BridgeModuleEventData>
-  implements AttachableBridgeInstance<TParams, BridgeModuleEventData> {
-  static override readonly configSchemas: Schema[] = [...super.configSchemas, BridgeConfigSchema]
-  static override readonly defaultConfigSchema: Schema = BridgeConfigSchema
-  static override readonly uniqueName = globallyUnique('AbstractBridge', AbstractBridge, 'xyo')
-
-  protected _roots?: ModuleInstance[]
-
-  override get allowNameResolution() {
-    // we default to false here to prevent name collisions
-    return this.params.allowNameResolution ?? true
-  }
-
-  get discoverRoots() {
-    return this.config.client?.discoverRoots ?? (this.config.client === undefined ? false : 'start')
-  }
-
-  override get queries(): Schema[] {
-    return [BridgeConnectQuerySchema, BridgeDisconnectQuerySchema, BridgeExposeQuerySchema, BridgeUnexposeQuerySchema, ...super.queries]
-  }
-
-  get resolver(): Promisable<ModuleResolverInstance> {
-    return assertEx(this.params.resolver, () => 'No resolver provided')
-  }
-
-  async expose(id: ModuleIdentifier, options?: BridgeExposeOptions | undefined): Promise<ModuleInstance[]> {
-    this._noOverride('expose')
-    assertEx(id !== '*', () => "Exposing '*' not supported")
-    const addressToExpose = assertEx(await resolvePathToAddress(this, id), () => `Module to expose not found [${id}]`)
-    console.log(`expose: ${addressToExpose}`)
-    const modules = await this.exposeHandler(addressToExpose, options)
-    await this.emit('exposed', { mod: this, modules })
-    return modules
-  }
-
-  async exposed(): Promise<Address[]> {
-    this._noOverride('exposed')
-    return await this.exposedHandler()
-  }
-
-  /** @deprecated do not pass undefined.  If trying to get all, pass '*' */
-  override async resolve(): Promise<ModuleInstance[]>
-  override async resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>
-  override async resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
-
-  override async resolve<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options: ModuleFilterOptions<T> = {},
-  ): Promise<T | T[] | undefined> {
-    const roots = (this._roots ?? []) as T[]
-    const workingSet = (options.direction === 'up' ? [this as ModuleInstance] : [...roots, this]) as T[]
-    if (id === '*') {
-      const remainingDepth = (options.maxDepth ?? 5) - 1
-      return remainingDepth <= 0
-        ? workingSet
-        : (
-            [...workingSet, ...(await Promise.all(roots.map(mod => mod.resolve('*', { ...options, maxDepth: remainingDepth })))).flat()]
-          )
-    }
-    switch (typeof id) {
-      case 'string': {
-        const parts = id.split(':')
-        const first = assertEx(parts.shift(), () => 'Missing module identifier')
-        const firstId = await transformModuleIdentifier(first, this.moduleIdentifierTransformers)
-        const result = workingSet.find((mod) => {
-          return firstId === mod.address || firstId === mod.modName
-        })
-        return parts.length === 0 ? result : result?.resolve(parts.join(':'), options)
-      }
-      default: {
-        return
-      }
-    }
-  }
-
-  override async startHandler() {
-    if (this.discoverRoots === 'lazy') {
-      forget(this.getRoots())
-    } else if (this.discoverRoots === 'start') {
-      await this.getRoots()
-    }
-  }
-
-  async unexpose(id: ModuleIdentifier, options?: BridgeUnexposeOptions | undefined): Promise<Address[]> {
-    this._noOverride('unexpose')
-    const addressToUnexpose = assertEx(await resolvePathToAddress(this, id), () => `Module to unexpose not found [${id}]`)
-    const modules = await this.unexposeHandler(addressToUnexpose, options)
-    await this.emit('unexposed', { mod: this, modules })
-    return modules.map(mod => mod.address)
-  }
-
-  protected override async queryHandler<T extends QueryBoundWitness = QueryBoundWitness>(
-    query: T,
-    payloads?: Payload[],
-  ): Promise<ModuleQueryHandlerResult> {
-    const wrapper = QueryBoundWitnessWrapper.parseQuery<BridgeQueries>(query, payloads)
-    const queryPayload = await wrapper.getQuery()
-    const resultPayloads: Payload[] = []
-
-    switch (queryPayload.schema) {
-      case BridgeExposeQuerySchema: {
-        const filterPayloads = (payloads ?? []).filter(isPayloadOfSchemaType<ModuleFilterPayload>(ModuleFilterPayloadSchema))
-        assertEx(filterPayloads, () => 'At least one filter is required')
-
-        await Promise.all(
-          filterPayloads.map(async (filter) => {
-            const { id, ...options } = filter
-            const modules = await this.expose(id, options)
-            for (const mod of modules) {
-              const addressPayload: AddressPayload = {
-                address: mod.address,
-                schema: AddressSchema,
-              }
-              resultPayloads.push(addressPayload)
-            }
-          }),
-        )
-        break
-      }
-      case BridgeUnexposeQuerySchema: {
-        const filterPayloads = (payloads ?? []).filter(isPayloadOfSchemaType<ModuleFilterPayload>(ModuleFilterPayloadSchema))
-        assertEx(filterPayloads, () => 'At least one filter is required')
-
-        await Promise.all(
-          filterPayloads.map(async (filter) => {
-            const { id, ...options } = filter
-            const moduleAddresses = await this.unexpose(id, options)
-            for (const address of moduleAddresses) {
-              const addressPayload: AddressPayload = {
-                address,
-                schema: AddressSchema,
-              }
-              resultPayloads.push(addressPayload)
-            }
-          }),
-        )
-        break
-      }
-      default: {
-        return await super.queryHandler(query, payloads)
-      }
-    }
-    return resultPayloads
-  }
-
-  protected override async resolveArchivingArchivists(): Promise<ArchivistInstance[]> {
-    const archivists = this.archiving?.archivists
-    if (!archivists) return []
-    const resolvedAddresses = (
-      await Promise.all(
-        archivists.map(async archivist =>
-          (await Promise.all((await this.parents()).map(parent => resolvePathToAddress(parent, archivist)))).filter(exists)),
-      )
-    )
-      .flat()
-      .filter(exists)
-    const resolved = (await Promise.all(resolvedAddresses.map(address => resolveAddressToInstance(this, address)))).filter(exists)
-    return resolved.map(mod => asArchivistInstance(mod)).filter(exists)
-  }
-
-  abstract exposeHandler(address: Address, options?: BridgeExposeOptions | undefined): Promisable<ModuleInstance[]>
-
-  abstract exposedHandler(): Promisable<Address[]>
-
-  abstract getRoots(force?: boolean): Promise<ModuleInstance[]>
-
-  abstract unexposeHandler(address: Address, options?: BridgeUnexposeOptions | undefined): Promisable<ModuleInstance[]>
-}

package/src/AbstractBridgeModuleResolver.ts

@@ -1,47 +0,0 @@
-import type { AccountInstance } from '@xyo-network/account-model'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import type {
-  BridgeInstance, QuerySendFinishedEventArgs, QuerySendStartedEventArgs,
-} from '@xyo-network/bridge-model'
-import type {
-  ArchivingModuleConfig,
-  CacheConfig,
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleInstance,
-} from '@xyo-network/module-model'
-import { ObjectResolverPriority } from '@xyo-network/module-model'
-import type { ModuleResolverParams } from '@xyo-network/module-resolver'
-import { CompositeModuleResolver } from '@xyo-network/module-resolver'
-
-import type { ModuleProxyParams } from './AbstractModuleProxy/index.ts'
-
-export interface BridgeModuleResolverParams extends ModuleResolverParams {
-  additionalSigners?: AccountInstance[]
-  archiving?: ArchivingModuleConfig['archiving'] & { resolveArchivists: () => Promise<ArchivistInstance[]> }
-  bridge: BridgeInstance
-  cacheConfig?: CacheConfig
-  onQuerySendFinished?: (args: Omit<QuerySendFinishedEventArgs, 'mod'>) => void
-  onQuerySendStarted?: (args: Omit<QuerySendStartedEventArgs, 'mod'>) => void
-  wrapperAccount: AccountInstance
-}
-
-export abstract class AbstractBridgeModuleResolver<
-  TParams extends BridgeModuleResolverParams = BridgeModuleResolverParams,
-  TProxyParams extends ModuleProxyParams = ModuleProxyParams,
-> extends CompositeModuleResolver<TParams> {
-  override get priority() {
-    return ObjectResolverPriority.VeryLow
-  }
-
-  override async resolveHandler<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier,
-    options?: ModuleFilterOptions<T>,
-    _params?: Partial<TProxyParams>,
-  ): Promise<T[]> {
-    if (id === '*') {
-      return []
-    }
-    return await super.resolveHandler(id, options)
-  }
-}

package/src/AbstractModuleProxy/AbstractModuleProxy.ts

@@ -1,309 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import {
-  asAddress, assertEx,
-  exists,
-  forget,
-  isAddress, toSafeJsonString,
-} from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
-import type { AccountInstance } from '@xyo-network/account-model'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import type { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { BoundWitnessWrapper, QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import type { QuerySendFinishedEventArgs, QuerySendStartedEventArgs } from '@xyo-network/bridge-model'
-import type { ModuleManifestPayload, NodeManifestPayload } from '@xyo-network/manifest-model'
-import { ModuleManifestPayloadSchema, NodeManifestPayloadSchema } from '@xyo-network/manifest-model'
-import { AbstractModuleInstance } from '@xyo-network/module-abstract'
-import type {
-  AddressPreviousHashPayload,
-  ArchivingModuleConfig,
-  AttachableModuleInstance,
-  ModuleAddressQuery,
-  ModuleEventData,
-  ModuleInstance,
-  ModuleManifestQuery,
-  ModuleName,
-  ModuleQueryHandlerResult,
-  ModuleQueryResult,
-  ModuleResolver,
-  QueryableModule,
-  QueryableModuleParams,
-} from '@xyo-network/module-model'
-import {
-  AddressPreviousHashSchema,
-  DeadModuleError,
-  ModuleAddressQuerySchema,
-  ModuleConfigSchema,
-  ModuleManifestQuerySchema,
-  ModuleStateQuerySchema,
-} from '@xyo-network/module-model'
-import { ModuleWrapper } from '@xyo-network/module-wrapper'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type {
-  ModuleError, Payload, Schema,
-} from '@xyo-network/payload-model'
-import {
-  isPayloadOfSchemaType, isSchema, ModuleErrorSchema,
-} from '@xyo-network/payload-model'
-import type { QueryPayload } from '@xyo-network/query-payload-plugin'
-import { QuerySchema } from '@xyo-network/query-payload-plugin'
-import { LRUCache } from 'lru-cache'
-
-import { ModuleProxyResolver } from './ModuleProxyResolver.ts'
-
-export interface ModuleProxyParams extends QueryableModuleParams
-{
-  account: AccountInstance
-  archiving?: ArchivingModuleConfig['archiving'] & { resolveArchivists: () => Promise<ArchivistInstance[]> }
-  host: ModuleResolver
-  manifest?: ModuleManifestPayload
-  moduleAddress: Address
-  onQuerySendFinished?: (args: Omit<QuerySendFinishedEventArgs, 'mod'>) => void
-  onQuerySendStarted?: (args: Omit<QuerySendStartedEventArgs, 'mod'>) => void
-  state?: Payload[]
-}
-
-export abstract class AbstractModuleProxy<
-  TWrappedModule extends ModuleInstance = ModuleInstance,
-  TParams extends ModuleProxyParams = ModuleProxyParams,
->
-  extends AbstractModuleInstance<TParams, TWrappedModule['eventData']>
-  implements ModuleInstance<TParams, TWrappedModule['eventData']> {
-  static readonly requiredQueries: string[] = [ModuleStateQuerySchema]
-
-  protected _config?: TWrappedModule['config']
-  protected _publicChildren?: ModuleInstance[]
-  protected _state: Payload[] | undefined = undefined
-  protected _stateInProcess = false
-
-  private _spamTrap = new LRUCache<string, number>({
-    max: 1000, ttl: 1000 * 60, ttlAutopurge: true,
-  })
-
-  override get address() {
-    return this.params.moduleAddress
-  }
-
-  override get archiving(): ArchivingModuleConfig['archiving'] | undefined {
-    return this.params?.archiving
-  }
-
-  override get config(): TWrappedModule['config'] & { schema: Schema } {
-    return { ...this._config, schema: (this._config?.schema ?? ModuleConfigSchema) }
-  }
-
-  override get queries(): Schema[] {
-    const queryPayloads = assertEx(this._state, () => 'Module state not found.  Make sure proxy has been started').filter(item =>
-      isPayloadOfSchemaType<QueryPayload>(QuerySchema)(item)) as QueryPayload[]
-    return queryPayloads.map(payload => payload.query)
-  }
-
-  static hasRequiredQueries(mod: QueryableModule) {
-    return this.missingRequiredQueries(mod).length === 0
-  }
-
-  static override isAllowedSchema(schema: Schema): boolean {
-    return isSchema(schema)
-  }
-
-  static missingRequiredQueries(mod: QueryableModule): string[] {
-    const moduleQueries = mod.queries
-    return (
-      this.requiredQueries.map((query) => {
-        return moduleQueries.includes(query) ? null : query
-      })
-    ).filter(exists)
-  }
-
-  static override async paramsHandler<T extends AttachableModuleInstance<QueryableModuleParams, ModuleEventData>>(
-    inParams?: Partial<T['params']>,
-  ): Promise<T['params']> {
-    const superParams = await super.paramsHandler(inParams)
-    return {
-      ...superParams,
-      account: (superParams.account === 'random') ? await Account.random() : superParams.account,
-      addToResolvers: superParams.addToResolvers ?? true,
-    }
-  }
-
-  async addressPreviousHash(): Promise<AddressPreviousHashPayload> {
-    const queryPayload: ModuleAddressQuery = { schema: ModuleAddressQuerySchema }
-    const result: AddressPreviousHashPayload = assertEx(
-      (await this.sendQuery(queryPayload, undefined, this.account)).find(
-        isPayloadOfSchemaType<AddressPreviousHashPayload>(AddressPreviousHashSchema),
-      ) as AddressPreviousHashPayload,
-      () => 'Result did not include correct payload',
-    )
-    return result
-  }
-
-  childAddressByName(name: ModuleName): Address | undefined {
-    const nodeManifests = this._state?.filter(isPayloadOfSchemaType<NodeManifestPayload>(NodeManifestPayloadSchema))
-    const childPairs = nodeManifests?.flatMap(nodeManifest => Object.entries(nodeManifest.status?.children ?? {}) as [Address, ModuleName | null][])
-    return asAddress(childPairs?.find(([_, childName]) => childName === name)?.[0])
-  }
-
-  async childAddressMap(): Promise<Record<Address, ModuleName | null>> {
-    let nodeManifests: NodeManifestPayload[] | undefined
-      = isPayloadOfSchemaType<NodeManifestPayload>(NodeManifestPayloadSchema)(this.params.manifest) ? [this.params.manifest] : undefined
-    const result: Record<Address, ModuleName | null> = {}
-    if (nodeManifests === undefined) {
-      const state = await this.state()
-      nodeManifests = state.filter(isPayloadOfSchemaType<NodeManifestPayload>(NodeManifestPayloadSchema))
-    }
-    for (const manifest of nodeManifests ?? []) {
-      const children = manifest.modules?.public ?? []
-      for (const child of children) {
-        if (typeof child === 'object') {
-          const address = child.status?.address
-          if (isAddress(address)) {
-            result[address] = child.config.name ?? null
-          }
-        }
-      }
-    }
-    return result
-  }
-
-  override async createHandler(): Promise<void> {
-    await super.createHandler()
-    let manifest: ModuleManifestPayload | NodeManifestPayload | undefined = this.params.manifest
-    if (!manifest) {
-      const state = await this.state()
-      const manifestPayload = state.find(
-        payload => isPayloadOfSchemaType<NodeManifestPayload>(NodeManifestPayloadSchema)(payload)
-          || isPayloadOfSchemaType<ModuleManifestPayload>(ModuleManifestPayloadSchema)(payload),
-      )
-      manifest = assertEx(manifestPayload, () => "Can't find manifest payload")
-    }
-    this.setConfig({ ...manifest.config })
-    this.downResolver.addResolver(
-      new ModuleProxyResolver({
-        childAddressMap: await this.childAddressMap(),
-        host: this.params.host,
-        mod: this,
-        moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-      }),
-    )
-  }
-
-  override async manifest(maxDepth?: number): Promise<ModuleManifestPayload> {
-    const queryPayload: ModuleManifestQuery = { schema: ModuleManifestQuerySchema, ...(maxDepth === undefined ? {} : { maxDepth }) }
-    return (await this.sendQuery(queryPayload))[0] as ModuleManifestPayload
-  }
-
-  override async moduleAddress(): Promise<AddressPreviousHashPayload[]> {
-    const queryPayload: ModuleAddressQuery = { schema: ModuleAddressQuerySchema }
-    return (await this.sendQuery(queryPayload)) as AddressPreviousHashPayload[]
-  }
-
-  override async previousHash(): Promise<string | undefined> {
-    const queryPayload: ModuleAddressQuery = { schema: ModuleAddressQuerySchema }
-    return ((await this.sendQuery(queryPayload)).pop() as AddressPreviousHashPayload).previousHash
-  }
-
-  override async publicChildren() {
-    this._publicChildren = this._publicChildren ?? (await super.publicChildren())
-    return this._publicChildren
-  }
-
-  override async query<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryResult> {
-    this._checkDead()
-    return await this.busy(async () => {
-      try {
-        await this.checkSpam(query)
-        if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-          forget(this.storeToArchivists([query, ...(payloads ?? [])]))
-        }
-        this.params.onQuerySendStarted?.({ payloads, query })
-        const result = await this.proxyQueryHandler<T>(query, payloads)
-        this.params.onQuerySendFinished?.({
-          payloads, query, result, status: 'success',
-        })
-        if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-          forget(this.storeToArchivists(result.flat()))
-        }
-        forget(this.emit('moduleQueried', {
-          mod: this, payloads, query, result,
-        }))
-        return result
-      } catch (ex) {
-        this.params.onQuerySendFinished?.({
-          payloads, query, status: 'failure',
-        })
-        const error = ex as Error
-        this._lastError = error
-        // this.status = 'dead'
-        const deadError = new DeadModuleError(this.address, error)
-        const errorPayload: ModuleError = {
-          message: deadError.message,
-          name: deadError.name,
-          schema: ModuleErrorSchema,
-        }
-        const sourceQuery = assertEx(QueryBoundWitnessWrapper.unwrap(query), () => 'Invalid query')
-        return await this.bindQueryResult(sourceQuery, [], undefined, [errorPayload])
-      }
-    })
-  }
-
-  override queryHandler<T extends QueryBoundWitness = QueryBoundWitness>(
-    _query: T,
-    _payloads?: Payload[],
-    _queryConfig?: TWrappedModule['params']['config'],
-  ): Promise<ModuleQueryHandlerResult> {
-    throw new Error('queryHandler should never be called')
-  }
-
-  override async queryable<T extends QueryBoundWitness = QueryBoundWitness>(
-    _query: T,
-    _payloads?: Payload[],
-    _queryConfig?: TWrappedModule['params']['config'],
-  ): Promise<boolean> {
-    return await Promise.resolve(true)
-  }
-
-  override async resolveArchivingArchivists(): Promise<ArchivistInstance[]> {
-    return (await this.params.archiving?.resolveArchivists()) ?? []
-  }
-
-  setConfig(config: TWrappedModule['params']['config']) {
-    this._config = config
-  }
-
-  setState(state: Payload[]) {
-    this._state = state
-  }
-
-  override async state(): Promise<Payload[]> {
-    if (this._state === undefined) {
-      // temporarily add ModuleStateQuerySchema to the schema list so we can wrap it and get the real query list
-      const stateQueryPayload: QueryPayload = { query: ModuleStateQuerySchema, schema: QuerySchema }
-      const manifestQueryPayload: QueryPayload = { query: ModuleManifestQuerySchema, schema: QuerySchema }
-      this._state = [stateQueryPayload, manifestQueryPayload]
-      const wrapper = ModuleWrapper.wrap(this, await Account.random())
-      this._state = await wrapper.state()
-    }
-    return this._state
-  }
-
-  protected filterErrors(result: ModuleQueryResult): ModuleError[] {
-    const wrapper = BoundWitnessWrapper.wrap(result[0], result[1])
-    return wrapper.payloadsBySchema<ModuleError>(ModuleErrorSchema)
-  }
-
-  protected override async startHandler(): Promise<void> {
-    return await super.startHandler()
-  }
-
-  // this checks and warns if we are getting spammed by the same query
-  private async checkSpam(query: QueryBoundWitness) {
-    const hash = await PayloadBuilder.hash(query)
-    const previousCount = this._spamTrap.get(hash) ?? 0
-    if (previousCount > 0) {
-      this.logger?.warn(`Spam trap triggered for query: ${hash} from ${toSafeJsonString(query.addresses)}`)
-    }
-    this._spamTrap.set(hash, previousCount + 1)
-  }
-
-  abstract proxyQueryHandler<T extends QueryBoundWitness = QueryBoundWitness>(_query: T, _payloads?: Payload[]): Promise<ModuleQueryResult>
-}

package/src/AbstractModuleProxy/ModuleProxyResolver.ts

@@ -1,156 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import { assertEx, exists } from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
-import type { ModuleManifestPayload } from '@xyo-network/manifest-model'
-import type {
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleIdentifierTransformer,
-  ModuleInstance,
-  ModuleName,
-  ModuleResolver,
-  ModuleResolverInstance,
-  ObjectFilterOptions,
-} from '@xyo-network/module-model'
-import { ObjectResolverPriority } from '@xyo-network/module-model'
-import { CompositeModuleResolver } from '@xyo-network/module-resolver'
-
-import { wrapModuleWithType } from '../wrapModuleWithType.ts'
-
-export interface ModuleProxyResolverOptions {
-  childAddressMap: Record<Address, ModuleName | null>
-  childManifests?: Record<Address, ModuleManifestPayload>
-  childStates?: Record<Address, ModuleManifestPayload>
-  host: ModuleResolver
-  mod: ModuleInstance
-  moduleIdentifierTransformers?: ModuleIdentifierTransformer[]
-}
-
-export class ModuleProxyResolver<T extends ModuleProxyResolverOptions = ModuleProxyResolverOptions> implements ModuleResolverInstance {
-  private downResolver: CompositeModuleResolver
-  private options: T
-
-  constructor(options: T) {
-    this.options = options
-    this.downResolver = new CompositeModuleResolver({ moduleIdentifierTransformers: options.moduleIdentifierTransformers, root: this.root })
-  }
-
-  get priority() {
-    return ObjectResolverPriority.VeryLow
-  }
-
-  get root() {
-    return this.options.mod
-  }
-
-  protected get childAddressMap() {
-    return this.options.childAddressMap
-  }
-
-  protected get host() {
-    return this.options.host
-  }
-
-  protected get mod() {
-    return this.options.mod
-  }
-
-  addResolver(_resolver: ModuleResolver): this {
-    throw new Error('Not supported')
-  }
-
-  childManifest(address: Address) {
-    return this.options.childManifests?.[address]
-  }
-
-  childState(address: Address) {
-    return this.options.childStates?.[address]
-  }
-
-  removeResolver(_resolver: ModuleResolver): this {
-    throw new Error('Not supported')
-  }
-
-  /** @deprecated do not pass undefined.  If trying to get all, pass '*' */
-  async resolve(): Promise<ModuleInstance[]>
-  async resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>
-  async resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
-  // eslint-disable-next-line complexity
-  async resolve<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options?: ModuleFilterOptions<T>,
-  ): Promise<T | T[] | undefined> {
-    // console.log(`childAddressMap: ${toSafeJsonString(this.childAddressMap, 10)}`)
-    const direction = options?.direction ?? 'all'
-    if (id === '*') {
-      // get all the child addresses.  if they have been resolved before, they should be in downResolver
-      const childAddresses = Object.keys(this.childAddressMap)
-      const resolvedChildren = await Promise.all(childAddresses.map<Promise<T | undefined>>(address => this.resolve<T>(address, options)))
-      return resolvedChildren.filter(exists)
-    } else if (typeof id === 'string') {
-      const idParts = id.split(':')
-      const firstPart: ModuleIdentifier = assertEx(idParts.shift(), () => 'Invalid module identifier at first position')
-      const firstPartAddress = await this.resolveIdentifier(firstPart)
-      if (firstPartAddress) {
-        const remainingParts = idParts.length > 0 ? idParts.join(':') : undefined
-        if (direction === 'down' || direction === 'all') {
-          const downResolverModule = await this.downResolver.resolve<T>(firstPartAddress)
-          if (downResolverModule) {
-            return remainingParts ? downResolverModule.resolve(remainingParts, options) : downResolverModule
-          }
-
-          console.log(`ModuleProxyResolver: ${firstPartAddress} | ${this.root.address}`)
-          if (firstPartAddress === this.root.address) {
-            const wrapped = wrapModuleWithType(this.root, await Account.random()) as unknown as T
-            return remainingParts ? wrapped?.resolve(remainingParts, options) : wrapped
-          }
-
-          // if it is a known child, create a proxy
-          const addressToProxy
-            = Object.keys(this.childAddressMap).includes(firstPartAddress as Address)
-              ? (firstPartAddress as Address)
-              : (Object.entries(this.childAddressMap).find(([_, value]) => value === firstPartAddress)?.[0] as Address | undefined)
-          if (addressToProxy) {
-            const proxy = await this.host.resolve(addressToProxy, { ...options, direction: 'down' })
-            if (proxy) {
-              const wrapped = wrapModuleWithType(proxy, await Account.random()) as unknown as T
-              return remainingParts ? wrapped?.resolve(remainingParts, options) : wrapped
-            }
-            return
-          }
-        }
-      }
-      return
-    }
-  }
-
-  resolveIdentifier(id: ModuleIdentifier, _options?: ObjectFilterOptions): Promisable<Address | undefined> {
-    // check if any of the modules have the id as an address
-    if (this.childAddressMap[id as Address]) {
-      return id as Address
-    }
-
-    if (this.root.address === id) {
-      return this.root.address
-    }
-
-    if (this.root.modName === id) {
-      return this.root.address
-    }
-
-    // check if id is a name of one of modules in the resolver
-    const addressFromName = Object.entries(this.childAddressMap).find(([, name]) => name === id)?.[0] as Address | undefined
-    if (addressFromName) {
-      return addressFromName
-    }
-  }
-
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ObjectFilterOptions<T>): Promise<T[]>
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | undefined>
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier,
-    _options?: ObjectFilterOptions<T>,
-  ): Promise<T | T[] | undefined> {
-    if (id === '*') return await Promise.resolve([])
-  }
-}

package/src/AbstractModuleProxy/index.ts

@@ -1,2 +0,0 @@
-export * from './AbstractModuleProxy.ts'
-export * from './ModuleProxyResolver.ts'

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from './AbstractBridge.ts'
-export * from './AbstractBridgeModuleResolver.ts'
-export * from './AbstractModuleProxy/index.ts'
-export * from './wrapModuleWithType.ts'

package/src/wrapModuleWithType.ts

@@ -1,32 +0,0 @@
-import type { AccountInstance } from '@xyo-network/account-model'
-import { isArchivistModule } from '@xyo-network/archivist-model'
-import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
-import { isDivinerModule } from '@xyo-network/diviner-model'
-import { DivinerWrapper } from '@xyo-network/diviner-wrapper'
-import type { QueryableModule } from '@xyo-network/module-model'
-import type { ModuleWrapper } from '@xyo-network/module-wrapper'
-import { isNodeModule } from '@xyo-network/node-model'
-import { NodeWrapper } from '@xyo-network/node-wrapper'
-import { isSentinelModule } from '@xyo-network/sentinel-model'
-import { SentinelWrapper } from '@xyo-network/sentinel-wrapper'
-import { isWitnessModule } from '@xyo-network/witness-model'
-import { WitnessWrapper } from '@xyo-network/witness-wrapper'
-
-export const wrapModuleWithType = (mod: QueryableModule, account: AccountInstance): ModuleWrapper => {
-  if (isArchivistModule(mod)) {
-    return ArchivistWrapper.wrap(mod, account)
-  }
-  if (isDivinerModule(mod)) {
-    return DivinerWrapper.wrap(mod, account)
-  }
-  if (isNodeModule(mod)) {
-    return NodeWrapper.wrap(mod, account)
-  }
-  if (isSentinelModule(mod)) {
-    return SentinelWrapper.wrap(mod, account)
-  }
-  if (isWitnessModule(mod)) {
-    return WitnessWrapper.wrap(mod, account)
-  }
-  throw 'Failed to wrap'
-}