@xyo-network/os-runtime 7.2.0 → 7.3.0

package/src/classes/dapp/DefaultsResource.ts

@@ -1,67 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type {
-  DappInjectableParams, NodeOsInfo, XyOsContext,
-} from '@xyo-network/os-model'
-import { isDappInjectableParams, isNodeOsInfo } from '@xyo-network/os-model'
-
-import { DappCallerBase } from '../../DappCallerBase.ts'
-import { DappDefaultsResourceQueries } from '../../DefaultsQueries.ts'
-import type { Listener, ResourceStore } from '../../lib/index.ts'
-import { PayloadStore } from '../../lib/index.ts'
-
-export type DappDefaultsResourceViews = 'nodeOsInfo' | 'dappInjectableParamsFromRoute'
-
-/**
- * A resource for interacting with Dapp Defaults
- */
-export class DappDefaultsResource extends DappCallerBase implements ResourceStore<DappDefaultsResourceViews> {
-  private _dappInjectableParamsFromRouteListener: PayloadStore<DappInjectableParams> | undefined
-  private _nodeOsInfoListener: PayloadStore<NodeOsInfo> | undefined
-
-  constructor(context: XyOsContext) {
-    super(context)
-  }
-
-  get dappInjectableParamsFromRouteListener() {
-    return assertEx(this._dappInjectableParamsFromRouteListener, () => 'DappInjectableParams not found')
-  }
-
-  get nodeOsInfoListener() {
-    return assertEx(this._nodeOsInfoListener, () => 'NodeOsInfo not found')
-  }
-
-  get subscriptions() {
-    return {
-      dappInjectableParamsFromRoute: (cb: Listener) => this.dappInjectableParamsFromRouteListener.subscribe(cb),
-      nodeOsInfo: (cb: Listener) => this.nodeOsInfoListener.subscribe(cb),
-    }
-  }
-
-  get views() {
-    return {
-      dappInjectableParamsFromRoute: () => this.dappInjectableParamsFromRouteListener.getSnapshot(),
-      nodeOsInfo: () => this.nodeOsInfoListener.getSnapshot(),
-    }
-  }
-
-  cleanupListeners() {
-    this.nodeOsInfoListener.cleanupListeners()
-  }
-
-  async start() {
-    const archivist = await this.getDappArchivist()
-    const diviner = await this.getDappArchivistPayloadDiviner()
-
-    this._nodeOsInfoListener = await PayloadStore.create<NodeOsInfo>({
-      archivist,
-      getLatest: async () => await DappDefaultsResourceQueries.getNodeOsInfo(diviner),
-      idFunction: isNodeOsInfo,
-    })
-
-    this._dappInjectableParamsFromRouteListener = await PayloadStore.create<DappInjectableParams>({
-      archivist,
-      getLatest: async () => await DappDefaultsResourceQueries.getDappInjectableParamsFromRoute(diviner),
-      idFunction: isDappInjectableParams,
-    })
-  }
-}

package/src/classes/dapp/index.ts

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

package/src/classes/index.ts

@@ -1,4 +0,0 @@
-export * from './dapp/index.ts'
-export * from './lib/index.ts'
-export * from './menu/index.ts'
-export * from './settings/index.ts'

package/src/classes/lib/DappCreatorParams.ts

@@ -1,18 +0,0 @@
-import type { ModuleManifest } from '@xyo-network/manifest'
-import type { ModuleFactoryLocatorInstance } from '@xyo-network/module-model'
-import type {
-  DappName, DappPackageManifestPayload, XyOsContext,
-} from '@xyo-network/os-model'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-
-export type DappNodesCreatorParams = {
-  config: {
-    dappName: DappName
-    payload: DappPackageManifestPayload
-    privateChildren?: ModuleManifest[]
-    publicChildren?: ModuleManifest[]
-  }
-  context: XyOsContext
-  locator?: ModuleFactoryLocatorInstance
-  wallet: WalletInstance
-}

package/src/classes/lib/Insertable.ts

@@ -1,10 +0,0 @@
-import type { DappName, XyOsContext } from '@xyo-network/os-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-export interface InsertableConstructor { new (_xyOs: XyOsContext, dappName: DappName): DefaultPayloadsInsertable }
-
-type InsertableConstructorParams = ConstructorParameters<InsertableConstructor>
-
-export interface DefaultPayloadsInsertable { payloads(): Promise<Payload[]> }
-
-export const createInsertable = (insertable: InsertableConstructor, ...params: InsertableConstructorParams) => new insertable(...params)

package/src/classes/lib/index.ts

@@ -1,2 +0,0 @@
-export * from './DappCreatorParams.ts'
-export * from './Insertable.ts'

package/src/classes/menu/Caller.ts

@@ -1,77 +0,0 @@
-import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
-import type {
-  DappInjectableParams,
-  DappNavItemSelection,
-  XyOsContext,
-} from '@xyo-network/os-model'
-import {
-  DappInjectableParamsSchema,
-  DappNavItemSelectionSchema,
-} from '@xyo-network/os-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload } from '@xyo-network/payload-model'
-
-import { DappCaller } from '../../Caller.ts'
-
-export class DappMenuCaller extends DappCaller {
-  constructor(context: XyOsContext) {
-    super(context)
-  }
-
-  /**
-   * Add new Payloads to the dappArchivist if they haven't already
-   *
-   * @param  {Payload[]} payloads
-   */
-  async add(payloads: Payload[], force = false) {
-    const dappArchivist = await this.getDappArchivist()
-
-    for (const payload of payloads) {
-      const hash = await PayloadBuilder.dataHash(payload)
-      const [existing] = await dappArchivist.get([hash])
-      if (!existing || force) {
-        await dappArchivist.insert(payloads)
-      }
-    }
-  }
-
-  async currentNavSelection(): Promise<DappNavItemSelection[] | undefined> {
-    const diviner = await this.getDappArchivistPayloadDiviner()
-    const query = {
-      limit: 1,
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [DappNavItemSelectionSchema],
-    }
-
-    return (await diviner.divine([query])) as DappNavItemSelection[]
-  }
-
-  /*
-   * Indicate to the system that a nav item was selected
-   *
-   * @param  {string} path
-   * @params {string} injectableParamsPath
-   * @returns Promise
-   */
-  async makeNavItemSelection(path: string, injectableParamsPath?: string): Promise<void> {
-    const dappArchivist = await this.getDappArchivist()
-    const payload: DappNavItemSelection = {
-      path,
-      schema: DappNavItemSelectionSchema,
-      timestamp: Date.now(),
-    }
-    await dappArchivist.insert([payload])
-
-    if (injectableParamsPath) {
-      const injectableParams: DappInjectableParams = {
-        params: {},
-        path: injectableParamsPath,
-        schema: DappInjectableParamsSchema,
-        source: 'route',
-        timestamp: Date.now(),
-      }
-      await dappArchivist.insert([injectableParams])
-    }
-  }
-}

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/assert'
-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/assert'
-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  {NodeBackground} payload
-   */
-  async addNodeBackground(payload: 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 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/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 {
-  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/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

@@ -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  {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

@@ -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>[]
-  },
-}