@xyo-network/module-abstract 5.3.20 → 5.3.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/module-abstract",
-  "version": "5.3.20",
+  "version": "5.3.24",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,45 +30,72 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
-    "!**/*.test.*"
+    "!**/*.test.*",
+    "README.md"
   ],
   "dependencies": {
-    "@xyo-network/account": "~5.3.20",
-    "@xyo-network/account-model": "~5.3.20",
-    "@xyo-network/archivist-model": "~5.3.20",
-    "@xyo-network/boundwitness-builder": "~5.3.20",
-    "@xyo-network/boundwitness-model": "~5.3.20",
-    "@xyo-network/boundwitness-wrapper": "~5.3.20",
-    "@xyo-network/config-payload-plugin": "~5.3.20",
-    "@xyo-network/manifest-model": "~5.3.20",
-    "@xyo-network/module-model": "~5.3.20",
-    "@xyo-network/module-resolver": "~5.3.20",
-    "@xyo-network/node-model": "~5.3.20",
-    "@xyo-network/payload-builder": "~5.3.20",
-    "@xyo-network/payload-model": "~5.3.20",
-    "@xyo-network/query-payload-plugin": "~5.3.20",
-    "@xyo-network/wallet-model": "~5.3.20",
     "async-mutex": "~0.5.0",
-    "lru-cache": "^11.2.7"
+    "lru-cache": "~11.2.7",
+    "@xyo-network/account-model": "~5.3.24",
+    "@xyo-network/account": "~5.3.24",
+    "@xyo-network/boundwitness-wrapper": "~5.3.24",
+    "@xyo-network/archivist-model": "~5.3.24",
+    "@xyo-network/boundwitness-model": "~5.3.24",
+    "@xyo-network/config-payload-plugin": "~5.3.24",
+    "@xyo-network/module-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/query-payload-plugin": "~5.3.24",
+    "@xyo-network/boundwitness-builder": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24",
+    "@xyo-network/wallet-model": "~5.3.24",
+    "@xyo-network/payload-builder": "~5.3.24"
   },
   "devDependencies": {
-    "@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",
+    "@opentelemetry/api": "^1.9.1",
+    "@types/node": "^25.5.0",
+    "@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",
+    "@xylabs/vitest-extended": "~5.0.93",
+    "acorn": "^8.16.0",
+    "async-mutex": "~0.5.0",
+    "axios": "^1.14.0",
+    "esbuild": "^0.28.0",
+    "ethers": "^6.16.0",
+    "lru-cache": "~11.2.7",
+    "tslib": "^2.8.1",
     "typescript": "~5.9.3",
+    "vite": "^8.0.3",
     "vitest": "~4.1.2",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@xyo-network/account": "~5.3.24",
+    "@xyo-network/account-model": "~5.3.24",
+    "@xyo-network/archivist-model": "~5.3.24",
+    "@xyo-network/boundwitness-builder": "~5.3.24",
+    "@xyo-network/manifest-model": "~5.3.24",
+    "@xyo-network/boundwitness-model": "~5.3.24",
+    "@xyo-network/boundwitness-wrapper": "~5.3.24",
+    "@xyo-network/config-payload-plugin": "~5.3.24",
+    "@xyo-network/module-resolver": "~5.3.24",
+    "@xyo-network/node-model": "~5.3.24",
+    "@xyo-network/module-model": "~5.3.24",
+    "@xyo-network/payload-builder": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24",
+    "@xyo-network/query-payload-plugin": "~5.3.24",
+    "@xyo-network/wallet-model": "~5.3.24"
   },
   "peerDependencies": {
     "@xylabs/sdk-js": "^5",
+    "ethers": "^6",
+    "tslib": "^2.8.1",
     "zod": "^4"
   },
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/AbstractModule.ts

@@ -1,672 +0,0 @@
-/* eslint-disable max-lines */
-import type {
-  Address, CreatableInstance, Hash, Logger,
-  Promisable,
-} from '@xylabs/sdk-js'
-import {
-  AbstractCreatable,
-  assertEx,
-  ConsoleLogger, exists,
-  forget,
-  globallyUnique,
-  handleErrorAsync,
-  IdLogger,
-  isDefined, isObject, isString, isUndefined, LevelLogger,
-  LogLevel,
-  PromiseEx,
-} from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
-import { type AccountInstance, isAccountInstance } from '@xyo-network/account-model'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import { asArchivistInstance } from '@xyo-network/archivist-model'
-import { BoundWitnessBuilder, QueryBoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
-import type { BoundWitness, QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { isQueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import type { ConfigPayload } from '@xyo-network/config-payload-plugin'
-import { ConfigSchema } from '@xyo-network/config-payload-plugin'
-import type { ModuleManifestPayload } from '@xyo-network/manifest-model'
-import type {
-  AddressPayload,
-  AddressPreviousHashPayload,
-  ArchivingModuleConfig,
-  AttachableModuleInstance,
-  CreatableModule,
-  CreatableModuleFactory,
-  CreatableModuleInstance,
-  Labels,
-  ModuleBusyEventArgs,
-  ModuleConfig,
-  ModuleDescriptionPayload,
-  ModuleDetailsError,
-  ModuleEventData,
-  ModuleManifestQuery,
-  ModuleQueriedEventArgs,
-  ModuleQueries,
-  ModuleQueryHandlerResult,
-  ModuleQueryResult,
-  ModuleResolverInstance,
-  QueryableModule,
-  QueryableModuleParams,
-} from '@xyo-network/module-model'
-import {
-  AddressPreviousHashSchema,
-  AddressSchema,
-  creatableModule,
-  DeadModuleError,
-  isModuleName,
-  isSerializable,
-  ModuleAddressQuerySchema,
-  ModuleConfigSchema,
-  ModuleDescriptionSchema,
-  ModuleFactory,
-  ModuleManifestQuerySchema,
-  ModuleStateQuerySchema,
-  ModuleSubscribeQuerySchema,
-  ObjectResolverPriority,
-} from '@xyo-network/module-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import {
-  asSchema,
-  type ModuleError, type Payload, type Query, type Schema,
-} from '@xyo-network/payload-model'
-import { QuerySchema } from '@xyo-network/query-payload-plugin'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import { Mutex } from 'async-mutex'
-import { LRUCache } from 'lru-cache'
-
-import { determineAccount } from './determineAccount.ts'
-import { ModuleErrorBuilder } from './Error.ts'
-import type { Queryable } from './QueryValidator/index.ts'
-import { ModuleConfigQueryValidator, SupportedQueryValidator } from './QueryValidator/index.ts'
-
-export const DefaultModuleQueries = [ModuleAddressQuerySchema, ModuleSubscribeQuerySchema, ModuleManifestQuerySchema, ModuleStateQuerySchema]
-
-creatableModule()
-export abstract class AbstractModule<TParams extends QueryableModuleParams = QueryableModuleParams, TEventData extends ModuleEventData = ModuleEventData>
-  extends AbstractCreatable<TParams, TEventData>
-  implements QueryableModule<TParams, TEventData> {
-  static readonly allowRandomAccount: boolean = true
-  static readonly configSchemas: Schema[] = [ModuleConfigSchema]
-  static readonly defaultConfigSchema: Schema = ModuleConfigSchema
-  // eslint-disable-next-line sonarjs/public-static-readonly
-  static override defaultLogger: Logger = new ConsoleLogger(LogLevel.warn)
-  // eslint-disable-next-line sonarjs/public-static-readonly
-  static enableLazyLoad = false
-  static readonly labels: Labels = {}
-  static readonly uniqueName = globallyUnique('AbstractModule', AbstractModule, 'xyo')
-
-  protected static privateConstructorKey = Date.now().toString()
-
-  protected _account: AccountInstance | undefined
-
-  // cache manifest based on maxDepth
-  protected _cachedManifests = new LRUCache<number, ModuleManifestPayload>({ max: 10, ttl: 1000 * 60 * 5 })
-
-  protected _globalReentrancyMutex: Mutex | undefined
-
-  protected _lastError?: ModuleDetailsError
-
-  protected _moduleConfigQueryValidator: Queryable | undefined
-  protected _supportedQueryValidator: Queryable | undefined
-
-  private _busyCount = 0
-  private _logger: Logger | undefined | null = undefined
-
-  get account() {
-    return assertEx(this._account, () => 'Missing account')
-  }
-
-  get additionalSigners(): AccountInstance[] {
-    return this.params.additionalSigners ?? []
-  }
-
-  get address() {
-    return this.account.address
-  }
-
-  get allowAnonymous() {
-    return !!this.config.security?.allowAnonymous
-  }
-
-  get allowNameResolution() {
-    return this.params.allowNameResolution ?? true
-  }
-
-  get archiving(): ArchivingModuleConfig['archiving'] | undefined {
-    return this.config.archiving
-  }
-
-  get archivist() {
-    return this.config.archivist
-  }
-
-  get config(): TParams['config'] & { schema: Schema } {
-    return { ...this.params.config, schema: this.params.config.schema ?? ModuleConfigSchema }
-  }
-
-  get dead() {
-    return this.status === 'error'
-  }
-
-  get ephemeralQueryAccountEnabled(): boolean {
-    return !!this.params.ephemeralQueryAccountEnabled
-  }
-
-  get globalReentrancyMutex() {
-    this._globalReentrancyMutex = this._globalReentrancyMutex ?? (this.reentrancy?.scope === 'global' ? new Mutex() : undefined)
-    return this._globalReentrancyMutex
-  }
-
-  get id() {
-    return this.modName ?? this.address
-  }
-
-  override get logger() {
-    // we use null to prevent a second round of not creating a logger
-    if (isUndefined(this._logger)) {
-      const logLevel = this.config.logLevel
-      const newLogger = this._logger ?? (this.params?.logger ? new IdLogger(this.params.logger, () => `${this.constructor.name}[${this.id}]`) : null)
-      this._logger = (isObject(newLogger) && isDefined(logLevel)) ? new LevelLogger(newLogger, logLevel) : newLogger
-    }
-    return this._logger ?? undefined
-  }
-
-  get modName() {
-    return this.config.name
-  }
-
-  get priority() {
-    return ObjectResolverPriority.Normal
-  }
-
-  get queries(): Schema[] {
-    return [...DefaultModuleQueries]
-  }
-
-  get reentrancy() {
-    return this.config.reentrancy
-  }
-
-  override get statusReporter() {
-    return this.params.statusReporter
-  }
-
-  get timestamp() {
-    return this.config.timestamp ?? false
-  }
-
-  protected get moduleConfigQueryValidator(): Queryable {
-    return assertEx(this._moduleConfigQueryValidator, () => 'ModuleConfigQueryValidator not initialized')
-  }
-
-  protected get supportedQueryValidator(): Queryable {
-    return assertEx(this._supportedQueryValidator, () => 'SupportedQueryValidator not initialized')
-  }
-
-  abstract get downResolver(): ModuleResolverInstance
-
-  abstract get upResolver(): ModuleResolverInstance
-
-  static _getRootFunction(funcName: string) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let anyThis = this as any
-    while (anyThis.__proto__[funcName]) {
-      anyThis = anyThis.__proto__
-    }
-    return anyThis[funcName]
-  }
-
-  static _noOverride(functionName: string) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const thisFunc = (this as any)[functionName]
-
-    const rootFunc = this._getRootFunction(functionName)
-    assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`)
-  }
-
-  static override async createHandler<T extends CreatableInstance>(
-    inInstance: T,
-  ) {
-    const instance = (await super.createHandler(inInstance))
-    if (instance instanceof AbstractModule) {
-      if (this.configSchemas.length === 0) {
-        throw new Error(`No allowed config schemas for [${this.name}]`)
-      }
-
-      const schema: Schema = instance.config.schema ?? this.defaultConfigSchema
-      const allowedSchemas: Schema[] = this.configSchemas
-
-      assertEx(this.isAllowedSchema(schema), () => `Bad Config Schema [Received ${schema}] [Expected ${JSON.stringify(allowedSchemas)}]`)
-    } else {
-      throw new TypeError(`Invalid instance type [${instance.constructor.name}] for [${this.name}]`)
-    }
-
-    return instance
-  }
-
-  static async determineAccount(params: {
-    account?: AccountInstance | 'random'
-    accountPath?: string
-    wallet?: WalletInstance
-  }): Promise<AccountInstance> {
-    return await determineAccount(params, this.allowRandomAccount)
-  }
-
-  static factory<TModule extends CreatableModuleInstance>(
-    this: CreatableModule<TModule>,
-    params?: Partial<TModule['params']>,
-  ): CreatableModuleFactory<TModule> {
-    return ModuleFactory.withParams<TModule>(this, params)
-  }
-
-  static isAllowedSchema(schema: Schema): boolean {
-    return this.configSchemas.includes(schema)
-  }
-
-  static override async paramsHandler<T extends AttachableModuleInstance<QueryableModuleParams, ModuleEventData>>(
-    inParams: Partial<T['params']> = {},
-  ) {
-    const superParams = await super.paramsHandler(inParams)
-    const params = {
-      ...superParams,
-      account: await this.determineAccount(superParams),
-      config: { schema: this.defaultConfigSchema, ...superParams.config },
-      logger: superParams.logger ?? this.defaultLogger,
-    } as T['params']
-    return params
-  }
-
-  // eslint-disable-next-line sonarjs/no-identical-functions
-  _getRootFunction(funcName: string) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let anyThis = this as any
-    while (anyThis.__proto__[funcName]) {
-      anyThis = anyThis.__proto__
-    }
-    return anyThis[funcName]
-  }
-
-  async busy<R>(closure: () => Promise<R>) {
-    if (this._busyCount <= 0) {
-      this._busyCount = 0
-      const args: ModuleBusyEventArgs = { busy: true, mod: this }
-      await this.emit('moduleBusy', args)
-    }
-    this._busyCount++
-    try {
-      return await closure()
-    } finally {
-      this._busyCount--
-      if (this._busyCount <= 0) {
-        this._busyCount = 0
-        const args: ModuleBusyEventArgs = { busy: false, mod: this }
-        await this.emit('moduleBusy', args)
-      }
-    }
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    assertEx(this.name === undefined || isModuleName(this.name), () => `Invalid module name: ${this.name}`)
-
-    if (this.params.account === 'random') {
-      this._account = await Account.random()
-    } else if (isAccountInstance(this.params.account)) {
-      this._account = this.params.account
-    }
-
-    assertEx(isAccountInstance(this._account), () => `Invalid account instance: ${this._account}`)
-
-    this._supportedQueryValidator = new SupportedQueryValidator(this as QueryableModule).queryable
-    this._moduleConfigQueryValidator = new ModuleConfigQueryValidator(this.config).queryable
-
-    if (!AbstractModule.enableLazyLoad) {
-      setTimeout(() => forget(this.start()), 200)
-    }
-  }
-
-  override emit<TEventName extends keyof TEventData = keyof TEventData, TEventArgs extends TEventData[TEventName] = TEventData[TEventName]>(
-    eventName: TEventName,
-    eventArgs: TEventArgs,
-  ) {
-    return super.emit(eventName, eventArgs)
-  }
-
-  isSupportedQuery(query: Schema, assert: boolean | string = false): boolean {
-    // check if ever supported
-    if (!this.queries.includes(query)) {
-      if (assert !== false) {
-        assertEx(false, () => `Query not supported [${isString(assert) ? assert : query}] on [${this.modName}, ${this.address}] (queries list)`)
-      }
-      return false
-    }
-    // check if config allows it
-    const supported = Array.isArray(this.config.allowedQueries) ? this.config.allowedQueries.includes(query) : true
-    if (assert !== false) {
-      assertEx(supported, () => `Query not supported [${isString(assert) ? assert : query}] on [${this.modName}, ${this.address}] (config)`)
-    }
-    return supported
-  }
-
-  previousHash(): Promisable<string | undefined> {
-    this._checkDead()
-    return this.account.previousHash
-  }
-
-  async query<T extends QueryBoundWitness = QueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(
-    query: T,
-    payloads?: Payload[],
-    queryConfig?: TConfig,
-  ): Promise<ModuleQueryResult> {
-    this._checkDead()
-    this._noOverride('query')
-    return await this.spanAsync('query', async () => {
-      const sourceQuery = assertEx(isQueryBoundWitness(query) ? query : undefined, () => 'Unable to parse query')
-      return await this.busy(async () => {
-        const resultPayloads: Payload[] = []
-        const errorPayloads: ModuleError[] = []
-        const queryAccount = this.ephemeralQueryAccountEnabled ? await Account.random() : undefined
-
-        try {
-          await this.startedAsync('throw')
-          if (!this.allowAnonymous && query.addresses.length === 0) {
-            throw new Error(`Anonymous Queries not allowed, but running anyway [${this.modName}], [${this.address}]`)
-          }
-          if (queryConfig?.allowedQueries) {
-            assertEx(queryConfig?.allowedQueries.includes(sourceQuery.schema), () => `Query not allowed [${sourceQuery.schema}]`)
-          }
-          resultPayloads.push(...(await this.queryHandler(sourceQuery, payloads, queryConfig)))
-        } catch (ex) {
-          await handleErrorAsync(ex, async (err) => {
-            const error = err as ModuleDetailsError
-            this._lastError = error
-            // this.status = 'dead'
-            errorPayloads.push(
-              new ModuleErrorBuilder()
-                .meta({ $sources: [await PayloadBuilder.dataHash(sourceQuery)] })
-                .name(this.modName ?? '<Unknown>')
-                .query(sourceQuery.schema)
-                .details(error.details)
-                .message(error.message)
-                .build(),
-            )
-          })
-        }
-        if (this.timestamp) {
-          const timestamp = { schema: asSchema('network.xyo.timestamp', true), timestamp: Date.now() }
-          resultPayloads.push(timestamp)
-        }
-        const result = await this.bindQueryResult(sourceQuery, resultPayloads, queryAccount ? [queryAccount] : [], errorPayloads)
-        const args: ModuleQueriedEventArgs = {
-          mod: this, payloads, query: sourceQuery, result,
-        }
-        await this.emit('moduleQueried', args)
-        return result
-      })
-    }, { timeBudgetLimit: 200 })
-  }
-
-  async queryable<T extends QueryBoundWitness = QueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(
-    query: T,
-    payloads?: Payload[],
-    queryConfig?: TConfig,
-  ): Promise<boolean> {
-    if (this.dead) {
-      return false
-    }
-    if (!(this.started('warn'))) return false
-    const configValidator
-      = queryConfig ? new ModuleConfigQueryValidator(Object.assign({}, this.config, queryConfig)).queryable : this.moduleConfigQueryValidator
-    const validators = [this.supportedQueryValidator, configValidator]
-
-    const results = await Promise.all(validators.map(validator => validator(query, payloads)))
-    for (const result of results) {
-      if (!result) {
-        return false
-      }
-    }
-    return true
-  }
-
-  protected _checkDead() {
-    if (this.dead) {
-      throw new DeadModuleError(this.id, this._lastError)
-    }
-  }
-
-  protected async archivistInstance(): Promise<ArchivistInstance | undefined>
-  protected async archivistInstance(required: true): Promise<ArchivistInstance>
-  protected async archivistInstance(required = false): Promise<ArchivistInstance | undefined> {
-    const archivist = this.archivist
-    if (isUndefined(archivist)) {
-      if (required) {
-        throw new Error('No archivist specified')
-      }
-      return undefined
-    }
-    const resolved = (await this.upResolver.resolve(archivist)) ?? (await this.downResolver.resolve(archivist))
-    if (required) {
-      assertEx(resolved, () => `Unable to resolve archivist [${archivist}]`)
-    }
-    return resolved ? asArchivistInstance(resolved, () => `Specified archivist is not an Archivist [${archivist}]`) : undefined
-  }
-
-  protected bindHashes(hashes: Hash[], schema: Schema[], account?: AccountInstance) {
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    return new PromiseEx((resolve) => {
-      const result = this.bindHashesInternal(hashes, schema, account)
-      resolve?.(result)
-      return result
-    }, account)
-  }
-
-  protected async bindHashesInternal(hashes: Hash[], schema: Schema[], account: AccountInstance = this.account): Promise<BoundWitness> {
-    const builder = new BoundWitnessBuilder().hashes(hashes, schema).signer(account)
-    const result: BoundWitness = (await builder.build())[0]
-    this.logger?.debug(`result: ${JSON.stringify(result, null, 2)}`)
-    return result
-  }
-
-  protected bindQuery<T extends Query>(
-    query: T,
-    payloads?: Payload[],
-    account?: AccountInstance,
-    additionalSigners?: AccountInstance[],
-  ): PromiseEx<[QueryBoundWitness, Payload[], Payload[]], AccountInstance> {
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    return new PromiseEx<[QueryBoundWitness, Payload[], Payload[]], AccountInstance>(async (resolve) => {
-      const result = await this.bindQueryInternal(query, payloads, account, additionalSigners)
-      resolve?.(result)
-      return result
-    }, account)
-  }
-
-  protected async bindQueryInternal<T extends Query>(
-    query: T,
-    payloads?: Payload[],
-    account: AccountInstance = this.account,
-    additionalSigners: AccountInstance[] = [],
-  ): Promise<[QueryBoundWitness, Payload[], Payload[]]> {
-    const accounts = [account, ...additionalSigners].filter(exists)
-    const builder = new QueryBoundWitnessBuilder().payloads(payloads).signers(accounts).query(query)
-
-    const [bw, payloadsOut, errors] = await builder.build()
-    return [bw, [...payloadsOut], errors]
-  }
-
-  protected async bindQueryResult<T extends Query>(
-    query: T,
-    payloads: Payload[],
-    additionalWitnesses: AccountInstance[] = [],
-    errors?: ModuleError[],
-  ): Promise<ModuleQueryResult> {
-    const queryDataHash = await PayloadBuilder.dataHash(query)
-    const builder = new BoundWitnessBuilder().payloads(payloads).errors(errors).sourceQuery(queryDataHash)
-    const witnesses = [this.account, ...additionalWitnesses].filter(exists)
-    builder.signers(witnesses)
-    const result = [
-      PayloadBuilder.omitPrivateStorageMeta((await builder.build())[0]),
-      PayloadBuilder.omitPrivateStorageMeta(payloads),
-      PayloadBuilder.omitPrivateStorageMeta(errors ?? []),
-    ] as ModuleQueryResult
-    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-      forget(this.storeToArchivists(result.flat()))
-    }
-    return result
-  }
-
-  protected generateConfigAndAddress(_maxDepth?: number): Promisable<Payload[]> {
-    const config = this.config
-    const address: AddressPayload = { schema: AddressSchema, address: this.address }
-    const queries = this.queries.map((query) => {
-      return { schema: QuerySchema, query }
-    })
-    const configSchema: ConfigPayload = {
-      config: config.schema,
-      schema: ConfigSchema,
-    }
-    return ([config, configSchema, address, ...queries]).filter(exists)
-  }
-
-  protected async generateDescribe(): Promise<ModuleDescriptionPayload> {
-    const description: ModuleDescriptionPayload = {
-      address: this.address,
-      name: this.modName ?? `Unnamed ${this.constructor.name}`,
-      queries: this.queries,
-      schema: ModuleDescriptionSchema,
-    }
-
-    const discover = await this.generateConfigAndAddress()
-
-    description.children = (
-      discover?.map((payload) => {
-        const address = payload.schema === AddressSchema ? (payload as AddressPayload).address : undefined
-        return address == this.address ? undefined : address
-      }) ?? []
-    ).filter(exists)
-
-    return description
-  }
-
-  /** @deprecated use archivistInstance() instead */
-  protected async getArchivist(): Promise<ArchivistInstance | undefined> {
-    return await this.archivistInstance()
-  }
-
-  protected isAllowedArchivingQuery(schema: Schema): boolean {
-    const queries = this.archiving?.queries
-    if (queries) {
-      return queries.includes(schema)
-    }
-    return true
-  }
-
-  protected manifestHandler(_maxDepth: number = 1, _ignoreAddresses: Address[] = []): Promisable<ModuleManifestPayload> {
-    throw new Error('Not supported')
-  }
-
-  protected moduleAddressHandler(): Promisable<(AddressPreviousHashPayload | AddressPayload)[]> {
-    const address = this.address
-    const name = this.modName
-    const previousHash = this.account.previousHash
-    const moduleAccount = isDefined(name)
-      ? {
-          address, name, schema: AddressSchema,
-        }
-      : { address, schema: AddressSchema }
-    const moduleAccountPreviousHash = isDefined(previousHash)
-      ? {
-          address, previousHash, schema: AddressPreviousHashSchema,
-        }
-      : { address, schema: AddressSchema }
-    return [moduleAccount, moduleAccountPreviousHash]
-  }
-
-  protected async queryHandler<T extends QueryBoundWitness = QueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(
-    query: T,
-    payloads?: Payload[],
-    queryConfig?: TConfig,
-  ): Promise<ModuleQueryHandlerResult> {
-    await this.startedAsync('throw')
-    const wrapper = QueryBoundWitnessWrapper.parseQuery<ModuleQueries>(query, payloads)
-    const queryPayload = await wrapper.getQuery()
-    assertEx(await this.queryable(query, payloads, queryConfig))
-    const resultPayloads: Payload[] = []
-    switch (queryPayload.schema) {
-      case ModuleManifestQuerySchema: {
-        const typedQueryPayload = queryPayload as ModuleManifestQuery
-        resultPayloads.push(await this.manifestHandler(typedQueryPayload.maxDepth))
-        break
-      }
-      case ModuleAddressQuerySchema: {
-        resultPayloads.push(...(await this.moduleAddressHandler()))
-        break
-      }
-      case ModuleStateQuerySchema: {
-        resultPayloads.push(...(await this.stateHandler()))
-        break
-      }
-      case ModuleSubscribeQuerySchema: {
-        this.subscribeHandler()
-        break
-      }
-      default: {
-        throw new Error(`Unsupported Query [${(queryPayload as Payload).schema}]`)
-      }
-    }
-    return PayloadBuilder.omitPrivateStorageMeta(resultPayloads) as ModuleQueryHandlerResult
-  }
-
-  protected override async startHandler(): Promise<void> {
-    this.validateConfig()
-    await super.startHandler()
-  }
-
-  protected async stateHandler(): Promise<Payload[]> {
-    return [await this.manifestHandler(), ...(await this.generateConfigAndAddress()), await this.generateDescribe()]
-  }
-
-  protected override async stopHandler(): Promise<void> {
-    await super.stopHandler()
-    this._startPromise = undefined
-  }
-
-  protected subscribeHandler() {
-    return
-  }
-
-  protected validateConfig(config?: unknown, parents: string[] = []): boolean {
-    // eslint-disable-next-line unicorn/no-array-reduce
-    return Object.entries(config ?? this.config ?? {}).reduce((valid, [key, value]) => {
-      switch (typeof value) {
-        case 'function': {
-          this.logger?.warn(`Fields of type function not allowed in config [${parents?.join('.')}.${key}]`)
-          return false
-        }
-        case 'object': {
-          if (Array.isArray(value)) {
-            return (
-              // eslint-disable-next-line unicorn/no-array-reduce
-              value.reduce((valid, value) => {
-                return this.validateConfig(value, [...parents, key]) && valid
-              }, true) && valid
-            )
-          }
-
-          if (!isSerializable(value)) {
-            this.logger?.warn(`Fields that are not serializable to JSON are not allowed in config [${parents?.join('.')}.${key}]`)
-            return false
-          }
-          return value ? this.validateConfig(value, [...parents, key]) && valid : true
-        }
-        default: {
-          return valid
-        }
-      }
-    }, true)
-  }
-
-  protected abstract certifyParents(): Promise<Payload[]>
-  protected abstract storeToArchivists(payloads: Payload[]): Promise<Payload[]>
-}

package/src/AbstractModuleInstance.ts

@@ -1,357 +0,0 @@
-import type {
-  Address, Promisable,
-  TypeCheck,
-  TypedValue,
-} from '@xylabs/sdk-js'
-import {
-  exists, globallyUnique, isDefined,
-} from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/account-model'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import { asArchivistInstance } from '@xyo-network/archivist-model'
-import type { ModuleManifestPayload } from '@xyo-network/manifest-model'
-import { ModuleManifestPayloadSchema } from '@xyo-network/manifest-model'
-import type {
-  AddressPayload,
-  AddressPreviousHashPayload,
-  AttachableModuleInstance,
-  ModuleEventData,
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleInstance,
-  ModuleInstanceParams,
-  ModuleManifestQuery,
-  ModuleName,
-  ModuleNameResolver,
-  ModuleQueryResult,
-  ModuleStateQuery,
-  ObjectFilterOptions,
-  ResolveHelperConfig,
-} from '@xyo-network/module-model'
-import {
-  duplicateModules,
-  ModuleManifestQuerySchema,
-  ModuleStateQuerySchema,
-  resolveAll,
-  resolveAllDown,
-  resolveAllUp,
-  ResolveHelper,
-  resolvePathToInstance,
-} from '@xyo-network/module-model'
-import { CompositeModuleResolver } from '@xyo-network/module-resolver'
-import type { NodeInstance } from '@xyo-network/node-model'
-import { asNodeInstance } from '@xyo-network/node-model'
-import type { Payload, Query } from '@xyo-network/payload-model'
-
-import { AbstractModule } from './AbstractModule.ts'
-
-function filterIdentity<T extends TypedValue>(mod?: ModuleInstance, identityFunc?: TypeCheck<T>): T
-function filterIdentity<T extends TypedValue>(mods?: ModuleInstance[], identityFunc?: TypeCheck<T>): T[]
-function filterIdentity<T extends TypedValue>(mod?: ModuleInstance | ModuleInstance[], identityFunc?: TypeCheck<T>) {
-  if (Array.isArray(mod)) {
-    if (identityFunc) {
-      return mod.map(m => identityFunc(m)).filter(exists)
-    }
-    return mod
-  }
-  return (mod ? (identityFunc ? identityFunc(mod) : true) : false) ? mod : undefined
-}
-
-export abstract class AbstractModuleInstance<TParams extends ModuleInstanceParams = ModuleInstanceParams, TEventData extends ModuleEventData = ModuleEventData>
-  extends AbstractModule<TParams, TEventData>
-  implements AttachableModuleInstance<TParams, TEventData>, ModuleNameResolver {
-  static override readonly uniqueName = globallyUnique('AbstractModuleInstance', AbstractModuleInstance, 'xyo')
-
-  // switches between old and new resolution system
-  static readonly useNewResolver = false
-
-  private _downResolver?: CompositeModuleResolver
-  private _parents: NodeInstance[] = []
-  private _privateResolver?: CompositeModuleResolver
-  private _upResolver?: CompositeModuleResolver
-
-  get downResolver() {
-    this._downResolver
-      = this._downResolver
-        ?? new CompositeModuleResolver({
-          allowNameResolution: this.allowNameResolution,
-          moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-          root: this,
-        })
-    return this._downResolver
-  }
-
-  override get modName() {
-    return super.modName
-  }
-
-  get moduleIdentifierTransformers() {
-    return this.params.moduleIdentifierTransformers ?? ResolveHelper.transformers
-  }
-
-  get privateResolver() {
-    this._privateResolver
-      = this._privateResolver
-        ?? new CompositeModuleResolver({
-          allowNameResolution: this.allowNameResolution,
-          moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-          root: this,
-        })
-    return this._privateResolver
-  }
-
-  get root() {
-    return this
-  }
-
-  get timeBudget() {
-    return this.config.timeBudget
-  }
-
-  get upResolver() {
-    this._upResolver
-      = this._upResolver
-        ?? new CompositeModuleResolver({
-          allowNameResolution: this.allowNameResolution,
-          moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-          root: this,
-        })
-    return this._upResolver
-  }
-
-  addParent(mod: ModuleInstance) {
-    const existingEntry = this._parents.find(parent => parent.address === mod.address)
-    if (!existingEntry) {
-      this._parents.push(asNodeInstance(mod, 'Only NodeInstances can be parents', { required: true }))
-    }
-  }
-
-  async certifyParents(): Promise<Payload[]> {
-    const parents = await this.parents()
-    return (
-      await Promise.all(
-        parents.map(async (parent) => {
-          const [bw, payloads, errors] = await parent.certifyQuery(this.address)
-          return errors.length === 0 ? [bw, ...payloads] : []
-        }),
-      )
-    ).flat()
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    const addToResolvers = this.params.addToResolvers ?? true
-    if (addToResolvers) {
-      this.upResolver.add(this)
-      this.downResolver.add(this)
-    }
-  }
-
-  manifest(maxDepth?: number): Promise<ModuleManifestPayload> {
-    this._checkDead()
-    return this.busy(async () => {
-      return await this.manifestHandler(maxDepth)
-    })
-  }
-
-  async manifestQuery(account: AccountInstance, maxDepth?: number): Promise<ModuleQueryResult<ModuleManifestPayload>> {
-    const queryPayload: ModuleManifestQuery = { schema: ModuleManifestQuerySchema, ...(maxDepth === undefined ? {} : { maxDepth }) }
-    return await this.sendQueryRaw<ModuleManifestQuery, Payload, ModuleManifestPayload>(queryPayload, undefined, account)
-  }
-
-  moduleAddress(): Promise<(AddressPayload | AddressPreviousHashPayload)[]> {
-    this._checkDead()
-    return this.busy(async () => {
-      return await this.moduleAddressHandler()
-    })
-  }
-
-  parents(): Promisable<NodeInstance[]> {
-    return this._parents
-  }
-
-  privateChildren(): Promisable<ModuleInstance[]> {
-    return [...this.params.privateChildren ?? []]
-  }
-
-  publicChildren(): Promisable<ModuleInstance[]> {
-    return [...this.params.publicChildren ?? []]
-  }
-
-  removeParent(address: Address) {
-    this._parents = this._parents.filter(item => item.address !== address)
-  }
-
-  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>
-  async resolve<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options: ModuleFilterOptions<T> = {},
-  ): Promise<T | T[] | undefined> {
-    if (AbstractModuleInstance.useNewResolver) {
-      if (id === '*') {
-        const { maxDepth = 10, direction } = options
-        if (direction === 'down') {
-          return filterIdentity<T>((await resolveAllDown(this, maxDepth)) ?? [], options.identity)
-        }
-        if (direction === 'up') {
-          return filterIdentity<T>(await resolveAllUp(this, maxDepth) ?? [], options.identity)
-        }
-        return filterIdentity<T>(await resolveAll(this, maxDepth) ?? [], options.identity)
-      } else if (typeof id === 'string') {
-        return filterIdentity<T>(await resolvePathToInstance(this, id, true), options.identity)
-      } else {
-        throw new TypeError('Invalid id type')
-      }
-    } else {
-      const config: ResolveHelperConfig = {
-        address: this.address,
-        dead: this.dead,
-        downResolver: this.downResolver,
-        logger: this.logger,
-        mod: this,
-        transformers: this.moduleIdentifierTransformers,
-        upResolver: this.upResolver,
-      }
-      if (id === '*') {
-        return filterIdentity<T>(await ResolveHelper.resolve(config, '*', options) ?? [], options.identity)
-      }
-      return filterIdentity<T>(await ResolveHelper.resolve(config, id, options), options.identity)
-    }
-  }
-
-  resolveIdentifier(id: ModuleIdentifier, options?: ObjectFilterOptions): Promise<Address | undefined> {
-    const { direction = 'all' } = options ?? {}
-    switch (direction) {
-      case 'down': {
-        return this.downResolver.resolveIdentifier(id, options)
-      }
-      default: {
-        const mutatedOptions = { ...options, direction: 'all' } as ObjectFilterOptions
-        return this.upResolver.resolveIdentifier(id, mutatedOptions)
-      }
-    }
-  }
-
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options: ModuleFilterOptions<T> = {},
-  ): Promise<T | T[] | undefined> {
-    return (
-      (await this.privateResolver.resolve(id, options))
-      ?? (await this.upResolver.resolve(id, options))
-      ?? (await this.downResolver.resolve(id, options))
-    )
-  }
-
-  async siblings(): Promise<ModuleInstance[]> {
-    return (await Promise.all((await this.parents()).map(parent => parent.publicChildren()))).flat().filter(duplicateModules)
-  }
-
-  state() {
-    this._checkDead()
-    return this.busy(async () => {
-      return await this.stateHandler()
-    })
-  }
-
-  async stateQuery(account: AccountInstance): Promise<ModuleQueryResult> {
-    const queryPayload: ModuleStateQuery = { schema: ModuleStateQuerySchema }
-    return await this.sendQueryRaw(queryPayload, undefined, account)
-  }
-
-  subscribe(_queryAccount?: AccountInstance) {
-    this._checkDead()
-    return this.subscribeHandler()
-  }
-
-  protected override async manifestHandler(maxDepth: number = 1, _ignoreAddresses: Address[] = []): Promise<ModuleManifestPayload> {
-    const cachedResult = this._cachedManifests.get(maxDepth)
-    if (cachedResult) {
-      return cachedResult
-    }
-    const modName = this.modName ?? '<Anonymous>'
-    const children = await this.publicChildren()
-    const childAddressToName: Record<Address, ModuleName | null> = {}
-    for (const child of children) {
-      if (child.address !== this.address) {
-        childAddressToName[child.address] = child.modName ?? null
-      }
-    }
-    const result = {
-      config: { name: modName, ...this.config },
-      name: modName,
-      schema: ModuleManifestPayloadSchema,
-      status: { address: this.address, children: childAddressToName },
-    }
-    this._cachedManifests.set(maxDepth, result)
-    return result
-  }
-
-  protected async resolveArchivingArchivists(): Promise<ArchivistInstance[]> {
-    const archivists = this.archiving?.archivists
-    if (!archivists) return []
-    const resolved = await Promise.all(archivists.map(archivist => this.resolve(archivist)))
-    return (resolved.map(mod => asArchivistInstance(mod))).filter(exists)
-  }
-
-  protected async sendQuery<T extends Query, P extends Payload = Payload, R extends Payload = Payload>(
-    queryPayload: T,
-    payloads?: P[],
-    account?: AccountInstance,
-  ): Promise<R[]> {
-    const queryResults = await this.sendQueryRaw(queryPayload, payloads, account)
-    const [, resultPayloads, errors] = queryResults
-
-    /* TODO: Figure out what to do with the returning BW.  Should we store them in a queue in case the caller wants to see them? */
-
-    if (isDefined(errors) && errors.length > 0) {
-      /* TODO: Figure out how to rollup multiple Errors */
-      throw errors[0]
-    }
-
-    return resultPayloads as R[]
-  }
-
-  protected async sendQueryRaw<T extends Query, P extends Payload = Payload, R extends Payload = Payload>(
-    queryPayload: T,
-    payloads?: P[],
-    account?: AccountInstance,
-  ): Promise<ModuleQueryResult<R>> {
-    // Bind them
-    const query = await this.bindQuery(queryPayload, payloads, account, this.additionalSigners)
-
-    // Send them off
-    return (await this.query(query[0], query[1])) as ModuleQueryResult<R>
-  }
-
-  protected override startHandler() {
-    this._checkDead()
-    return this.busy(async () => {
-      if (this.status === 'started' || this.status === 'creating') {
-        return
-      }
-      await super.startHandler()
-    })
-  }
-
-  protected async storeToArchivists(payloads: Payload[]): Promise<Payload[]> {
-    try {
-      const archivists = await this.resolveArchivingArchivists()
-      return (
-        await Promise.all(
-          archivists.map((archivist) => {
-            return archivist.insert?.(payloads)
-          }),
-        )
-      ).map(([bw]) => bw)
-    } catch (ex) {
-      const error = ex as Error
-      this.logger?.error(`Error storing to archivists: ${error.message}`)
-      return []
-    }
-  }
-}

package/src/Error.ts

@@ -1,44 +0,0 @@
-import type { Hash, JsonValue } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { ModuleError, Schema } from '@xyo-network/payload-model'
-import { ModuleErrorSchema } from '@xyo-network/payload-model'
-
-export class ModuleErrorBuilder extends PayloadBuilder<ModuleError> {
-  _details?: JsonValue
-  _message?: string
-  _name?: string
-  _query?: Hash | Schema
-  constructor() {
-    super({ schema: ModuleErrorSchema })
-  }
-
-  override build(): ModuleError {
-    this.fields({
-      details: this._details,
-      message: this._message,
-      name: this._name,
-      query: this._query,
-    })
-    return super.build()
-  }
-
-  details(details?: JsonValue) {
-    this._details = details
-    return this
-  }
-
-  message(message: string) {
-    this._message = message
-    return this
-  }
-
-  name(name: string) {
-    this._name = name
-    return this
-  }
-
-  query(query: Hash | Schema) {
-    this._query = query
-    return this
-  }
-}

package/src/LoggerModuleStatusReporter.ts

@@ -1,21 +0,0 @@
-import type {
-  CreatableName, CreatableStatus, Logger,
-} from '@xylabs/sdk-js'
-import type { ModuleStatusReporter } from '@xyo-network/module-model'
-
-export class LoggerModuleStatusReporter implements ModuleStatusReporter {
-  protected logger: Logger
-
-  protected statusMap: Record<CreatableName, CreatableStatus> = {}
-
-  constructor(logger: Logger) {
-    this.logger = logger
-  }
-
-  report(name: CreatableName, status: CreatableStatus, progress?: number | Error): void {
-    this.statusMap[name] = status
-    const starting = (Object.entries(this.statusMap).map(([, value]): number => value === 'starting' ? 1 : 0)).reduce((a, b) => a + b, 0)
-    const started = (Object.entries(this.statusMap).map(([, value]): number => value === 'started' ? 1 : 0)).reduce((a, b) => a + b, 0)
-    this.logger.log(`${started}/${starting + started} ${name} status: ${status}`, { progress })
-  }
-}

package/src/QueryValidator/ModuleConfigQueryValidator.ts

@@ -1,75 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import type {
-  AnyConfigSchema, CosigningAddressSet, ModuleConfig, ModuleQueries,
-} from '@xyo-network/module-model'
-import { asSchema, type Schema } from '@xyo-network/payload-model'
-
-import type { Queryable, QueryValidator } from './QueryValidator.ts'
-
-export type SortedPipedAddressesString = string
-
-const delimiter = ''
-
-export class ModuleConfigQueryValidator<TConfig extends AnyConfigSchema<ModuleConfig>> implements QueryValidator {
-  protected allowed: Record<Schema, SortedPipedAddressesString[]> = {}
-  protected disallowed: Record<Schema, SortedPipedAddressesString[]> = {}
-  protected readonly hasAllowedRules: boolean
-  protected readonly hasDisallowedRules: boolean
-  protected readonly hasRules: boolean
-
-  constructor(config?: TConfig) {
-    if (config?.security?.allowed) {
-      for (const [schema, addresses] of Object.entries(config.security?.allowed)) {
-        const typedSchema = asSchema(schema, true)
-        this.allowed[typedSchema] = addresses.map(toAddressesString)
-      }
-    }
-    if (config?.security?.disallowed) {
-      for (const [schema, addresses] of Object.entries(config.security?.disallowed)) {
-        const typedSchema = asSchema(schema, true)
-        this.disallowed[typedSchema] = 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 = async (query, payloads) => {
-    if (!this.hasRules) return true
-    const addresses = query.addresses
-    if (addresses.length === 0) return false
-    const wrapper = QueryBoundWitnessWrapper.parseQuery<ModuleQueries>(query, payloads)
-    const schema = (await wrapper.getQuery()).schema
-    return this.queryAllowed(schema, addresses) && !this.queryDisallowed(schema, addresses)
-  }
-
-  protected queryAllowed = (schema: Schema, addresses: Address[]): 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: Schema, 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
-        // eslint-disable-next-line sonarjs/no-alphabetical-sort
-        .toSorted()
-        .map(address => address.toLowerCase())
-        .join(delimiter)
-    : addresses.toLowerCase()
-}

package/src/QueryValidator/QueryValidator.ts

@@ -1,9 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-export type Queryable<T extends QueryBoundWitness = QueryBoundWitness> = (query: T, payloads?: Payload[]) => Promisable<boolean>
-
-export interface QueryValidator<T extends QueryBoundWitness = QueryBoundWitness> {
-  queryable: Queryable<T>
-}

package/src/QueryValidator/SupportedQueryValidator.ts

@@ -1,27 +0,0 @@
-import type { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import type { ModuleQueries, QueryableModule } from '@xyo-network/module-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { Queryable, QueryValidator } from './QueryValidator.ts'
-
-export const isQuerySupportedByModule = async <T extends QueryBoundWitness = QueryBoundWitness>(
-  mod: QueryableModule,
-  query: T,
-  payloads?: Payload[],
-): Promise<boolean> => {
-  const wrapper = QueryBoundWitnessWrapper.parseQuery<ModuleQueries>(query, payloads)
-  const schema = (await wrapper.getQuery()).schema
-  return mod.queries.includes(schema)
-}
-
-export class SupportedQueryValidator implements QueryValidator {
-  protected readonly mod: QueryableModule
-  constructor(mod: QueryableModule) {
-    this.mod = mod
-  }
-
-  queryable: Queryable = (query, payloads) => {
-    return isQuerySupportedByModule(this.mod, query, payloads)
-  }
-}

package/src/QueryValidator/index.ts

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

package/src/determineAccount.ts

@@ -1,53 +0,0 @@
-import {
-  assertEx,
-  isDefined, isString, isUndefined,
-} from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
-import type { AccountInstance } from '@xyo-network/account-model'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-
-export interface DetermineAccountFromAccountParams {
-  account: AccountInstance | 'random'
-  accountPath?: never
-  wallet?: never
-}
-
-export interface DetermineAccountFromWalletParams {
-  account?: never
-  accountPath?: string
-  wallet: WalletInstance
-}
-
-export interface DetermineRandomParams {}
-
-export type DetermineAccountParams = DetermineAccountFromAccountParams | DetermineAccountFromWalletParams | DetermineRandomParams
-
-const isDetermineAccountFromAccountParams = (params: DetermineAccountParams): params is DetermineAccountFromAccountParams => {
-  assertEx(isUndefined((params as DetermineAccountFromWalletParams).accountPath), () => 'accountPath may not be provided when account is provided')
-  return isDefined((params as DetermineAccountFromAccountParams).account)
-}
-
-const isDetermineAccountFromWalletParams = (params: DetermineAccountParams): params is DetermineAccountFromWalletParams => {
-  return isDefined((params as DetermineAccountFromWalletParams).wallet)
-}
-
-export async function determineAccount(params: DetermineAccountParams, allowRandomAccount = true): Promise<AccountInstance> {
-  if (isDetermineAccountFromAccountParams(params)) {
-    if (params.account === 'random') {
-      assertEx(allowRandomAccount, () => 'Random address not allowed')
-      return await Account.random()
-    }
-    return params.account
-  }
-
-  if (isDetermineAccountFromWalletParams(params)) {
-    return assertEx(
-      isString(params.accountPath) ? await params.wallet.derivePath(params.accountPath) : params.wallet,
-      () => 'Failed to derive account from path',
-    )
-  }
-
-  // this should eventually be removed/thrown
-  console.warn('AbstractModule.determineAccount: No account or wallet provided - Creating Random account')
-  return await Account.random()
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './AbstractModule.ts'
-export * from './AbstractModuleInstance.ts'
-export * from './Error.ts'
-export * from './LoggerModuleStatusReporter.ts'
-export * from './QueryValidator/index.ts'