@xyo-network/os-runtime 7.2.0 → 7.3.0

package/src/classes/settings/badge/Resource.ts

@@ -1,50 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type { OsBadge, XyOsContext } from '@xyo-network/os-model'
-import { isBadgeWithMeta } from '@xyo-network/os-model'
-
-import type { ResourceStore } from '../../../lib/index.ts'
-import { PayloadStore } from '../../../lib/index.ts'
-import { OsSettingsCallerBase } from '../CallerBase.ts'
-import { OsBadgeQueries } from './Queries.ts'
-
-export type OsBadgeResourceViews = 'savedSeedPhrase'
-
-export class OsBadgeResource extends OsSettingsCallerBase implements ResourceStore<OsBadgeResourceViews> {
-  static readonly views: OsBadgeResourceViews[] = ['savedSeedPhrase']
-
-  private _savedSeedPhrase: PayloadStore<OsBadge> | undefined
-
-  constructor(xyOsContext: XyOsContext) {
-    super(xyOsContext)
-  }
-
-  get savedSeedPhrase() {
-    return assertEx(this._savedSeedPhrase, () => 'Saved seed phrase listener not set')
-  }
-
-  get subscriptions() {
-    return { savedSeedPhrase: (cb: () => void) => this.savedSeedPhrase.subscribe(cb) }
-  }
-
-  get views() {
-    return { savedSeedPhrase: () => this.savedSeedPhrase.latest }
-  }
-
-  cleanupListeners() {
-    this.savedSeedPhrase.cleanupListeners()
-  }
-
-  /**
-   * start listeners
-   **/
-  async start() {
-    const diviner = await this.getOsSettingsPayloadDiviner()
-    const archivist = await this.getOsSettingsArchivist()
-
-    this._savedSeedPhrase = await PayloadStore.create<OsBadge>({
-      archivist,
-      getLatest: async () => await OsBadgeQueries.getBadge('savedSeedPhrase', diviner),
-      idFunction: isBadgeWithMeta,
-    })
-  }
-}

package/src/classes/settings/badge/index.ts

@@ -1,2 +0,0 @@
-export * from './Caller.ts'
-export * from './Resource.ts'

package/src/classes/settings/index.ts

@@ -1,5 +0,0 @@
-export * from './badge/index.ts'
-export * from './Caller.ts'
-export * from './CallerBase.ts'
-export * from './Resource.ts'
-export * from './SettingsQueries.ts'

package/src/dapp/context/creator/Creator.ts

@@ -1,122 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { asArchivistInstance } from '@xyo-network/archivist-model'
-import { replaceManifestTokens } from '@xyo-network/kernel'
-import { DappPackageManifestPayloadSchema } from '@xyo-network/manifest'
-import type { ManifestWrapper } from '@xyo-network/manifest-wrapper'
-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, ExternalModule, XyOsContext,
-} from '@xyo-network/os-model'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-
-import type { DappNodesCreatorParams } from '../../../classes/lib/index.ts'
-import { DappCallerBase } from '../../../DappCallerBase.ts'
-import { manifestReplacementTokens } from '../../../manifest/index.ts'
-import { DefaultPayloads } from './DefaultPayloads/index.ts'
-import { ExternalModulePermissions } from './ExternalModulePermissions/index.ts'
-
-export type TargetDappManifestParams = ConstructorParameters<typeof ManifestWrapper<DappPackageManifestPayload>>
-
-export class DappContextCreator {
-  // Designated offset path for the wallet used by windowed dapps. In the future, other offsets could be used for other dapp modes
-  private static DAPP_WINDOW_WALLET_PATH = '1'
-
-  private context: XyOsContext
-  private dappId: DappId
-  private externalPermissions?: ExternalModule[]
-  private rootWallet: WalletInstance
-  private sharedLocator?: ModuleFactoryLocatorInstance
-  private targetDappManifestParams: TargetDappManifestParams
-
-  constructor(
-    targetDappManifestParams: TargetDappManifestParams,
-    dappId: DappId,
-    context: XyOsContext,
-    rootWallet: WalletInstance,
-    externalPermissions?: ExternalModule[],
-    sharedLocator?: ModuleFactoryLocatorInstance,
-  ) {
-    this.targetDappManifestParams = targetDappManifestParams
-    this.dappId = dappId
-    this.context = context
-    this.rootWallet = rootWallet
-    this.externalPermissions = externalPermissions
-    this.sharedLocator = sharedLocator
-  }
-
-  static async create(params: DappNodesCreatorParams, xnsNodeUrl: string | undefined, xnsNetwork: string | undefined) {
-    const {
-      config, locator, context, wallet,
-    } = params
-    const {
-      payload, dappName, publicChildren, privateChildren,
-    } = config
-
-    const { external, manifestPayload } = this.parseDappPackageManifestPayload(payload, xnsNodeUrl, xnsNetwork)
-    console.debug('[DEBUG] dApp manifest', manifestPayload)
-
-    // derive a wallet for the dapp to use from the root wallet
-    const dappWallet = await wallet.derivePath(DappContextCreator.DAPP_WINDOW_WALLET_PATH)
-    const targetDappManifestParams: TargetDappManifestParams = [manifestPayload,
-      dappWallet,
-      locator ?? new ModuleFactoryLocator(),
-      publicChildren,
-      privateChildren]
-
-    const instance = new this(targetDappManifestParams, dappName, context, wallet, external?.modules, locator)
-    return instance
-  }
-
-  // Add default payloads to the archivist shared between the os and the dapp
-  static async primeDappArchivist(dappContext: XyOsContext, osContext: XyOsContext, dappName: DappId) {
-    const dappCaller = new DappCallerBase(dappContext)
-    const dappArchivist = await dappCaller.getDappArchivist()
-    const defaultPayloads = new DefaultPayloads(dappArchivist, osContext, dappName)
-
-    await defaultPayloads.insert()
-  }
-
-  // Reset the dapp archivist to remove all payloads
-  static async resetDappArchivist(context: XyOsContext) {
-    const dappModule = await context.root.resolve('DappArchivist')
-    const dappArchivist = assertEx(asArchivistInstance(dappModule), () => 'resetDappArchivist: DappArchivist not found')
-
-    await dappArchivist.clear()
-  }
-
-  private static parseDappPackageManifestPayload(payload: DappPackageManifestPayload, xnsNodeUrl: string | undefined, xnsNetwork: string | undefined) {
-    // extract external permissions from package manifest payload
-    const { external, ...manifestWithoutExternals } = payload
-    const manifestPayloadRaw: DappPackageManifestPayload = {
-      ...manifestWithoutExternals,
-      schema: DappPackageManifestPayloadSchema,
-    }
-    console.log('DappContextCreator:parseDappPackageManifestPayload', xnsNodeUrl, xnsNetwork)
-    const manifestPayload = replaceManifestTokens(manifestPayloadRaw, manifestReplacementTokens(xnsNodeUrl, xnsNetwork))
-    return { external, manifestPayload }
-  }
-
-  async loadDappContext(context: XyOsContext): Promise<XyOsContext> {
-    console.log('DappNodesCreator:loadDappContext', this.dappId)
-    // build nodes and attach to dappNodes to dappWindowNode
-    const dapp
-      = (await context.dappByName(this.dappId))
-        ?? (await (async () => {
-          const dapp = await context.buildDapp(this.targetDappManifestParams[0], this.dappId)
-          await dapp.boot(this.rootWallet, this.sharedLocator)
-          return dapp
-        })())
-    await this.handleExternalModulePermissions(dapp.root)
-    await DappContextCreator.primeDappArchivist(dapp, this.context, this.dappId)
-
-    return dapp
-  }
-
-  // try to satisfy the external permissions requested by a dapp
-  private async handleExternalModulePermissions(dappWindowNode: NodeInstance) {
-    const externalModulePermissions = new ExternalModulePermissions(this.context, dappWindowNode, this.dappId, this.externalPermissions)
-    await externalModulePermissions.permit()
-  }
-}

package/src/dapp/context/creator/DefaultPayloads/DappAccessPayloads.ts

@@ -1,20 +0,0 @@
-import type { DappName, XyOsContext } from '@xyo-network/os-model'
-
-import type { DefaultPayloadsInsertable } from '../../../../classes/lib/index.ts'
-import { OsCallerBase } from '../../../../OsCallerBase.ts'
-
-export class DappAccessPayloads implements DefaultPayloadsInsertable {
-  private context: XyOsContext
-  constructor(
-    context: XyOsContext,
-    _dappName: DappName,
-  ) {
-    this.context = context
-  }
-
-  async payloads() {
-    const osCaller = new OsCallerBase(this.context)
-    const archivist = await osCaller.getRegisteredDappInterfacesArchivist()
-    return await archivist.all()
-  }
-}

package/src/dapp/context/creator/DefaultPayloads/DefaultPayloads.ts

@@ -1,40 +0,0 @@
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import type { DappName, XyOsContext } from '@xyo-network/os-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { InsertableConstructor } from '../../../../classes/lib/index.ts'
-import { createInsertable } from '../../../../classes/lib/index.ts'
-import { DappAccessPayloads } from './DappAccessPayloads.ts'
-import { NodeInfoPayload } from './NodeInfoPayload.ts'
-
-export class DefaultPayloads {
-  private dappArchivist: ArchivistInstance
-  private dappName: DappName
-  private xyOs: XyOsContext
-
-  constructor(
-    dappArchivist: ArchivistInstance,
-    xyOs: XyOsContext,
-    dappName: DappName,
-  ) {
-    this.dappArchivist = dappArchivist
-    this.xyOs = xyOs
-    this.dappName = dappName
-  }
-
-  async insert() {
-    const insertables: InsertableConstructor[] = [NodeInfoPayload, DappAccessPayloads]
-    const insertPayloads: Payload[] = []
-    for (const insertable of insertables) {
-      const classInstance = createInsertable(insertable, this.xyOs, this.dappName)
-      const payloads = await classInstance.payloads()
-      insertPayloads.push(...payloads)
-    }
-    for (const payload of insertPayloads) {
-      const [existing] = await this.dappArchivist.get([await PayloadBuilder.dataHash(payload)])
-      if (existing) continue
-      await this.dappArchivist.insert([payload])
-    }
-  }
-}

package/src/dapp/context/creator/DefaultPayloads/NodeInfoPayload.ts

@@ -1,33 +0,0 @@
-import type { Address } from '@xylabs/hex'
-import type {
-  DappName, NodeOsInfo, XyOsContext,
-} from '@xyo-network/os-model'
-import { NodeOsInfoSchema } from '@xyo-network/os-model'
-
-import type { DefaultPayloadsInsertable } from '../../../../classes/lib/index.ts'
-
-export class NodeInfoPayload implements DefaultPayloadsInsertable {
-  private _context: XyOsContext
-  constructor(
-    context: XyOsContext,
-    _dappName: DappName,
-  ) {
-    this._context = context
-  }
-
-  async payloads() {
-    const exposedNode = this._context.exposedNode
-    if (exposedNode) {
-      console.debug('[DEBUG]', 'Found Exposed Node Address', exposedNode?.address)
-    } else {
-      console.error('exposedNode not found')
-    }
-
-    await Promise.resolve()
-    const nodeOsInfo: NodeOsInfo = {
-      publicAddress: exposedNode?.address ?? '' as Address,
-      schema: NodeOsInfoSchema,
-    }
-    return [nodeOsInfo]
-  }
-}

package/src/dapp/context/creator/DefaultPayloads/index.ts

@@ -1 +0,0 @@
-export * from './DefaultPayloads.ts'

package/src/dapp/context/creator/ExternalModulePermissions/ExternalModulePermissions.ts

@@ -1,59 +0,0 @@
-import type { AttachableModuleInstance, ModuleIdentifier } from '@xyo-network/module-model'
-import type { NodeInstance } from '@xyo-network/node-model'
-import type {
-  DappName, ExternalModule, XyOsContext,
-} from '@xyo-network/os-model'
-
-// Dapps can only request specific modules from the parent node
-const ALLOWED_MODULES_FROM_PARENT = ['IntentArchivist', 'OsSettingsNode', 'OsPubSubNetworkStackNode', 'OsXyoPublicNetworkStackNode'] as const
-
-export class ExternalModulePermissions {
-  private context: XyOsContext
-  private dappName: DappName
-  private dappWindowNode: NodeInstance
-  private externalPermissions?: ExternalModule[]
-
-  constructor(
-    context: XyOsContext,
-    dappWindowNode: NodeInstance,
-    dappName: DappName,
-    externalPermissions?: ExternalModule[],
-  ) {
-    this.context = context
-    this.dappWindowNode = dappWindowNode
-    this.dappName = dappName
-    this.externalPermissions = externalPermissions
-  }
-
-  async permit() {
-    for (const permission of this.externalPermissions ?? []) {
-      await this.permitExternalModule(permission)
-    }
-  }
-
-  private getExternalModuleName(permission: ExternalModule) {
-    return permission.name as (typeof ALLOWED_MODULES_FROM_PARENT)[number]
-  }
-
-  private async permitExternalModule(externalPermission: ExternalModule) {
-    const externalModuleName = this.getExternalModuleName(externalPermission)
-
-    if (ALLOWED_MODULES_FROM_PARENT.includes(externalModuleName)) {
-      const mod = await this.resolveExternalModule(externalModuleName)
-      await this.registerAndAttachModule(mod)
-    } else {
-      console.warn(`${this.dappName} requested ${externalModuleName} but it was not fulfilled`)
-    }
-  }
-
-  private async registerAndAttachModule(mod?: AttachableModuleInstance) {
-    if (mod) {
-      await this.dappWindowNode.register?.(mod)
-      await this.dappWindowNode.attach(mod.address, true)
-    }
-  }
-
-  private async resolveExternalModule(id: ModuleIdentifier): Promise<AttachableModuleInstance | undefined> {
-    return await this.context.root.resolve(id)
-  }
-}

package/src/dapp/context/creator/ExternalModulePermissions/index.ts

@@ -1 +0,0 @@
-export * from './ExternalModulePermissions.ts'

package/src/dapp/context/creator/createDappContext.ts

@@ -1,61 +0,0 @@
-import { GenericPayloadDiviner } from '@xyo-network/diviner-payload-generic'
-import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
-import type { ModuleFactoryLocatorInstance } from '@xyo-network/module-model'
-import type {
-  RegisteredDapp, WindowDappNodeSet, XyOsContext,
-} from '@xyo-network/os-model'
-import { HDWallet } from '@xyo-network/wallet'
-
-import type { DappNodesCreatorParams } from '../../../classes/lib/index.ts'
-import { DappSeedPhraseRepository } from '../../../wallet/index.ts'
-import { DappContextCreator } from './Creator.ts'
-
-const GenericPayloadDivinerTags = { 'network.xyo.generic.payload.diviner': 'GenericPayloadDiviner' }
-
-const resolveLocator = (existingLocator?: ModuleFactoryLocatorInstance): ModuleFactoryLocatorInstance => {
-  const locator = existingLocator ?? new ModuleFactoryLocator()
-  locator.register(GenericPayloadDiviner.factory(), GenericPayloadDivinerTags)
-  return locator
-}
-
-export const createDappContext = async (
-  dapp: RegisteredDapp,
-  context: XyOsContext,
-  allowedNames: string[],
-  xnsNodeUrl: string | undefined,
-  xnsNetwork: string | undefined,
-): Promise<WindowDappNodeSet> => {
-  console.log('createNodes')
-  try {
-    const dappSeedPhraseRepository = new DappSeedPhraseRepository(context, allowedNames)
-    const seedPhrase = await dappSeedPhraseRepository.request(dapp.config.walletId)
-    if (!seedPhrase) {
-      throw new Error(`unable to find seed phrase for walletId: ${JSON.stringify(dapp.config, null, 2)}`)
-    }
-    const wallet = await HDWallet.fromPhrase(seedPhrase)
-    const dappName = dapp.config.name
-    const { config: dappConfig, params: dappParams } = dapp
-
-    const locator = resolveLocator((dappParams.locator ?? new ModuleFactoryLocator()).merge(context.platformLocator))
-
-    const params: DappNodesCreatorParams = {
-      config: { dappName, payload: dappConfig.manifest },
-      context,
-      locator,
-      wallet,
-    }
-    const dappContextCreator = await DappContextCreator.create(params, xnsNodeUrl, xnsNetwork)
-
-    const dappContext = await dappContextCreator.loadDappContext(context)
-
-    return {
-      context: dappContext,
-      dappWallet: wallet,
-    }
-  } catch (e) {
-    const error = e as Error
-    console.error(`Error creating dappWindow node: ${error.message}`)
-    console.error(`Error creating dappWindow node: ${error.stack}`)
-    throw new Error(`Error creating dappWindow node: ${error.message}`)
-  }
-}

package/src/dapp/context/creator/index.ts

@@ -1,3 +0,0 @@
-export * from './createDappContext.ts'
-export * from './Creator.ts'
-export * from './ExternalModulePermissions/index.ts'

package/src/dapp/context/index.ts

@@ -1 +0,0 @@
-export * from './creator/index.ts'

package/src/dapp/index.ts

@@ -1 +0,0 @@
-export * from './context/index.ts'

package/src/event/bus/Connection.ts

@@ -1,33 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type { BaseParams } from '@xylabs/base'
-import type { EventData } from '@xylabs/events'
-import { BaseEmitter } from '@xylabs/events'
-import type {
-  EventBusConnectionInterface, EventBusConnectionRequest, EventBusConnectionType,
-} from '@xyo-network/os-model'
-
-/**
- * A Generic Connection to add to an EventBus
- * @param  {EventBusConnectionRequest} request
- */
-export class EventBusConnection<TEventData extends EventData = EventData>
-  extends BaseEmitter<BaseParams, TEventData>
-  implements EventBusConnectionInterface<TEventData> {
-  _id?: string
-  description?: string
-  type: EventBusConnectionType
-
-  constructor(request: EventBusConnectionRequest) {
-    super({})
-    this.description = request.description
-    this.type = request.type
-  }
-
-  get id() {
-    return assertEx(this._id, () => 'Connection ID not set.  Did you forget to call buildConnection()?')
-  }
-
-  buildConnection(id: string) {
-    this._id = id
-  }
-}

package/src/event/bus/EventBus.ts

@@ -1,159 +0,0 @@
-import { findAs } from '@xylabs/array'
-import { assertEx } from '@xylabs/assert'
-import { forget } from '@xylabs/forget'
-import type { ArchivistModuleEventData } from '@xyo-network/archivist'
-import { asArchivistInstance } from '@xyo-network/archivist'
-import { MemoryArchivist, MemoryArchivistConfigSchema } from '@xyo-network/archivist-memory'
-import type {
-  EventBusConnectionInterface,
-  EventBusEvent,
-  EventBusInterface,
-  EventBusPubSubConnectionInterface,
-  PublisherEventListener,
-} from '@xyo-network/os-model'
-import {
-  asOptionalEventBusEvent,
-  isPubSubConnections,
-} from '@xyo-network/os-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { Mutex } from 'async-mutex'
-import { v4 as uuid } from 'uuid'
-
-/**
- * Event Bus implementation inspired by the DBus protocol used in Linux desktop systems for inter-process communication.
- *
- * General flow:
- * 1. Connection Added
- * 2. Publisher and Subscriber Callbacks added
- * 3. Events occurs and stored internally
- * 4. Subscriber Callbacks called based off stored events
- */
-export class EventBus implements EventBusInterface {
-  // Internal Archivist to store event data
-  private _archivist: MemoryArchivist | undefined
-
-  // Store all connections
-  private connections: Record<string, EventBusConnectionInterface> = {}
-
-  // Store all publisher callbacks for later removal
-  private publisherCallbacks: Record<string, PublisherEventListener> = {}
-
-  private startMutex = new Mutex()
-
-  get archivist() {
-    return asArchivistInstance(
-      assertEx(this._archivist, () => 'Archivist not found.  Did you forget to call start()?'),
-      'not a valid archivist instance',
-      { required: true },
-    )
-  }
-
-  addConnection(connection: EventBusConnectionInterface) {
-    // unique connection id
-    const id = uuid()
-
-    // store in local cache
-    this.connections[id] = connection
-
-    // update the connection id with the generated id
-    connection.buildConnection(id)
-
-    // let existing connections know about newly published events
-    if (isPubSubConnections(connection)) {
-      this.handlePublisherAdd(connection)
-    } else {
-      throw new Error('Unsupported connection type. Must be PubSub')
-    }
-    return connection
-  }
-
-  removeConnection(connectionId: string) {
-    // find the existing connection
-    const connection = this.connections[connectionId]
-    if (!connection) {
-      throw new Error('Connection not found ' + connectionId)
-    }
-
-    if (connection && isPubSubConnections(connection)) {
-      this.handlePublisherRemove(connection)
-    }
-
-    delete this.connections[connectionId]
-  }
-
-  async start(storeName = 'EventBusArchivist') {
-    return await this.startMutex.runExclusive(async () => {
-      if (this._archivist) {
-        console.warn('EventBus already started')
-        return this
-      }
-      // Later versions could include a node that has a payload diviner to query past events
-      this._archivist = await MemoryArchivist.create({ config: { name: storeName, schema: MemoryArchivistConfigSchema } })
-
-      // start listening to inserted events from publishers
-      // NOTE: This is a very basic implementation and could be optimized by indexing on connection, eventName, and callback
-      // for faster lookups by event name
-      this.archivist.on('inserted', ({ payloads }: ArchivistModuleEventData['inserted']) => {
-      // confirm an eventBusPayload was inserted
-        const eventBusEvent = findAs(payloads, asOptionalEventBusEvent)
-        // if not an eventBusPayload, return
-        if (!eventBusEvent) return
-        // Loop through all connections
-        for (const connectionId in this.connections) {
-          const connection = this.connections[connectionId]
-          // Target PubSub connections
-          if (isPubSubConnections(connection) && connection.subscribableEvents) {
-          // Loop through all subscribable events
-            for (const [eventName, callback] of connection.subscribableEvents.entries()) {
-            // check if the event name matches the payload name
-              if (eventName !== eventBusEvent.name) continue
-              // pass the event payloads to the callback
-              if (callback) {
-                const forgettable = async () => await callback({ payloads })
-                forget(forgettable())
-              }
-            }
-          }
-        }
-      })
-      return this
-    })
-  }
-
-  private handlePublisherAdd(connection: EventBusPubSubConnectionInterface) {
-    // Loop through all publishable events
-    for (const eventName of connection.publishableEvents ?? []) {
-      // Create publisher callback
-      const connectionPublisherCallback: PublisherEventListener = async ({ payloads }) => {
-        // build the event payload
-        const event: EventBusEvent = { name: eventName, schema: 'network.xyo.event.bus.event' }
-        const eventPayloads = payloads ?? []
-        event.sources = await PayloadBuilder.dataHashes(eventPayloads)
-        // Sync events to archivist
-        try {
-          await this.archivist.insert([event, ...(payloads ?? [])])
-        } catch (e) {
-          console.error('Error inserting event into archivist', e)
-        }
-      }
-      // Subscribe the publisher callback to the connection
-      connection.on(eventName, connectionPublisherCallback)
-
-      // store the publisher callback for later removal
-      const callbackId = connection.id + eventName
-      this.publisherCallbacks[callbackId] = connectionPublisherCallback
-    }
-  }
-
-  private handlePublisherRemove(connection: EventBusPubSubConnectionInterface) {
-    // Loop through all publishable events
-    for (const [, event] of connection.publishableEvents?.entries() ?? []) {
-      // find the publisher callback
-      const id = connection.id + event
-      const callback = this.publisherCallbacks[id]
-
-      // unsubscribe the publisher callback from the connection
-      if (callback) connection.off(event, callback)
-    }
-  }
-}

package/src/event/bus/PubSubConnection.ts

@@ -1,28 +0,0 @@
-import type {
-  EventBusPubSubConnectionInterface,
-  EventBusPubSubConnectionRequest,
-  PublisherEventListenerEventData,
-  SubscribableEventListeners,
-} from '@xyo-network/os-model'
-
-import { EventBusConnection } from './Connection.ts'
-
-/**
- * A PubSub Connection to add to an EventBus
- * @param  {EventBusPubSubConnectionRequest} request
- */
-export class EventBusPubSubConnection<TPublisherEventData extends PublisherEventListenerEventData = PublisherEventListenerEventData>
-  extends EventBusConnection<TPublisherEventData>
-  implements EventBusPubSubConnectionInterface {
-  publishableEvents?: string[]
-  subscribableEvents?: SubscribableEventListeners
-
-  constructor(request: EventBusPubSubConnectionRequest) {
-    super(request)
-    if (request.type !== 'PubSub') {
-      throw new Error('Invalid connection type. Must be PubSub')
-    }
-    this.publishableEvents = request.publishableEvents
-    this.subscribableEvents = request.subscribableEvents
-  }
-}

package/src/event/bus/index.ts

@@ -1,3 +0,0 @@
-export * from './Connection.ts'
-export * from './EventBus.ts'
-export * from './PubSubConnection.ts'

package/src/event/connections/DappAccessRequest.ts

@@ -1,11 +0,0 @@
-import type { EventBusPubSubConnectionRequest } from '@xyo-network/os-model'
-
-import { EventBusPubSubConnection } from '../bus/index.ts'
-
-export const DappAccessRequestEvent = 'dappAccessRequest'
-
-const dappAccessRequestConnectionRequest: EventBusPubSubConnectionRequest = {
-  publishableEvents: [DappAccessRequestEvent],
-  type: 'PubSub',
-}
-export const dappAccessRequestConnection = () => new EventBusPubSubConnection(dappAccessRequestConnectionRequest)

package/src/event/connections/DappsReady.ts

@@ -1,9 +0,0 @@
-import type { EventBusPubSubConnectionRequest } from '@xyo-network/os-model'
-
-import { EventBusPubSubConnection } from '../bus/index.ts'
-
-const dappsReadyConnectionRequest: EventBusPubSubConnectionRequest = {
-  publishableEvents: ['dappsReady'],
-  type: 'PubSub',
-}
-export const dappsReadyConnection = () => new EventBusPubSubConnection(dappsReadyConnectionRequest)