@xyo-network/os-runtime 3.0.0

package/src/classes/node/Creator.ts

@@ -0,0 +1,96 @@
+import { assertEx } from '@xylabs/assert'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import type { PackageManifestPayload } from '@xyo-network/manifest'
+import { PackageManifestPayloadSchema } from '@xyo-network/manifest'
+import type { ManifestWrapper } from '@xyo-network/manifest-wrapper'
+import type { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+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 { DappCallerBase } from '../../DappCallerBase.ts'
+import { ReplaceManifestTokens } from '../../manifest/index.ts'
+import type { DappNodesCreatorParams } from '../lib/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'
+
+  constructor(
+    private targetDappManifestParams: TargetDappManifestParams,
+    private dappId: DappId,
+    private context: XyOsContext,
+    private rootWallet: WalletInstance,
+    private externalPermissions?: ExternalModule[],
+    private sharedLocator?: ModuleFactoryLocator,
+  ) {}
+
+  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, 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), () => '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: PackageManifestPayload = {
+      ...manifestWithoutExternals,
+      schema: PackageManifestPayloadSchema,
+    }
+    const manifestPayload = ReplaceManifestTokens(manifestPayloadRaw, 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/classes/node/DefaultPayloads/DappAccessPayloads.ts

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

package/src/classes/node/DefaultPayloads/DefaultPayloads.ts

@@ -0,0 +1,33 @@
+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 '../../lib/index.ts'
+import { createInsertable } from '../../lib/index.ts'
+import { DappAccessPayloads } from './DappAccessPayloads.ts'
+import { NodeInfoPayload } from './NodeInfoPayload.ts'
+import { SigningKeyPayloads } from './SigningKeyPayloads.ts'
+
+export class DefaultPayloads {
+  constructor(
+    private dappArchivist: ArchivistInstance,
+    private xyOs: XyOsContext,
+    private dappName: DappName,
+  ) {}
+
+  async insert() {
+    const insertables: InsertableConstructor[] = [NodeInfoPayload, SigningKeyPayloads, 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/classes/node/DefaultPayloads/NodeInfoPayload.ts

@@ -0,0 +1,27 @@
+import type { DappName, NodeOsInfo, XyOsContext } from '@xyo-network/os-model'
+import { NodeOsInfoSchema } from '@xyo-network/os-model'
+
+import type { DefaultPayloadsInsertable } from '../../lib/index.ts'
+
+export class NodeInfoPayload implements DefaultPayloadsInsertable {
+  constructor(
+    private _context: XyOsContext,
+    _dappName: DappName,
+  ) {}
+
+  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 ?? '',
+      schema: NodeOsInfoSchema,
+    }
+    return [nodeOsInfo]
+  }
+}

package/src/classes/node/DefaultPayloads/SigningKeyPayloads.ts

@@ -0,0 +1,85 @@
+import { assertEx } from '@xylabs/assert'
+import { hexFrom } from '@xylabs/hex'
+import { HDWallet } from '@xyo-network/account'
+import type { DappName, XyOsContext } from '@xyo-network/os-model'
+import { mnemonicArrayToString, SigningKeySchema } from '@xyo-network/os-model'
+import type { Payload } from '@xyo-network/payload-model'
+import { isAnyPayload } from '@xyo-network/payload-model'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+
+import type { DefaultPayloadsInsertable } from '../../lib/index.ts'
+import { OsSettingsCaller } from '../../settings/index.ts'
+
+const DappsWithAdditionalPayloads = new Set(['Profile'])
+
+const DefaultName: DappName = 'Name Service' as const
+
+const DEFAULT_DAPP_ACCOUNT_PATHS: Record<string, string> = {
+  [DefaultName]: "1'/1",
+} as const
+
+// WIP - for now, dApps listed here can gain access to the signing key for other dapps
+// In the future, this will be controlled by the user
+const ADDITIONAL_DAPP_ACCOUNT_PATHS: Record<string, Record<string, string>> = {
+  ['Profile']: {
+    [DefaultName]: DEFAULT_DAPP_ACCOUNT_PATHS[DefaultName],
+  },
+} as const
+
+export class SigningKeyPayloads implements DefaultPayloadsInsertable {
+  constructor(
+    private context: XyOsContext,
+    private dappName: DappName,
+  ) {}
+
+  async payloads() {
+    const wallet = await this.resolveXyoWallet()
+
+    // get the signing key payloads for the default dapp account
+    const defaultDappAccountSigningKeyPayloads = await this.signingKeyPayload(wallet, this.dappName, DEFAULT_DAPP_ACCOUNT_PATHS[this.dappName])
+
+    // and any additional dapp accounts
+    const additionalDappAccountSigningKeyPayloads: (Payload | undefined)[] = []
+    for (const [dappName, accountPaths] of Object.entries(ADDITIONAL_DAPP_ACCOUNT_PATHS)) {
+      if (dappName !== this.dappName || !DappsWithAdditionalPayloads.has(dappName)) continue
+
+      for (const additionalDappAccountName of Object.keys(accountPaths)) {
+        const signingKeyPayload = await this.signingKeyPayload(wallet, additionalDappAccountName, accountPaths[additionalDappAccountName])
+        additionalDappAccountSigningKeyPayloads.push(signingKeyPayload)
+      }
+    }
+
+    // filter so we only return valid payloads
+    return [...additionalDappAccountSigningKeyPayloads, defaultDappAccountSigningKeyPayloads].filter(isAnyPayload) as Payload[]
+  }
+
+  private async resolveXyoWallet() {
+    // get the user's wallet
+    const settingsCaller = new OsSettingsCaller(this.context)
+    const latestWallet = await settingsCaller.getLatestUserWallet()
+
+    // find the phrase
+    const phrase = mnemonicArrayToString(latestWallet.mnemonic.mnemonic)
+    const assertedPhrase = assertEx(phrase, () => 'No phrase found in latest wallet')
+
+    // create a wallet instance
+    return await HDWallet.fromPhrase(assertedPhrase)
+  }
+
+  private async signingKeyPayload(wallet: WalletInstance, name: string, path?: string) {
+    if (path) {
+      // derive the sub account
+      const subAccount = await wallet.derivePath(path)
+
+      // get the private key
+      const privateKey = hexFrom(subAccount.privateKey, { prefix: false })
+
+      // return the payload
+      return {
+        dappName: name,
+        privateKey,
+        schema: SigningKeySchema,
+      }
+    }
+  }
+}

package/src/classes/node/DefaultPayloads/index.ts

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

package/src/classes/node/ExternalModulePermissions/ExternalModulePermissions.ts

@@ -0,0 +1,47 @@
+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 {
+  constructor(
+    private context: XyOsContext,
+    private dappWindowNode: NodeInstance,
+    private dappName: DappName,
+    private externalPermissions?: ExternalModule[],
+  ) {}
+
+  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/classes/node/ExternalModulePermissions/index.ts

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

package/src/classes/node/createDappContext.ts

@@ -0,0 +1,52 @@
+import { HDWallet } from '@xyo-network/account'
+import { GenericPayloadDiviner } from '@xyo-network/diviner-payload-generic'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type { RegisteredDapp, WindowDappNodeSet, XyOsContext } from '@xyo-network/os-model'
+
+import { DappSeedPhraseRepository } from '../../wallet/index.ts'
+import type { DappNodesCreatorParams } from '../lib/index.ts'
+import { DappContextCreator } from './Creator.ts'
+
+const GenericPayloadDivinerTags = { 'network.xyo.generic.payload.diviner': 'GenericPayloadDiviner' }
+
+const resolveLocator = (existingLocator?: ModuleFactoryLocator) => {
+  const locator = existingLocator ?? new ModuleFactoryLocator()
+  locator.register(GenericPayloadDiviner, 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/classes/node/index.ts

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

package/src/classes/registration/DappRegistrationService.ts

@@ -0,0 +1,146 @@
+import { forget } from '@xylabs/forget'
+import type { Promisable } from '@xylabs/promise'
+import { fulfilled, rejected } from '@xylabs/promise'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type {
+  DappPackageManifestPayload,
+  DappParams,
+  DappRegistrationResults,
+  PayloadWithVersion,
+  RegisteredDappSetResult,
+  XyOsContext,
+  XyOsDappContext } from '@xyo-network/os-model'
+import {
+  DappIntentTypes,
+  DappMode,
+  isRegisteredDappAccessDappSet,
+  isRegisteredDappExposedDappSet,
+} from '@xyo-network/os-model'
+
+import { dappAccessRequestConnection, DappAccessRequestEvent, exposeDappRequestConnection, ExposeDappRequestEvent } from '../../event/index.ts'
+import { DappIntentCaller } from '../../intent/index.ts'
+import { NameTransforms } from '../../lib/index.ts'
+import { DappSeedPhraseRepository } from '../../wallet/index.ts'
+import { XyOsDapp } from '../../XyOsDapp.ts'
+import { ManageSystemDapps } from '../system/index.ts'
+import { DappRegistry } from './DappRegistry.ts'
+
+export interface DappRegistrationServiceParams {
+  dappNames: string[]
+  dappParams: Record<string, DappParams>
+  dappPayloads: PayloadWithVersion[]
+}
+
+export class DappRegistrationService {
+  // Dapps that have been built with their own context
+  builtDapps: Record<string, XyOsDappContext> = {}
+
+  dappRegistry: DappRegistry
+  dappSeedPhraseRepository: DappSeedPhraseRepository
+  manageSystemDapps: ManageSystemDapps
+
+  // Dapps that have been registered with dappAccessRequests
+  registeredAccessDappSets: Set<RegisteredDappSetResult> = new Set()
+
+  // Dapps that have been registered with the dapp registry
+  registeredDappSets: Set<RegisteredDappSetResult> = new Set()
+
+  // Dapps that have been registered with exposeDappRequests
+  registeredExposedDappSets: Set<RegisteredDappSetResult> = new Set()
+
+  private dappAccessRequestConnection = dappAccessRequestConnection()
+  private exposeDappRequestConnection = exposeDappRequestConnection()
+
+  constructor(
+    private context: XyOsContext,
+    private params: DappRegistrationServiceParams = { dappNames: [], dappParams: {}, dappPayloads: [] },
+    private locator = new ModuleFactoryLocator(),
+    private developmentMode?: boolean,
+  ) {
+    this.manageSystemDapps = new ManageSystemDapps(
+      context,
+      this.params?.dappNames ?? [],
+      this.params?.dappPayloads ?? [],
+      this.params?.dappParams ?? {},
+      this.locator,
+      this.developmentMode,
+    )
+    this.dappSeedPhraseRepository = new DappSeedPhraseRepository(context, this.params?.dappNames ?? [])
+    this.dappRegistry = new DappRegistry(this.dappSeedPhraseRepository)
+
+    this.addConnectionRequests()
+  }
+
+  buildDapp(
+    manifest: DappPackageManifestPayload,
+    dappId = NameTransforms.slug(manifest.nodes[0]?.config.name),
+    name = NameTransforms.moduleName(manifest.nodes[0]?.config.name),
+  ): Promisable<XyOsDappContext> {
+    const dapp = new XyOsDapp({ dapp: { id: dappId, name }, locator: this.locator, manifest, parent: this.context }) as XyOsDappContext
+    this.builtDapps[dappId] = dapp
+    return dapp
+  }
+
+  getParamsForRegisteredDapp(dappId: string) {
+    return this.params?.dappParams[dappId]
+  }
+
+  async start(): Promise<DappRegistrationResults> {
+    const systemDapps = await this.context.monitor(async () => await this.manageSystemDapps.install(), { name: 'Install System dApps' })
+    const activeDapps = systemDapps.filter(({ dapp }) => dapp.icon.active === true)
+    const results = await Promise.allSettled(
+      activeDapps.map(async (dappSet) => {
+        const { dapp } = dappSet
+        const registeredDapp = await this.dappRegistry.registerDapp(dapp)
+        const result: RegisteredDappSetResult = { dapp: registeredDapp, dappIcon: dapp.icon }
+
+        // Start post registration process in the background
+        const forgetHandlers = async () => {
+          try {
+            await this.postRegistrationHandlers(result)
+          } catch (e) {
+            console.error('Error in post registration handlers', e)
+          }
+        }
+        forget(forgetHandlers())
+
+        return result
+      }),
+    )
+    const failed = results.filter(rejected).map(result => result.reason)
+    const succeeded = results.filter(fulfilled).map(result => result.value)
+
+    for (const registeredDapp of succeeded) this.registeredDappSets.add(registeredDapp)
+
+    return { failed, succeeded }
+  }
+
+  private addConnectionRequests() {
+    this.context.eventBus.addConnection(this.dappAccessRequestConnection)
+    this.context.eventBus.addConnection(this.exposeDappRequestConnection)
+  }
+
+  private async postRegistrationHandlers(registeredDapp: RegisteredDappSetResult) {
+    if (registeredDapp.dapp) {
+      if (isRegisteredDappExposedDappSet(registeredDapp)) {
+        // add to exposed dapp set
+        this.registeredExposedDappSets.add(registeredDapp)
+        // craft intent
+        const exposeIntent = DappIntentCaller.buildIntent(
+          DappIntentCaller.OsDappName,
+          DappIntentTypes.Launch,
+          registeredDapp.dapp.config.name,
+          DappMode.Exposed,
+        )
+        // emit to bus
+        await this.exposeDappRequestConnection.emit(ExposeDappRequestEvent, { payloads: [registeredDapp.dapp.config, exposeIntent] })
+      }
+      if (isRegisteredDappAccessDappSet(registeredDapp)) {
+        // add to access dapp set
+        this.registeredAccessDappSets.add(registeredDapp)
+        // emit to bus
+        await this.dappAccessRequestConnection.emit(DappAccessRequestEvent, { payloads: registeredDapp.dapp.accessors })
+      }
+    }
+  }
+}

package/src/classes/registration/DappRegistry.ts

@@ -0,0 +1,121 @@
+import type { Hash } from '@xylabs/hex'
+import { HDWallet } from '@xyo-network/account'
+import type {
+  DappPackageManifestPayload,
+  DappParams,
+  RegisteredDapp,
+  RegisteredDappAccess,
+  UnregisteredDapp,
+  UnregisteredDappAccess } from '@xyo-network/os-model'
+import {
+  DappRegisteredSchema,
+  DappRegisteredState,
+  isRegisteredDappAccess,
+} from '@xyo-network/os-model'
+import type { WithMeta } from '@xyo-network/payload-model'
+
+import type { DappSeedPhraseRepository } from '../../wallet/index.ts'
+import type {
+  FailedAccessor } from './ValidateDappAccessDiviner/index.ts'
+import {
+  isFailedAccessor,
+  ValidateDappAccessDiviner,
+  ValidateDappAccessDivinerConfigSchema,
+} from './ValidateDappAccessDiviner/index.ts'
+
+export type DappRegisteredId = string
+
+/**
+ * Manage Dapp Registration
+ */
+export class DappRegistry {
+  private dappRegistry: Map<DappRegisteredId, RegisteredDapp> = new Map()
+
+  constructor(private dappSeedPhraseRepository: DappSeedPhraseRepository) {}
+
+  /**
+   * Register a Dapp with window manager and if successful, return its id
+   *
+   * @param {UnregisteredDapp} dapp Manifest and UI of the Dapp to register
+   * @returns {RegisteredDapp} dapp with registration fields
+   **/
+  async registerDapp(dapp?: UnregisteredDapp): Promise<RegisteredDapp | null> {
+    if (dapp) {
+      const { exposedModuleIds, manifest, modes, name, version, params, widgetConfigs } = this.extractDappProperties(dapp)
+
+      try {
+        /**
+         * TODO: More validation from sources is needed for third-party dapps. A name needs some form of verification
+         * before trusting it with a seed phrase at that given name.
+         */
+
+        // get a seed phrase for the given dapp id
+        const walletId = await this.dappSeedPhraseRepository.findOrCreate(name)
+
+        const registeredAccessors = await this.validateDappAccessPayloads(manifest, dapp.accessors, params)
+
+        const registeredDapp: RegisteredDapp = {
+          accessors: registeredAccessors,
+          config: {
+            exposedModuleIds,
+            manifest,
+            modes,
+            name,
+            schema: DappRegisteredSchema,
+            state: DappRegisteredState.Registered,
+            version,
+            // attach the walletId to a registered dapp so it can request it back in the future
+            walletId,
+          },
+          params,
+          widgetConfigs,
+        }
+
+        if (this.dappRegistry.get(name)) {
+          console.warn('tried to register two dapps with the same name', name)
+          return null
+        }
+        this.dappRegistry.set(name, registeredDapp)
+        return registeredDapp
+      } catch (e) {
+        console.error('Error registeringDapp', e)
+        return null
+      }
+    } else {
+      return null
+    }
+  }
+
+  /**
+   * Unregister a dapp so it can no longer be launched
+   *
+   * @param dappId
+   */
+  unregisterDapp(dappId: Hash) {
+    this.dappRegistry.delete(dappId)
+  }
+
+  private extractDappProperties(dapp: UnregisteredDapp) {
+    const { params, config, widgetConfigs } = dapp
+    const { exposedModuleIds, manifest, modes, name, sources, version } = config
+
+    return { exposedModuleIds, manifest, modes, name, params, sources, version, widgetConfigs }
+  }
+
+  private async validateDappAccessPayloads(manifest: DappPackageManifestPayload, accessors: UnregisteredDappAccess[] = [], params: DappParams) {
+    const validateDappAccess = await ValidateDappAccessDiviner.create({
+      account: await HDWallet.random(),
+      config: { schema: ValidateDappAccessDivinerConfigSchema },
+      dappParams: params,
+    })
+    const payloads = await validateDappAccess.divine([manifest, ...accessors])
+    const failedAccessors = payloads.filter(isFailedAccessor) as WithMeta<FailedAccessor>[]
+    const registeredAccessors = payloads.filter(isRegisteredDappAccess) as WithMeta<RegisteredDappAccess>[]
+
+    if (failedAccessors.length > 0) {
+      console.error('Failed to register all dapp accessors', failedAccessors)
+    }
+
+    return registeredAccessors
+  }
+}

package/src/classes/registration/ValidateDappAccessDiviner/Config.ts

@@ -0,0 +1,19 @@
+import type { DivinerParams } from '@xyo-network/diviner-model'
+import type { PackageManifestPayload } from '@xyo-network/manifest'
+import type { DappPackageManifestPayload, DappParams, RegisteredDappAccess, UnregisteredDappAccess } from '@xyo-network/os-model'
+import type { Payload, WithMeta } from '@xyo-network/payload-model'
+import { isPayloadOfSchemaTypeWithMeta } from '@xyo-network/payload-model'
+
+export const FailedAccessorSchema = 'network.xyo.os.failed.accessor.registration' as const
+export type FailedAccessorSchema = typeof FailedAccessorSchema
+
+export type FailedAccessor = Payload<{ accessor: UnregisteredDappAccess; errorMessage: string }, FailedAccessorSchema>
+
+export const isFailedAccessor = isPayloadOfSchemaTypeWithMeta<FailedAccessor>(FailedAccessorSchema)
+
+export type ValidateDappAccessDivinerParams = DivinerParams & { dappParams: DappParams }
+export type ValidateDappAccessDivinerIn = DappPackageManifestPayload | PackageManifestPayload | UnregisteredDappAccess
+export type ValidateDappAccessDivinerOut = WithMeta<RegisteredDappAccess> | WithMeta<FailedAccessor>
+
+export const ValidateDappAccessDivinerConfigSchema = 'network.xyo.os.dapp.access.registration.validate' as const
+export type ValidateDappAccessDivinerConfigSchema = typeof ValidateDappAccessDivinerConfigSchema