@xyo-network/os-runtime 7.2.1 → 7.3.0

package/src/OsCallerBase.ts

@@ -1,59 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import { asArchivistInstance } from '@xyo-network/archivist-model'
-import { asDivinerInstance } from '@xyo-network/diviner-model'
-import type { XyOsContext } from '@xyo-network/os-model'
-
-export const DappsArchivistModuleName = 'DappsArchivist'
-export const DappsArchivistDevelopmentModuleName = `${DappsArchivistModuleName}Development`
-export const DappsArchivistPayloadDivinerModuleName = 'DappsArchivistPayloadDiviner'
-export const DappsArchivistPayloadDevelopmentDivinerModuleName = `${DappsArchivistPayloadDivinerModuleName}Development`
-export const RegisteredDappInterfacesArchivistModuleName = 'RegisteredDappInterfacesArchivist'
-
-export class OsCallerBase {
-  protected context: XyOsContext
-  constructor(context: XyOsContext) {
-    this.context = context
-  }
-
-  // Get the dapps archivist
-  async getDappsArchivist() {
-    const mod = assertEx(await this.context.root.resolve(DappsArchivistModuleName), () => `${DappsArchivistModuleName} not found`)
-    return asArchivistInstance(mod, () => `${DappsArchivistModuleName} is not an archivist`, { required: true })
-  }
-
-  // Get the dapps archivist development
-  async getDappsArchivistDevelopment() {
-    const mod = assertEx(
-      await this.context.root.resolve(DappsArchivistDevelopmentModuleName),
-      () => `${DappsArchivistDevelopmentModuleName} not found`,
-    )
-    return asArchivistInstance(mod, () => `${DappsArchivistDevelopmentModuleName} is not an archivist`, { required: true })
-  }
-
-  // Get the dapps archivist payload diviner
-  async getDappsArchivistPayloadDiviner() {
-    const mod = assertEx(
-      await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName),
-      () => `${DappsArchivistPayloadDivinerModuleName} not found`,
-    )
-    return asDivinerInstance(mod, () => `${DappsArchivistPayloadDivinerModuleName} is not a diviner`, { required: true })
-  }
-
-  // Get the dapps archivist payload diviner development
-  async getDappsArchivistPayloadDivinerDevelopment() {
-    const mod = assertEx(
-      await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName),
-      () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`,
-    )
-    return asDivinerInstance(mod, () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} is not a diviner`, { required: true })
-  }
-
-  // Get the registered dapp interfaces archivist
-  async getRegisteredDappInterfacesArchivist() {
-    const mod = assertEx(
-      await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName),
-      () => `${RegisteredDappInterfacesArchivistModuleName} not found`,
-    )
-    return asArchivistInstance(mod, () => `${RegisteredDappInterfacesArchivistModuleName} is not an archivist`, { required: true })
-  }
-}

package/src/PubSubBridgeCaller.ts

@@ -1,33 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { BridgeExposeOptions } from '@xyo-network/bridge-model'
-import { asBridgeInstance } from '@xyo-network/bridge-model'
-import type { NodeInstance } from '@xyo-network/node-model'
-import { BridgedPubSubModuleName } from '@xyo-network/os-model'
-
-export class PubSubBridgeCaller {
-  private node: NodeInstance
-  constructor(node: NodeInstance) {
-    this.node = node
-  }
-
-  async exposeAddresses(addresses: Address[], options?: BridgeExposeOptions) {
-    const pubSubBridge = await this.getPubSubBridge()
-    for (const address of addresses) {
-      console.log(`Exposing: ${address}`)
-      await pubSubBridge.expose(address, options)
-    }
-  }
-
-  async unExposeAddresses(addresses: Address[]) {
-    const pubSubBridge = await this.getPubSubBridge()
-    for (const address of addresses) {
-      await pubSubBridge.unexpose?.(address)
-    }
-  }
-
-  private async getPubSubBridge() {
-    const mod = assertEx(await this.node.resolve(BridgedPubSubModuleName), () => `${BridgedPubSubModuleName} not found`)
-    return asBridgeInstance(mod, () => `${BridgedPubSubModuleName} is not a bridge`, { required: true })
-  }
-}

package/src/RunningDappCache.ts

@@ -1,58 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type {
-  DappId, RegisteredDapp, WindowDappNodeSet, XyOsContext,
-} from '@xyo-network/os-model'
-import { Mutex } from 'async-mutex'
-
-import { createDappContext, DappContextCreator } from './dapp/index.ts'
-import { XyOs } from './XyOs.ts'
-
-const findOrCreateMutex = new Mutex()
-
-/**
- * A cache for running node instances
- */
-export class RunningDappCache {
-  private static _cache: { [key: DappId]: WindowDappNodeSet } = {}
-
-  static async findOrCreate(
-    dapp: RegisteredDapp,
-    xyOs: XyOsContext,
-    allowedNames: string[],
-    xnsNodeUrl: string | undefined,
-    xnsNetwork: string | undefined,
-  ): Promise<WindowDappNodeSet> {
-    const dappId = dapp.config.name
-
-    return await XyOs.monitor<WindowDappNodeSet>(
-      async () =>
-        await findOrCreateMutex.runExclusive(async () => {
-          const existingWindowDappSet = RunningDappCache.get(dappId)
-          if (existingWindowDappSet) {
-            console.debug('[DEBUG]', `RunningDappCache, using existing node for ${dappId}`)
-            const existingDappContext = assertEx(existingWindowDappSet.context, () => 'No context found in existing dapp node')
-            await DappContextCreator.primeDappArchivist(existingDappContext, xyOs, dappId)
-            return existingWindowDappSet
-          }
-          console.debug('[DEBUG]', 'RunningDappCache:creating', dappId)
-          const windowDappSet = await createDappContext(dapp, xyOs, allowedNames, xnsNodeUrl, xnsNetwork)
-          RunningDappCache.set(dappId, windowDappSet)
-
-          return windowDappSet
-        }),
-      { additionalProperties: { dappId }, name: 'Loading dApp' },
-    )
-  }
-
-  static get(key: DappId): WindowDappNodeSet | undefined {
-    return this._cache[key]
-  }
-
-  static has(key?: DappId) {
-    return key ? !!this._cache[key] : false
-  }
-
-  static set(key: DappId, value: WindowDappNodeSet) {
-    this._cache[key] = value
-  }
-}

package/src/XyOs.ts

@@ -1,166 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import { boot } from '@xyo-network/bios'
-import { Kernel } from '@xyo-network/kernel'
-import type { KernelExternal } from '@xyo-network/kernel-model'
-import type { PackageManifest } from '@xyo-network/manifest'
-import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
-import type { ModuleFactoryLocatorInstance } from '@xyo-network/module-model'
-import type { NodeInstance } from '@xyo-network/node-model'
-import type {
-  DappId,
-  DappPackageManifestPayload,
-  DappParams,
-  SignersExternal,
-  StackInitializer,
-  XyOsContext,
-  XyOsDappContext,
-  XyOsGlobal,
-} from '@xyo-network/os-model'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-
-import { EventBus } from './event/index.ts'
-import type { MonitorEventConfig, XyOsMonitor } from './helpers/index.ts'
-import { NameTransforms } from './lib/index.ts'
-import { loadOsNode } from './loadOsNode.ts'
-import type { DappRegistrationServiceParams } from './registration/index.ts'
-import { DappRegistrationService } from './registration/index.ts'
-import { Signers } from './signer/index.ts'
-import type { OsPubSubNetworkStack, UninitializedStackMap } from './stack/index.ts'
-import { OsStackMap, StackManager } from './stack/index.ts'
-import type { XyOsContextParams } from './XyOsBase.ts'
-import { XyOsContextBase } from './XyOsBase.ts'
-
-export interface XyOsParams<TManifest extends PackageManifest = PackageManifest> extends XyOsContextParams<TManifest> {
-  dappsConfiguration?: DappRegistrationServiceParams
-  developmentMode?: boolean
-  kernel?: XyOsContext['kernel']
-  stackMap?: UninitializedStackMap
-}
-
-export class XyOs extends XyOsContextBase<XyOsParams> implements XyOsContext {
-  protected _exposedNode: NodeInstance | undefined
-  protected _exposedNodeOuter: NodeInstance | undefined
-  protected _kernel: KernelExternal
-  protected _locator: ModuleFactoryLocatorInstance
-  protected dappRegistrationService: DappRegistrationService
-  protected signers: SignersExternal | undefined
-  private stackManager: StackManager
-
-  constructor({
-    logger = console,
-    eventBus = new EventBus(),
-    kernel = new Kernel({ logger }),
-    locator = new ModuleFactoryLocator(),
-    dappsConfiguration,
-    developmentMode,
-    stackMap = OsStackMap,
-    ...params
-  }: XyOsParams = {}) {
-    super({
-      eventBus, kernel, locator, ...params,
-    })
-    this._locator = locator
-    this._kernel = kernel
-    this.stackManager = new StackManager(stackMap)
-    this.dappRegistrationService = new DappRegistrationService(this, dappsConfiguration, this.locator, developmentMode)
-    if (this.signerPaths && this.kernel?.bios?.seedPhraseStore) this.signers = new Signers(this.signerPaths, this.kernel?.bios?.seedPhraseStore)
-  }
-
-  static get monitoring(): XyOsMonitor | undefined {
-    return
-  }
-
-  static get xyOsGlobal(): XyOsGlobal {
-    return getXyOsGlobal()
-  }
-
-  override get bios(): KernelExternal['bios'] | undefined {
-    return assertEx(this.params.kernel?.bios, () => 'Missing bios')
-  }
-
-  override get exposedNode() {
-    return this.stackManager.getStack<OsPubSubNetworkStack>('osPubSubNetworkStack')?.exposedNode
-  }
-
-  override get exposedNodeOuter() {
-    return this.stackManager.getStack<OsPubSubNetworkStack>('osPubSubNetworkStack')?.exposedNodeOuter
-  }
-
-  override get kernel(): XyOsContext['kernel'] | undefined {
-    return assertEx(this.params.kernel, () => 'Missing kernel')
-  }
-
-  get locator() {
-    return this._locator
-  }
-
-  get stacks() {
-    return this.stackManager.stacks
-  }
-
-  override get user() {
-    return { signers: this.signers?.getWalletKindSigner('user') }
-  }
-
-  static async monitor<T>(fn: () => Promise<T>, eventConfig: MonitorEventConfig): Promise<T> {
-    const { name, additionalProperties } = eventConfig
-    const monitor = this.monitoring
-    monitor?.startTimer(name)
-    const result = await fn()
-    monitor?.stopTimer({ additionalProperties, name })
-
-    return result
-  }
-
-  override async boot(wallet: WalletInstance, locator: ModuleFactoryLocatorInstance = new ModuleFactoryLocator()) {
-    console.warn('XyOs:boot', wallet.address)
-    const fullLocator = this._locator.merge(locator)
-    return await this._bootMutex.runExclusive(async () => {
-      await this.eventBus.start()
-      if (this.kernel?.status === 'created') {
-        await this.kernel.boot(await boot(), { locator: fullLocator, kernelDrivers: [] })
-      }
-      if (this.kernel?.status !== 'booted') {
-        throw new Error('Kernel not booted')
-      }
-      assertEx(this._root === undefined, () => 'XyOs already booted')
-      const [root] = await XyOs.monitor(async () => await loadOsNode(wallet, fullLocator), { name: 'Load XyOs' })
-      this._root = root
-
-      this.stackManager.initialize(this)
-      if (this.signers) await this.signers.initialize()
-      return this
-    })
-  }
-
-  override buildDapp(
-    manifest: DappPackageManifestPayload,
-    dappId = NameTransforms.slug(manifest.nodes[0]?.config.name),
-    name = NameTransforms.moduleName(manifest.nodes[0]?.config.name),
-  ): Promisable<XyOsDappContext> {
-    return this.dappRegistrationService.buildDapp(manifest, dappId, name)
-  }
-
-  override dappByName(dappId: DappId): Promisable<XyOsDappContext | undefined> {
-    return this.dappRegistrationService.builtDapps[dappId]
-  }
-
-  override getDappParams(dappId: DappId): DappParams {
-    return this.dappRegistrationService.getParamsForRegisteredDapp(dappId)
-  }
-
-  override getStack(stackName: string): StackInitializer {
-    return assertEx(this.stackManager.getStack(stackName), () => `Stack not found: ${stackName}`)
-  }
-
-  override async monitor<T>(fn: () => Promise<T>, eventConfig: MonitorEventConfig): Promise<T> {
-    return await XyOs.monitor<T>(fn, eventConfig)
-  }
-
-  override shutdown() {
-    assertEx(this._root !== undefined, () => 'XyOs not booted')
-    this._root = undefined
-    this.stackManager.stop()
-  }
-}

package/src/XyOsBase.ts

@@ -1,135 +0,0 @@
-import type {
-  BaseParams, JsonObject, Promisable,
-} from '@xylabs/sdk-js'
-import { assertEx, BaseEmitter } from '@xylabs/sdk-js'
-import type { KernelExternal } from '@xyo-network/kernel-model'
-import type { PackageManifest } from '@xyo-network/manifest'
-import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
-import type { ModuleFactoryLocatorInstance } from '@xyo-network/module-model'
-import type { NodeInstance } from '@xyo-network/node-model'
-import type {
-  DappId, DappPackageManifestPayload, DappParams, EventBusInterface, OsUser,
-  StackInitializer, WalletKindSignerPaths, XyOsContext, XyOsDappContext,
-} from '@xyo-network/os-model'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import { Mutex } from 'async-mutex'
-
-export interface XyOsContextParams<TManifest extends PackageManifest = PackageManifest> extends BaseParams {
-  eventBus?: EventBusInterface
-  locator?: ModuleFactoryLocatorInstance
-  manifest?: TManifest
-  platformLocator?: ModuleFactoryLocator
-  signerPaths?: WalletKindSignerPaths
-}
-
-export class XyOsContextBase<TParams extends XyOsContextParams | void = void> extends BaseEmitter<
-  TParams extends XyOsContextParams ? TParams : XyOsContextParams
-> {
-  protected _bootMutex = new Mutex()
-  protected _platformLocator: ModuleFactoryLocator | undefined
-  protected _root: NodeInstance | undefined
-
-  get bios(): KernelExternal['bios'] | undefined {
-    return this.kernel?.bios
-  }
-
-  get eventBus(): XyOsContext['eventBus'] {
-    return assertEx(this.params.eventBus, () => 'Missing event bus')
-  }
-
-  get exposedNode(): NodeInstance | undefined {
-    throw new Error('Method not implemented. [exposedNode]')
-  }
-
-  get exposedNodeOuter(): NodeInstance | undefined {
-    throw new Error('Method not implemented. [exposedNodeOuter]')
-  }
-
-  get installedDapps(): DappId[] {
-    return []
-  }
-
-  get kernel(): XyOsContext['kernel'] | undefined {
-    return undefined
-  }
-
-  get manifest() {
-    return assertEx(this.params.manifest, () => 'Missing manifest')
-  }
-
-  get platformLocator(): ModuleFactoryLocator {
-    this._platformLocator = this._platformLocator ?? this.params.platformLocator ?? new ModuleFactoryLocator()
-    return this._platformLocator
-  }
-
-  get possibleRoot(): NodeInstance | undefined {
-    return this._root
-  }
-
-  get root(): NodeInstance {
-    return assertEx(this._root, () => 'XyOs root not set (probably not yet booted)')
-  }
-
-  get runningDapps(): DappId[] {
-    return []
-  }
-
-  get signerPaths() {
-    return this.params.signerPaths
-  }
-
-  get state() {
-    return this._root ? 'running' : 'stopped'
-  }
-
-  get user(): OsUser {
-    throw new Error('Method not implemented. [user]')
-  }
-
-  boot(_wallet: WalletInstance, _locator: ModuleFactoryLocator): Promisable<XyOsContext> {
-    throw new Error('Method not implemented. [boot]')
-  }
-
-  buildDapp(_manifest: DappPackageManifestPayload, _dappId?: DappId): Promisable<XyOsDappContext> {
-    throw new Error('Method not implemented. [buildDapp]')
-  }
-
-  dappByName(_dappId: DappId): Promisable<XyOsDappContext | undefined> {
-    throw new Error('Method not implemented. [runningDapp]')
-  }
-
-  getDappParams(_dappId: DappId): DappParams | undefined {
-    throw new Error('Method not implemented. [getDappParams]')
-  }
-
-  getStack(_stackName: string): StackInitializer {
-    throw new Error('Method not implemented. [getStack]')
-  }
-
-  installDapp(_dappId: DappId) {
-    throw new Error('Method not implemented. [installDapp]')
-  }
-
-  monitor<T>(_fn: () => Promise<T>, _eventConfig: {
-    additionalProperties?: JsonObject
-    name: string
-  }): Promise<T> {
-    throw new Error('Method not implemented. [monitor]')
-  }
-
-  shutdown() {
-    throw new Error('Method not implemented. [shutdown]')
-  }
-
-  startDapp(_dappId: DappId): Promisable<XyOsDappContext> {
-    throw new Error('Method not implemented. [startDapp]')
-  }
-
-  stopDapp(_dappId: DappId) {
-    throw new Error('Method not implemented. [stopDapp]')
-  }
-
-  uninstallDapp(_dappId: DappId) {
-    throw new Error('Method not implemented. [uninstallDapp]')
-  }
-}

package/src/XyOsDapp.ts

@@ -1,106 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { PackageManifestPayload } from '@xyo-network/manifest'
-import { NodeManifestPayload } from '@xyo-network/manifest'
-import { ManifestWrapper } from '@xyo-network/manifest-wrapper'
-import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
-import type { ModuleFactoryLocatorInstance } from '@xyo-network/module-model'
-import type {
-  DappPackageManifestPayload, OsUser, XyOsContext, XyOsDappContext, XyOsDappDetails,
-} from '@xyo-network/os-model'
-import { DappPackageManifestPayloadSchema } from '@xyo-network/os-model'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-
-import { DappWindowManifest } from './manifests/index.ts'
-import type { XyOsContextParams } from './XyOsBase.ts'
-import { XyOsContextBase } from './XyOsBase.ts'
-
-export interface XyOsDappContextParams extends XyOsContextParams<DappPackageManifestPayload> {
-  dapp: XyOsDappDetails
-  locator: ModuleFactoryLocatorInstance
-  parent: XyOsContext
-  user: OsUser
-}
-
-export class XyOsDapp extends XyOsContextBase<XyOsDappContextParams> implements XyOsDappContext {
-  dapp: XyOsDappDetails
-
-  constructor(params: XyOsDappContextParams) {
-    super(params)
-    this.dapp = { ...params.dapp }
-  }
-
-  override get eventBus() {
-    return this.parent.eventBus
-  }
-
-  override get exposedNode() {
-    return this.parent.exposedNode
-  }
-
-  override get exposedNodeOuter() {
-    return this.parent.exposedNodeOuter
-  }
-
-  /**
-   * @deprecated Dapps should not have access to the bios. This is done for the
-   * settings dapp, but should be refactored out. Bios could possibly be an
-   * optional property of the parent context passed in for dapps that require
-   * elevated permissions.
-   * ^^^ I believe we may want this here in that is a dApp requests access to the bios it will optionally be there
-   */
-  override get kernel(): XyOsContextBase['kernel'] {
-    return assertEx(this.parent.kernel, () => 'Missing kernel')
-  }
-
-  get parent() {
-    return this.params.parent
-  }
-
-  get stacks() {
-    return []
-  }
-
-  override get user() {
-    return this.params.user
-  }
-
-  override async boot(wallet: WalletInstance, locator?: ModuleFactoryLocator): Promise<XyOsDappContext> {
-    return await this._bootMutex.runExclusive(async () => {
-      console.log('XyOsDapp:boot:start', wallet.address, this.dapp.id)
-      assertEx(this._root === undefined, () => 'Dapp already booted')
-
-      const finalLocator
-        = locator ? (this.params.locator ?? new ModuleFactoryLocator()).merge(locator) : (this.params.locator ?? new ModuleFactoryLocator())
-
-      console.log('XyOsDapp:boot:finalLocator', finalLocator)
-
-      const dappNodesWrapper = new ManifestWrapper({ ...this.manifest, schema: DappPackageManifestPayloadSchema }, wallet, finalLocator)
-      const dappNodes = await dappNodesWrapper.loadNodes()
-      const manifest = DappWindowManifest as unknown as PackageManifestPayload
-
-      // Derive a specific wallet for the dappManifestWrapper.
-      // If the dappNodes and dappManifest wrappers get the same wallet, there will be collisions.
-      const dappManifestWallet = await wallet.derivePath('99999')
-      manifest.nodes[0].config.name = this.dapp.name + 'Root'
-      const wrapper = new ManifestWrapper<DappPackageManifestPayload>(
-        { ...manifest, schema: DappPackageManifestPayloadSchema },
-        dappManifestWallet,
-        finalLocator,
-      )
-
-      const node = await wrapper.loadNodeFromIndex(0)
-      for (const dappNode of dappNodes) {
-        await node.register(dappNode)
-        await node.attach(dappNode.address, true)
-      }
-
-      this._root = node
-      console.log('XyOsDapp:boot:finish', wallet.address, this.dapp.id)
-      return this
-    })
-  }
-
-  override getStack(stackName: string) {
-    return this.parent.getStack(stackName)
-  }
-}

package/src/access/Caller.ts

@@ -1,85 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
-import type { ModuleFactoryLocatorInstance } from '@xyo-network/module-model'
-import { asNodeInstance } from '@xyo-network/node-model'
-import type {
-  PostRegistrationHandler,
-  RegisteredDappAccess,
-  RegisteredDappSet,
-  RegisteredDappSetResult,
-  XyOsContext,
-} from '@xyo-network/os-model'
-import { isRegisteredDappAccessDappSet } from '@xyo-network/os-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-
-import { OsCallerBase } from '../OsCallerBase.ts'
-import { RunningDappCache } from '../RunningDappCache.ts'
-import { RunningDappAccessCache } from './RunningAccessDappCache.ts'
-
-/**
- * Caller for managing Dapp Access Nodes
- * Start nodes that have been registered as accessible
- * Grab their Access Node(s)
- * Put RegisteredDappAccess payloads in RegisteredDappInterfacesArchivist
- * Keep Service running that can service requests for Access Nodes
- */
-export class DappAccessCaller extends OsCallerBase implements PostRegistrationHandler {
-  private allowedNames: string[]
-  private platformLocator: ModuleFactoryLocatorInstance
-  private registeredDapps: RegisteredDappSetResult[]
-  private xnsNetwork: string | undefined
-  private xnsNodeUrl: string | undefined
-
-  constructor(
-    context: XyOsContext,
-    registeredDapps: RegisteredDappSetResult[],
-    allowedNames: string[],
-    xnsNodeUrl: string | undefined,
-    xnsNetwork: string | undefined,
-    platformLocator = new ModuleFactoryLocator(),
-  ) {
-    super(context)
-    this.registeredDapps = registeredDapps
-    this.allowedNames = allowedNames
-    this.xnsNodeUrl = xnsNodeUrl
-    this.xnsNetwork = xnsNetwork
-    this.platformLocator = platformLocator
-  }
-
-  async start() {
-    const registeredDappAccessDappSets = this.registeredDapps.filter(isRegisteredDappAccessDappSet)
-    for (const registeredDappSet of registeredDappAccessDappSets) {
-      const context = await this.buildRunningDappCache(registeredDappSet, this.allowedNames)
-
-      for (const dappAccessor of registeredDappSet.dapp.accessors) {
-        await this.cacheAccessNode(dappAccessor, context)
-        await this.saveRegisteredDappInterfaces(dappAccessor)
-      }
-    }
-  }
-
-  private async buildRunningDappCache(registeredDappSet: RegisteredDappSet, allowedNames: string[]) {
-    const { context } = await RunningDappCache.findOrCreate(registeredDappSet.dapp, this.context, allowedNames, this.xnsNodeUrl, this.xnsNetwork)
-    if (!context) throw new Error('Dapp context not found')
-    return context
-  }
-
-  private async cacheAccessNode(dappAccessor: RegisteredDappAccess, context: XyOsContext) {
-    const accessNodeId = dappAccessor.rootModuleId
-    const accessNodeModule = assertEx(await context.root.resolve(accessNodeId), () => 'Access Node Module not found')
-    const accessNode = asNodeInstance(accessNodeModule, () => 'Access Node Module is not a NodeInstance', { required: true })
-
-    RunningDappAccessCache.set(dappAccessor.registeringDappId, accessNode)
-  }
-
-  private async saveRegisteredDappInterfaces(registeredDappAccess: RegisteredDappAccess) {
-    const archivist = await this.getRegisteredDappInterfacesArchivist()
-
-    const hash = await PayloadBuilder.dataHash(registeredDappAccess)
-    const [existing] = await archivist.get([hash])
-    if (existing) return
-
-    await archivist.insert([registeredDappAccess])
-    console.debug('[DEBUG] -', `Registered ${registeredDappAccess.registeringDappId} with ${registeredDappAccess.name} interface`)
-  }
-}

package/src/access/Queries.ts

@@ -1,38 +0,0 @@
-import type { DivinerInstance } from '@xyo-network/diviner-model'
-import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
-import type { DappAccessRequest, RegisteredDappAccess } from '@xyo-network/os-model'
-import { DappAccessRequestSchema, RegisteredDappAccessSchema } from '@xyo-network/os-model'
-import type { WithSources } from '@xyo-network/payload-model'
-
-const noResults: unknown[] = []
-
-export const DappAccessRequestQueries = {
-  async getAccessRequests(diviner: DivinerInstance) {
-    const query = {
-      limit: 1,
-      schema: PayloadDivinerQuerySchema,
-      schemas: [DappAccessRequestSchema],
-    }
-
-    const results = (await diviner.divine([query])) as WithSources<DappAccessRequest>[]
-
-    if (results.length === 0) {
-      return noResults as WithSources<DappAccessRequest>[]
-    }
-    return results
-  },
-  async getRegisteredInterfaces(diviner: DivinerInstance) {
-    const query = {
-      limit: 1,
-      schema: PayloadDivinerQuerySchema,
-      schemas: [RegisteredDappAccessSchema],
-    }
-
-    const results = (await diviner.divine([query])) as WithSources<RegisteredDappAccess>[]
-
-    if (results.length === 0) {
-      return noResults as WithSources<RegisteredDappAccess>[]
-    }
-    return results
-  },
-}