@xyo-network/os-runtime 7.2.1 → 7.3.1

package/src/classes/menu/Queries.ts

@@ -1,60 +0,0 @@
-import type { DivinerInstance } from '@xyo-network/diviner-model'
-import type { PayloadDivinerQueryPayload } from '@xyo-network/diviner-payload-model'
-import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
-import type {
-  DappNavItem,
-  DappNavItemSelection,
-  DappNavMenuConfig,
-} from '@xyo-network/os-model'
-import {
-  DappNavItemSchema,
-  DappNavItemSelectionSchema,
-  DappNavMenuConfigSchema,
-} from '@xyo-network/os-model'
-import type { WithSources } from '@xyo-network/payload-model'
-
-const NO_ITEMS: unknown[] = []
-
-export const DappMenuQueries = {
-  async getMenuConfigs(diviner: DivinerInstance): Promise<WithSources<DappNavMenuConfig>[]> {
-    const query: PayloadDivinerQueryPayload = {
-      limit: 1,
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [DappNavMenuConfigSchema],
-    }
-    return (await diviner.divine([query])) as WithSources<DappNavMenuConfig>[]
-  },
-
-  async getMenuItems(diviner: DivinerInstance) {
-    const query: PayloadDivinerQueryPayload = {
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [DappNavItemSchema],
-    }
-
-    const results = (await diviner.divine([query])) as WithSources<DappNavItem>[]
-    return results.length > 0 ? results : (NO_ITEMS as WithSources<DappNavItem>[])
-  },
-
-  async getNavItemSelections(diviner: DivinerInstance) {
-    const query: PayloadDivinerQueryPayload = {
-      limit: 1,
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [DappNavItemSelectionSchema],
-    }
-    const results = (await diviner.divine([query])) as WithSources<DappNavItemSelection>[]
-    return results.length > 0 ? results : (NO_ITEMS as WithSources<DappNavItemSelection>[])
-  },
-
-  async getVisibleMenuItems(diviner: DivinerInstance) {
-    const query: PayloadDivinerQueryPayload = {
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [DappNavItemSchema],
-    }
-    const results = (await diviner.divine([query])) as WithSources<DappNavItem>[]
-    return results.filter(menuItem => menuItem.hidden !== true).toSorted((a, b) => ((a.weight ?? 0) > (b.weight ?? 0) ? 1 : -1))
-  },
-}

package/src/classes/menu/Resource.ts

@@ -1,105 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type {
-  DappNavItem, DappNavItemSelection, DappNavMenuConfig, XyOsContext,
-} from '@xyo-network/os-model'
-import { isDappNavItemSelection, isDappNavMenuConfig } from '@xyo-network/os-model'
-import type { Payload, WithSources } from '@xyo-network/payload-model'
-
-import { DappCaller } from '../../Caller.ts'
-import type { Listener, ResourceStore } from '../../lib/index.ts'
-import { PayloadStore } from '../../lib/index.ts'
-import { DappMenuQueries } from './Queries.ts'
-
-export type DappMenuResourceViews = 'menuConfigs' | 'menuItems' | 'menuItemsVisible' | 'menuItemSelections'
-
-export type NavPayloadType<T extends Payload = Payload> = WithSources<T>[]
-
-/**
- * A Repository for interacting with dapp menu items and config
- */
-export class DappMenuResource extends DappCaller implements ResourceStore<DappMenuResourceViews> {
-  private _menuConfigListener: PayloadStore<DappNavMenuConfig> | undefined
-  private _menuItemListener: PayloadStore<DappNavItem> | undefined
-  private _menuItemSelectionListener: PayloadStore<DappNavItemSelection> | undefined
-  private _menuItemVisibleListener: PayloadStore<DappNavItem> | undefined
-
-  constructor(xyOsContext: XyOsContext) {
-    super(xyOsContext)
-  }
-
-  get menuConfigListener() {
-    return assertEx(this._menuConfigListener, () => 'menuConfigListener note found')
-  }
-
-  get menuItemListener() {
-    return assertEx(this._menuItemListener, () => 'menuItemListener note found')
-  }
-
-  get menuItemSelectionListener() {
-    return assertEx(this._menuItemSelectionListener, () => 'menuItemSelectionListener note found')
-  }
-
-  get menuItemVisibleListener() {
-    return assertEx(this._menuItemVisibleListener, () => 'menuItemVisibleListener note found')
-  }
-
-  /** subscribe to latest set of payloads */
-  get subscriptions() {
-    return {
-      menuConfigs: (cb: Listener) => this.menuConfigListener.subscribe(cb),
-      menuItemSelections: (cb: Listener) => this.menuItemSelectionListener.subscribe(cb),
-      menuItems: (cb: Listener) => this.menuItemListener.subscribe(cb),
-      menuItemsVisible: (cb: Listener) => this.menuItemVisibleListener.subscribe(cb),
-    }
-  }
-
-  /**
-   * Return the latest menu payloads from the repository
-   */
-  get views() {
-    return {
-      menuConfigs: () => this.menuConfigListener.getSnapshot(),
-      menuItemSelections: () => this.menuItemSelectionListener.getSnapshot(),
-      menuItems: () => this.menuItemListener.getSnapshot(),
-      menuItemsVisible: () => this.menuItemVisibleListener.getSnapshot(),
-    }
-  }
-
-  /**
-   * Remove all listeners and reset their class members
-   */
-  cleanupListeners() {
-    this.menuConfigListener.cleanupListeners()
-    this.menuItemListener.cleanupListeners()
-    this.menuItemSelectionListener.cleanupListeners()
-  }
-
-  /**
-   * Start the resource
-   */
-  async start(): Promise<void> {
-    const dappArchivist = await this.getDappArchivist()
-    const dappArchivistPayloadDiviner = await this.getDappArchivistPayloadDiviner()
-
-    this._menuConfigListener = await PayloadStore.create<DappNavMenuConfig>({
-      archivist: dappArchivist,
-      getLatest: async () => await DappMenuQueries.getMenuConfigs(dappArchivistPayloadDiviner),
-      idFunction: isDappNavMenuConfig,
-    })
-    this._menuItemListener = await PayloadStore.create<DappNavItem>({
-      archivist: dappArchivist,
-      getLatest: async () => await DappMenuQueries.getMenuItems(dappArchivistPayloadDiviner),
-      idFunction: isDappNavMenuConfig,
-    })
-    this._menuItemVisibleListener = await PayloadStore.create<DappNavItem>({
-      archivist: dappArchivist,
-      getLatest: async () => await DappMenuQueries.getVisibleMenuItems(dappArchivistPayloadDiviner),
-      idFunction: isDappNavMenuConfig,
-    })
-    this._menuItemSelectionListener = await PayloadStore.create<DappNavItemSelection>({
-      archivist: dappArchivist,
-      getLatest: async () => await DappMenuQueries.getNavItemSelections(dappArchivistPayloadDiviner),
-      idFunction: isDappNavItemSelection,
-    })
-  }
-}

package/src/classes/menu/index.ts

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

package/src/classes/settings/Caller.ts

@@ -1,78 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type {
-  NodeBackground, WalletSeedPhrase, XyOsContext,
-} from '@xyo-network/os-model'
-
-import { isEqual } from '../../lib/index.ts'
-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 payload
-   */
-  async addNodeBackground(payload: NodeBackground) {
-    const archivist = await this.getOsSettingsArchivist()
-    await archivist.insert([payload])
-  }
-
-  /**
-   * Add a wallet seed phrase to the settings
-   * @param 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 NodeBackground[]
-    return result ?? null
-  }
-
-  async getLatestUserWallet(): Promise<WalletSeedPhrase> {
-    // Get the seed phrase from the OS settings
-    const diviner = await this.getOsSettingsPayloadDiviner()
-    const archivist = await this.getOsSettingsArchivist()
-    const storedSeedPhrasePayload = (await OsSettingsQueries.getLatestUserWallet(diviner, archivist)).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

@@ -1,27 +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'
-
-const OsSettingsArchivistModuleName = 'OsSettingsNode:OsSettingsArchivist'
-const OsSettingsArchivistPayloadDivinerModuleName = 'OsSettingsNode:OsSettingsArchivistPayloadDiviner'
-
-export class OsSettingsCallerBase {
-  protected context: XyOsContext
-  constructor(context: XyOsContext) {
-    this.context = context
-  }
-
-  async getOsSettingsArchivist() {
-    const mod = assertEx(await this.context.root.resolve(OsSettingsArchivistModuleName), () => `${OsSettingsArchivistModuleName} not found`)
-    return asArchivistInstance(mod, () => `${OsSettingsArchivistModuleName} is not an archivist`, { required: true })
-  }
-
-  async getOsSettingsPayloadDiviner() {
-    const mod = assertEx(
-      await this.context.root.resolve(OsSettingsArchivistPayloadDivinerModuleName),
-      () => `${OsSettingsArchivistPayloadDivinerModuleName} not found`,
-    )
-    return asDivinerInstance(mod, () => `${OsSettingsArchivistPayloadDivinerModuleName} is not a diviner`, { required: true })
-  }
-}

package/src/classes/settings/Resource.ts

@@ -1,81 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-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

@@ -1,56 +0,0 @@
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-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 { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { WithSources } from '@xyo-network/payload-model'
-
-const NO_RESULTS: WithSources<WalletSeedPhrase>[] = []
-
-export const OsSettingsQueries = {
-  async getLatestUserWallet(diviner: DivinerInstance, archivist?: ArchivistInstance): Promise<WalletSeedPhrase[]> {
-    const query = {
-      limit: 1,
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [WalletSeedPhraseSchema],
-    }
-    const results = (await diviner.divine([query])) as WalletSeedPhrase[]
-    const wallet = results.find(payload => payload.$label === 'userWallet')
-    if (wallet) return [wallet]
-    // Check for legacy payload and optionally migrate by re-minting it in the updates format.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const legacyWallet = results.find(payload => (payload as any).$meta.label === 'userWallet')
-    if (legacyWallet && archivist) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const legacyMeta = (legacyWallet as any).$meta
-      const newWalletPayloadFields = {
-        mnemonic: legacyWallet.mnemonic,
-        $label: legacyMeta.label,
-        $timestamp: legacyMeta.$timestamp,
-      }
-      const payload = new PayloadBuilder<WalletSeedPhrase>({ schema: WalletSeedPhraseSchema }).fields(newWalletPayloadFields).build()
-      await archivist.insert([payload])
-      return [payload]
-    }
-    return NO_RESULTS
-  },
-  async getNodeBackground(diviner: DivinerInstance) {
-    const query = {
-      limit: 1,
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [NodeBackgroundSchema],
-    }
-    return (await diviner.divine([query])) as WithSources<NodeBackground>[]
-  },
-  async getWallets(diviner: DivinerInstance) {
-    const query = {
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [WalletSeedPhraseSchema],
-    }
-    return (await diviner.divine([query])) as WithSources<WalletSeedPhrase>[]
-  },
-}

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

@@ -1,30 +0,0 @@
-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 achievement
-   */
-  async getBadge(achievement: ValidOsAchievements) {
-    const diviner = await this.getOsSettingsPayloadDiviner()
-    const results = await OsBadgeQueries.getBadge(achievement, diviner)
-    return results[0] ?? null
-  }
-
-  /**
-   * @param 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

@@ -1,19 +0,0 @@
-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'
-import type { WithSources } from '@xyo-network/payload-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 WithSources<OsBadge>[]
-  },
-}

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

@@ -1,50 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-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/sdk-js'
-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()
-  }
-}