@xyo-network/os-runtime 3.0.0

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

@@ -0,0 +1,132 @@
+import type { Address } from '@xylabs/hex'
+import { HDWallet } from '@xyo-network/account'
+import { AbstractDiviner } from '@xyo-network/diviner-abstract'
+import type { NodeManifestPayload, PackageManifestPayload } from '@xyo-network/manifest'
+import { ManifestWrapper, PackageManifestPayloadSchema } from '@xyo-network/manifest'
+import type { NodeInstance } from '@xyo-network/node-model'
+import type {
+  DappPackageManifestPayload,
+  DappParams,
+  RegisteredDappAccess,
+  UnregisteredDappAccess } from '@xyo-network/os-model'
+import {
+  isDappPackageManifestPayload,
+  isUnregisteredDappAccess,
+  RegisteredDappAccessSchema,
+} from '@xyo-network/os-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { WithMeta } from '@xyo-network/payload-model'
+
+import { ValidDappAccessInterfaces } from '../../../access-interfaces/index.ts'
+import type {
+  FailedAccessor,
+  ValidateDappAccessDivinerIn,
+  ValidateDappAccessDivinerOut,
+  ValidateDappAccessDivinerParams } from './Config.ts'
+import {
+  FailedAccessorSchema,
+  ValidateDappAccessDivinerConfigSchema,
+} from './Config.ts'
+
+// Validate the accessors of a dapp against the dapp access interfaces
+export class ValidateDappAccessDiviner<TParams extends ValidateDappAccessDivinerParams = ValidateDappAccessDivinerParams> extends AbstractDiviner<
+  TParams,
+  ValidateDappAccessDivinerIn,
+  ValidateDappAccessDivinerOut
+> {
+  static override configSchemas = [ValidateDappAccessDivinerConfigSchema]
+
+  protected override async divineHandler(payloads?: ValidateDappAccessDivinerIn[]): Promise<ValidateDappAccessDivinerOut[]> {
+    const dappManifest = payloads?.filter(isDappPackageManifestPayload) as DappPackageManifestPayload[]
+    const accessors = payloads?.filter(isUnregisteredDappAccess) as UnregisteredDappAccess[]
+    const dappParams = this.params.dappParams
+
+    if (dappManifest.length > 1) {
+      throw new Error('Only one dapp manifest payload is allowed')
+    }
+
+    if (!dappManifest || dappManifest.length === 0 || accessors?.length === 0) {
+      return []
+    }
+
+    const registeredAccessors: WithMeta<RegisteredDappAccess>[] = []
+    const failedAccessors: WithMeta<FailedAccessor>[] = []
+
+    for (const access of accessors) {
+      try {
+        if (access) {
+          const dappAccessInterface = ValidDappAccessInterfaces[access.name]
+          if (!dappAccessInterface) {
+            console.warn('Invalid dapp access interface', access.name)
+            continue
+          }
+
+          const dappManifestToTest = dappPackageManifestToPackageManifest(dappManifest[0])
+          const dappChildren = await getNodeChildren(dappManifestToTest, dappParams)
+          const interfaceChildren = await getNodeChildren(dappAccessInterface.manifest, dappParams)
+          const valid = compareChildren(interfaceChildren, dappChildren)
+          if (valid) {
+            const payload = await PayloadBuilder.build<RegisteredDappAccess>({
+              ...access,
+              schema: RegisteredDappAccessSchema,
+              timestamp: Date.now(),
+            })
+            registeredAccessors.push(payload)
+          } else {
+            const failedRegistration = await PayloadBuilder.build<FailedAccessor>({
+              accessor: access,
+              errorMessage: 'Invalid dapp access interface',
+              schema: FailedAccessorSchema,
+            })
+            failedAccessors.push(failedRegistration)
+          }
+        }
+      } catch (e) {
+        failedAccessors.push(
+          await PayloadBuilder.build<FailedAccessor>({ accessor: access, errorMessage: (e as Error).message, schema: FailedAccessorSchema }),
+        )
+      }
+    }
+
+    return [...registeredAccessors, ...failedAccessors]
+  }
+}
+
+const compareChildren = (interfaceChildren: Record<Address, string | null>[], dappChildren: Record<Address, string | null>[]) => {
+  return interfaceChildren.every(interfaceChild =>
+    Object.values(interfaceChild).every(interfaceChildName =>
+      dappChildren.some(dappChild => Object.values(dappChild).includes(interfaceChildName)),
+    ),
+  )
+}
+
+const dappPackageManifestToPackageManifest = (dappPackageManifest: DappPackageManifestPayload): PackageManifestPayload => {
+  return {
+    ...dappPackageManifest,
+    schema: PackageManifestPayloadSchema,
+  }
+}
+
+const getChildrenFromNode = async (node: NodeInstance) => {
+  const nodeManifest = (await node.state())?.[0] as NodeManifestPayload
+  return nodeManifest.status?.children
+}
+
+const getNodeChildren = async (manifestToTest: PackageManifestPayload, dappParams: DappParams) => {
+  const testNodes = await getNodeToTest(manifestToTest, dappParams)
+
+  const children: Record<Address, string | null>[] = []
+  for (const node of testNodes) {
+    const nodeChildren = await getChildrenFromNode(node)
+    if (nodeChildren) {
+      children.push(nodeChildren)
+    }
+  }
+
+  return children
+}
+
+const getNodeToTest = async (manifestToTest: PackageManifestPayload, dappParams: DappParams) => {
+  const dappManifestWrapper = new ManifestWrapper(manifestToTest, await HDWallet.random(), dappParams.locator)
+  return await dappManifestWrapper.loadNodes()
+}

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

@@ -0,0 +1,2 @@
+export * from './Config.ts'
+export * from './Diviner.ts'

package/src/classes/registration/index.ts

@@ -0,0 +1,2 @@
+export * from './DappRegistrationService.ts'
+export * from './DappRegistry.ts'

package/src/classes/settings/Caller.ts

@@ -0,0 +1,76 @@
+import { assertEx } from '@xylabs/assert'
+import { isEqual } from '@xylabs/lodash'
+import type { NodeBackground, WalletSeedPhrase, XyOsContext } from '@xyo-network/os-model'
+import type { WithMeta } from '@xyo-network/payload-model'
+
+import { buildUserWalletSeedPhrasePayload } from '../../utils/index.ts'
+import { OsSettingsCallerBase } from './CallerBase.ts'
+import { OsSettingsQueries } from './SettingsQueries.ts'
+
+export class OsSettingsCaller extends OsSettingsCallerBase {
+  constructor(context: XyOsContext) {
+    super(context)
+  }
+
+  /**
+   * Add a node background to the settings
+   * @param  {WithMeta<NodeBackground>} payload
+   */
+  async addNodeBackground(payload: WithMeta<NodeBackground>) {
+    const archivist = await this.getOsSettingsArchivist()
+    await archivist.insert([payload])
+  }
+
+  /**
+   * Add a wallet seed phrase to the settings
+   * @param  {WalletSeedPhrase} payload
+   */
+  async addWalletSeedPhrase(payload: WalletSeedPhrase) {
+    // NOTE: Since setting the seed phrase in OS takes precedence
+    // over the BIOS when the two phrases differ, we'll set the seed
+    // phrase in the OS first. That way if the latter saves fail we can
+    // still recover on next boot.
+
+    // Save seed phrase to OS settings
+    const archivist = await this.getOsSettingsArchivist()
+    await archivist.insert([payload])
+
+    // Save seed phrase to BIOS
+    const phrase = payload.mnemonic.mnemonic.join(' ')
+    await this.context.kernel?.bios?.seedPhraseStore.set('user', phrase)
+  }
+
+  /**
+   * Get the latest node background
+   */
+  async getLatestNodeBackground(): Promise<NodeBackground | null> {
+    const diviner = await this.getOsSettingsPayloadDiviner()
+    const [result] = (await OsSettingsQueries.getNodeBackground(diviner)) as WithMeta<NodeBackground>[]
+    return result ?? null
+  }
+
+  async getLatestUserWallet(): Promise<WalletSeedPhrase> {
+    // Get the seed phrase from the OS settings
+    const diviner = await this.getOsSettingsPayloadDiviner()
+    const storedSeedPhrasePayload = (await OsSettingsQueries.getLatestUserWallet(diviner)).pop()
+    // Get the seed phrase from the BIOS
+    const biosWalletSeedPhrase = assertEx(await this.context.kernel?.bios?.seedPhraseStore.get('user'), () => 'No user seed phrase found from BIOS')
+    const biosWalletSeedPhraseParts = biosWalletSeedPhrase.split(' ')
+    // If there is no stored seed phrase in the OS, use the seed phrase from the BIOS
+    if (!storedSeedPhrasePayload?.mnemonic?.mnemonic) {
+      // Create new wallet payload from BIOS seed phrase
+      const { payload: biosSeedPhrasePayload } = await buildUserWalletSeedPhrasePayload(biosWalletSeedPhrase)
+      // Store the BIOS seed phrase in the OS settings
+      await this.addWalletSeedPhrase(biosSeedPhrasePayload)
+      // Return BIOS seed phrase payload
+      return biosSeedPhrasePayload
+    } else if (!isEqual(storedSeedPhrasePayload.mnemonic.mnemonic, biosWalletSeedPhraseParts)) {
+      // If there is a seed phrase in the OS settings that does not match the BIOS seed phrase
+      // Update bios with existing user seed phrase
+      const updatedBiosSeedPhrase = storedSeedPhrasePayload.mnemonic.mnemonic.join(' ')
+      await this.context.kernel?.bios?.seedPhraseStore.set('user', updatedBiosSeedPhrase)
+    }
+    // Return stored seed phrase
+    return storedSeedPhrasePayload
+  }
+}

package/src/classes/settings/CallerBase.ts

@@ -0,0 +1,24 @@
+import { assertEx } from '@xylabs/assert'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import type { XyOsContext } from '@xyo-network/os-model'
+
+const OsSettingsArchivistModuleName = 'OsSettingsNode:OsSettingsArchivist'
+const OsSettingsArchivistPayloadDivinerModuleName = 'OsSettingsNode:OsSettingsArchivistPayloadDiviner'
+
+export class OsSettingsCallerBase {
+  constructor(protected context: XyOsContext) {}
+
+  async getOsSettingsArchivist() {
+    const mod = assertEx(await this.context.root.resolve(OsSettingsArchivistModuleName), () => `${OsSettingsArchivistModuleName} not found`)
+    return asArchivistInstance(mod, () => `${OsSettingsArchivistModuleName} is not an archivist`)
+  }
+
+  async getOsSettingsPayloadDiviner() {
+    const mod = assertEx(
+      await this.context.root.resolve(OsSettingsArchivistPayloadDivinerModuleName),
+      () => `${OsSettingsArchivistPayloadDivinerModuleName} not found`,
+    )
+    return asDivinerInstance(mod, () => `${OsSettingsArchivistPayloadDivinerModuleName} is not a diviner`)
+  }
+}

package/src/classes/settings/Resource.ts

@@ -0,0 +1,79 @@
+import { assertEx } from '@xylabs/assert'
+import type { NodeBackground, WalletSeedPhrase, XyOsContext } from '@xyo-network/os-model'
+import { isNodeBackground, isWalletSeedPhrase } from '@xyo-network/os-model'
+
+import type { Listener, ResourceStore } from '../../lib/index.ts'
+import { PayloadStore } from '../../lib/index.ts'
+import { OsSettingsCallerBase } from './CallerBase.ts'
+import { OsSettingsQueries } from './SettingsQueries.ts'
+
+export type OsSettingsResourceViews = 'wallets' | 'latestUserWallet' | 'nodeBackground'
+
+export class OsSettingsResource extends OsSettingsCallerBase implements ResourceStore<OsSettingsResourceViews> {
+  private _latestUserWalletListener: PayloadStore<WalletSeedPhrase> | undefined
+  private _nodeBackgroundListener: PayloadStore<NodeBackground> | undefined
+  private _walletsListener: PayloadStore<WalletSeedPhrase> | undefined
+
+  constructor(context: XyOsContext) {
+    super(context)
+  }
+
+  get latestUserWalletListener() {
+    return assertEx(this._latestUserWalletListener, () => 'Latest user wallet listener not set')
+  }
+
+  get nodeBackgroundListener() {
+    return assertEx(this._nodeBackgroundListener, () => 'Node background listener not set')
+  }
+
+  get subscriptions() {
+    return {
+      latestUserWallet: (cb: Listener) => this.walletsListener.subscribe(cb),
+      nodeBackground: (cb: Listener) => this.nodeBackgroundListener.subscribe(cb),
+      wallets: (cb: Listener) => this.walletsListener.subscribe(cb),
+    }
+  }
+
+  get views() {
+    return {
+      latestUserWallet: () => this.latestUserWalletListener.latest,
+      nodeBackground: () => this.nodeBackgroundListener.latest,
+      wallets: () => this.walletsListener.latest,
+    }
+  }
+
+  get walletsListener() {
+    return assertEx(this._walletsListener, () => 'Wallets listener not set')
+  }
+
+  cleanupListeners() {
+    this.walletsListener.cleanupListeners()
+    this.latestUserWalletListener.cleanupListeners()
+  }
+
+  /**
+   * start listeners
+   */
+  async start() {
+    const archivist = await this.getOsSettingsArchivist()
+    const diviner = await this.getOsSettingsPayloadDiviner()
+
+    this._walletsListener = await PayloadStore.create<WalletSeedPhrase>({
+      archivist,
+      getLatest: async () => await OsSettingsQueries.getWallets(diviner),
+      idFunction: isWalletSeedPhrase,
+    })
+
+    this._latestUserWalletListener = await PayloadStore.create<WalletSeedPhrase>({
+      archivist,
+      getLatest: async () => await OsSettingsQueries.getLatestUserWallet(diviner),
+      idFunction: isWalletSeedPhrase,
+    })
+
+    this._nodeBackgroundListener = await PayloadStore.create<NodeBackground>({
+      archivist,
+      getLatest: async () => await OsSettingsQueries.getNodeBackground(diviner),
+      idFunction: isNodeBackground,
+    })
+  }
+}

package/src/classes/settings/SettingsQueries.ts

@@ -0,0 +1,38 @@
+import type { DivinerInstance } from '@xyo-network/diviner-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type { NodeBackground, WalletSeedPhrase } from '@xyo-network/os-model'
+import { NodeBackgroundSchema, WalletSeedPhraseSchema } from '@xyo-network/os-model'
+import type { WithMeta } from '@xyo-network/payload-model'
+
+const NO_RESULTS: WithMeta<WalletSeedPhrase>[] = []
+
+export const OsSettingsQueries = {
+  async getLatestUserWallet(diviner: DivinerInstance) {
+    const query = {
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [WalletSeedPhraseSchema],
+    }
+    const results = (await diviner.divine([query])) as WithMeta<WalletSeedPhrase>[]
+    const wallet = results.find(payload => payload.$meta.label === 'userWallet')
+    return wallet ? [wallet] : NO_RESULTS
+  },
+  async getNodeBackground(diviner: DivinerInstance) {
+    const query = {
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [NodeBackgroundSchema],
+    }
+    return (await diviner.divine([query])) as WithMeta<NodeBackground>[]
+  },
+  async getWallets(diviner: DivinerInstance) {
+    const query = {
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [WalletSeedPhraseSchema],
+    }
+    return (await diviner.divine([query])) as WithMeta<WalletSeedPhrase>[]
+  },
+}

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

@@ -0,0 +1,30 @@
+import type { ValidOsAchievements } from '@xyo-network/os-model'
+import { OsBadgeSchema } from '@xyo-network/os-model'
+
+import { OsSettingsCallerBase } from '../CallerBase.ts'
+import { OsBadgeQueries } from './Queries.ts'
+
+export class OsBadgeCaller extends OsSettingsCallerBase {
+  /**
+   * @param  {ValidOsAchievements} achievement
+   */
+  async getBadge(achievement: ValidOsAchievements) {
+    const diviner = await this.getOsSettingsPayloadDiviner()
+    const results = await OsBadgeQueries.getBadge(achievement, diviner)
+    return results[0] ?? null
+  }
+
+  /**
+   * @param  {ValidOsAchievements} achievement
+   */
+  async saveBadge(achievement: ValidOsAchievements) {
+    const badge = {
+      achievement,
+      schema: OsBadgeSchema,
+      timestamp: Date.now(),
+    }
+
+    const archivist = await this.getOsSettingsArchivist()
+    return await archivist.insert([badge])
+  }
+}

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

@@ -0,0 +1,18 @@
+import type { DivinerInstance } from '@xyo-network/diviner-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type { OsBadge } from '@xyo-network/os-model'
+import { OsBadgeSchema } from '@xyo-network/os-model'
+
+export const OsBadgeQueries = {
+  getBadge: async (achievement: string, diviner: DivinerInstance) => {
+    const query = {
+      achievement,
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [OsBadgeSchema],
+    }
+
+    return (await diviner.divine([query])) as OsBadge[]
+  },
+}

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

@@ -0,0 +1,54 @@
+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

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

package/src/classes/settings/index.ts

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

package/src/classes/system/ManageSystemDapps.ts

@@ -0,0 +1,131 @@
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type { DappConfig, DappIcon, DappParams, DappSet, PayloadWithVersion, XyOsContext } from '@xyo-network/os-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { WithMeta } from '@xyo-network/payload-model'
+import semver from 'semver'
+
+import { OsCallerBase } from '../../OsCallerBase.ts'
+import { SystemDappQueries } from './Queries.ts'
+
+export type ErrorListener = (failedPayloads: DappConfig[]) => void
+export type DappSetsAndPayloads = { dappPayloads: (DappConfig | DappIcon)[]; dappSets: DappSet[] }
+
+/**
+ * Manage the installation of system dapps from payloads and return the built sets
+ */
+export class ManageSystemDapps extends OsCallerBase {
+  private onErrorCallbacks: ErrorListener[] = []
+
+  constructor(
+    context: XyOsContext,
+    private defaultSystemNames: string[],
+    private defaultSystemDapps: PayloadWithVersion[],
+    private defaultSystemDappParams: Record<string, DappParams>,
+    private locator?: ModuleFactoryLocator,
+    private developmentMode?: boolean,
+  ) {
+    super(context)
+  }
+
+  /**
+   * Add a callback to listen for errors throwing during system dapp registration
+   * @param  {ErrorListener} errorListener
+   */
+  addErrorListener(errorListener: ErrorListener) {
+    this.onErrorCallbacks.push(errorListener)
+  }
+
+  /**
+   * Installs the dapps into the OS and builds the appropriate DappSet
+   */
+  async install(): Promise<DappSet[]> {
+    await this.insertPayloads()
+    return await this.latestSets()
+  }
+
+  private async freshInstall(archivist: ArchivistInstance): Promise<void> {
+    await archivist.insert(this.defaultSystemDapps)
+  }
+
+  private async insertPayloads(): Promise<boolean> {
+    const archivist = this.developmentMode ? await this.getDappsArchivistDevelopment() : await this.getDappsArchivist()
+    try {
+      const allPayloads = (await archivist.all()) as WithMeta<DappIcon | DappConfig>[]
+      if (allPayloads.length === 0) {
+        await this.freshInstall(archivist)
+        return true
+      }
+
+      // only insert unseen system dapp payloads
+      for (const systemDappPayload of this.defaultSystemDapps) {
+        try {
+          const validSemver = semver.valid(systemDappPayload.version)
+          if (!validSemver) throw new Error('semver is a valid type (string) but was not able to be parsed')
+        } catch (e) {
+          console.error(`${systemDappPayload.version} does not appear to be a valid semver value`, e)
+          continue
+        }
+        const [existing] = await archivist.get([await PayloadBuilder.dataHash(systemDappPayload)])
+        if (existing) continue
+        await archivist.insert([systemDappPayload])
+      }
+      return true
+    } catch (e) {
+      console.error('error installing system dapps')
+      throw e
+    }
+  }
+
+  private async latestSets() {
+    const diviner = this.developmentMode ? await this.getDappsArchivistPayloadDivinerDevelopment() : await this.getDappsArchivistPayloadDiviner()
+    const dappSets: DappSet[] = []
+    const failedPayloads: DappConfig[] = []
+
+    for (const name of this.defaultSystemNames) {
+      try {
+        const dappConfig = await SystemDappQueries.getLatestConfig(diviner, name)
+        if (!dappConfig) {
+          console.error(`No config found for dapp ${name}`)
+          continue
+        }
+
+        const dappIcon = await SystemDappQueries.getLatestIcon(diviner, name, dappConfig.version)
+        if (!dappIcon) {
+          console.error(`No icon found for dapp ${dappConfig.name}`)
+          failedPayloads.push(dappConfig)
+          continue
+        }
+
+        const dappAccess = await SystemDappQueries.getDappAccess(diviner, name, dappConfig.version)
+
+        const dappParams = this.defaultSystemDappParams[dappConfig.name]
+        if (!dappParams) {
+          console.error(`No params found for dapp ${dappConfig.name}.  Did you forget to add it to OsDappParams?`)
+          failedPayloads.push(dappConfig)
+          continue
+        }
+
+        const dappWidgetConfigs = await SystemDappQueries.getWidgetConfigs(diviner, name, dappConfig.version)
+
+        dappSets.push({
+          dapp: {
+            accessors: dappAccess,
+            config: dappConfig,
+            icon: dappIcon,
+            params: dappParams,
+            widgetConfigs: dappWidgetConfigs,
+          },
+        })
+      } catch {
+        console.error(`Failed to build dapp ${name}`)
+      }
+    }
+
+    if (failedPayloads.length > 0) {
+      for (const cb of this.onErrorCallbacks) cb(failedPayloads)
+    }
+
+    return dappSets
+  }
+}

package/src/classes/system/Queries.ts

@@ -0,0 +1,69 @@
+import type { DivinerInstance } from '@xyo-network/diviner-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type {
+  DappConfig,
+  DappIcon,
+  DappId,
+  DappWidgetConfig,
+  UnregisteredDappAccess } from '@xyo-network/os-model'
+import {
+  DappConfigSchema,
+  DappIconSchema,
+  DappWidgetConfigSchema,
+  UnregisteredDappAccessSchema,
+} from '@xyo-network/os-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { WithMeta } from '@xyo-network/payload-model'
+
+export const SystemDappQueries = {
+  async getDappAccess(diviner: DivinerInstance, name: string, version: string) {
+    const accessQuery = {
+      order: 'desc',
+      registeringDappId: name,
+      schema: PayloadDivinerQuerySchema,
+      schemas: [UnregisteredDappAccessSchema],
+      version: version,
+    }
+    return (await diviner.divine([accessQuery])) as WithMeta<UnregisteredDappAccess>[]
+  },
+  async getLatestConfig(diviner: DivinerInstance, name: string) {
+    const configQuery = {
+      limit: 1,
+      name,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappConfigSchema],
+    }
+    const [dappConfig] = (await diviner.divine([configQuery])) as WithMeta<DappConfig>[]
+    return dappConfig
+  },
+  async getLatestIcon(diviner: DivinerInstance, name: string, version: string) {
+    const iconQuery = {
+      name,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappIconSchema],
+      version,
+    }
+    const [dappIcon] = (await diviner.divine([iconQuery])) as WithMeta<DappIcon>[]
+    return dappIcon
+  },
+  async getWidgetConfigs(diviner: DivinerInstance, name: DappId, version: string): Promise<WithMeta<DappWidgetConfig>[]> {
+    const widgetConfigQuery = {
+      dappId: name,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappWidgetConfigSchema],
+      version,
+    }
+    const widgetConfigs = (await diviner.divine([widgetConfigQuery])) as WithMeta<DappWidgetConfig>[]
+
+    const uniqueConfigs: Record<string, WithMeta<DappWidgetConfig>> = {}
+    for (const widgetConfig of widgetConfigs) {
+      const hash = await PayloadBuilder.dataHash(widgetConfig)
+      uniqueConfigs[widgetConfig.mode ?? hash] = widgetConfig
+    }
+
+    return Object.values(uniqueConfigs)
+  },
+}

package/src/classes/system/index.ts

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