@xyo-network/os-runtime 7.2.1 → 7.3.1

package/src/manifest/os-node.manifest.json

@@ -1,132 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/compilations/dapp-package-manifest-schema.json",
-  "nodes": [
-    {
-      "config": {
-        "accountPath": "0'",
-        "name": "OsNode",
-        "schema": "network.xyo.node.config"
-      },
-      "modules": {
-        "private": [],
-        "public": [
-          {
-            "config": {
-              "accountPath": "1'",
-              "name": "OSArchivist",
-              "dbName": "OSArchivist-2025-01-13",
-              "labels": {
-                "network.xyo.archivist.persistence.scope": "device"
-              },
-              "storeName": "payloads",
-              "parents": {
-                "read": [
-                  "Archivist"
-                ]
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "3'",
-              "name": "DappsArchivist",
-              "dbName": "DappsArchivist-2025-01-13",
-              "labels": {
-                "network.xyo.archivist.persistence.scope": "device"
-              },
-              "storeName": "payloads",
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "archivist": "DappsArchivist",
-              "dbVersion": 1,
-              "name": "DappsArchivistPayloadDiviner",
-              "labels": {
-                "network.xyo.archivist.persistence.scope": "device"
-              },
-              "schema": "network.xyo.diviner.payload.generic.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "4'",
-              "dbName": "IntentArchivist-2025-01-13",
-              "name": "IntentArchivist",
-              "storeName": "payloads",
-              "labels": {
-                "network.xyo.archivist.persistence.scope": "device"
-              },
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "7",
-              "archivist": "IntentArchivist",
-              "dbVersion": 1,
-              "name": "IntentArchivistPayloadDiviner",
-              "labels": {
-                "network.xyo.archivist.persistence.scope": "device"
-              },
-              "schema": "network.xyo.diviner.payload.generic.config",
-              "storeName": "payloads"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "8",
-              "name": "RegisteredDappInterfacesArchivist",
-              "schema": "network.xyo.archivist.memory.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "9'",
-              "name": "DappsArchivistDevelopment",
-              "parents": {
-                "write": [
-                  "DappsArchivist"
-                ]
-              },
-              "schema": "network.xyo.archivist.memory.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "10",
-              "archivist": "DappsArchivistDevelopment",
-              "dbVersion": 1,
-              "name": "DappsArchivistPayloadDivinerDevelopment",
-              "labels": {
-                "network.xyo.generic.payload.diviner": "GenericPayloadDiviner"
-              },
-              "schema": "network.xyo.diviner.payload.generic.config"
-            }
-          },
-          {
-            "config": {
-              "name": "OsPubSubNetworkStackNode",
-              "schema": "network.xyo.node.config"
-            }
-          },
-          {
-            "config": {
-              "name": "OsSettingsStackNode",
-              "schema": "network.xyo.node.config"
-            }
-          },
-          {
-            "config": {
-              "name": "OsXyoPublicNetworkStackNode",
-              "schema": "network.xyo.node.config"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  "schema": "network.xyo.manifest.package.dapp"
-}

package/src/manifests/dapp-window.manifest.json

@@ -1,36 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/compilations/dapp-package-manifest-schema.json",
-  "nodes": [
-    {
-      "config": {
-        "accountPath": "0'",
-        "name": "Dapp",
-        "schema": "network.xyo.node.config"
-      },
-      "modules": {
-        "private": [],
-        "public": [
-          {
-            "config": {
-              "accountPath": "0'/0'",
-              "name": "DappArchivist",
-              "schema": "network.xyo.archivist.memory.config"
-            }
-          },
-          {
-            "config": {
-              "accountPath": "0'/1'",
-              "archivist": "DappArchivist",
-              "labels": {
-                "network.xyo.generic.payload.diviner": "GenericPayloadDiviner"
-              },
-              "name": "DappArchivistPayloadDiviner",
-              "schema": "network.xyo.diviner.payload.generic.config"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  "schema": "network.xyo.manifest.package.dapp"
-}

package/src/manifests/index.ts

@@ -1 +0,0 @@
-export { default as DappWindowManifest } from './dapp-window.manifest.json' with { type: 'json' }

package/src/models/access/ValidDappAccessInterfaces.ts

@@ -1,6 +0,0 @@
-import type { DappAccessInterface } from '@xyo-network/os-model'
-import { RegisteredNames, RegisteredNamesInterface } from '@xyo-network/os-model'
-
-export type ValidDappAccessInterfaces = typeof RegisteredNames
-
-export const ValidDappAccessInterfaces: Record<string, DappAccessInterface> = { [RegisteredNames]: RegisteredNamesInterface }

package/src/models/access/index.ts

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

package/src/models/index.ts

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

package/src/profileModuleEvents.ts

@@ -1,43 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import type { QuerySendStartedEventArgs } from '@xyo-network/bridge-model'
-import type { ModuleInstance } from '@xyo-network/module-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-
-const DISPLAY_EVENT_COUNT_FREQUENCY = 100 as const
-
-export interface ProfileEventsData {
-  allEventCount: number
-  eventCounts: { [key: string | number | symbol]: number }
-}
-
-export const profileData: Record<Address, ProfileEventsData> = {}
-
-export const profileModuleEvents = (mod: ModuleInstance) => {
-  const modRef = new WeakRef(mod) // prevent memory leak
-  mod.onAny(async (eventName, args) => {
-    const mod = modRef.deref()
-    if (mod) {
-      const data = profileData[mod.address] ?? { allEventCount: 0, eventCounts: {} }
-      profileData[mod.address] = data
-      data.allEventCount += 1
-      data.eventCounts[eventName] = (data.eventCounts[eventName] ?? 0) + 1
-      if (eventName === 'querySendStarted') {
-        const { query, payloads = [] } = args as QuerySendStartedEventArgs
-        const pairs = await PayloadBuilder.dataHashPairs(payloads)
-        const foundPair = pairs.find(([, hash]) => hash === query.query)
-        if (foundPair) {
-          const [payload] = foundPair
-          console.log(`querySendStarted: ${payload.schema}`)
-        }
-      }
-      if (eventName === 'querySendFinished') {
-        const { query } = args as QuerySendStartedEventArgs
-        console.log(`querySendFinished: ${query.query}`)
-      }
-      if (data.allEventCount % DISPLAY_EVENT_COUNT_FREQUENCY === 0) {
-        console.log(`[PROFILE] - ${mod.id} Event Counts:`)
-        console.log(data.eventCounts)
-      }
-    }
-  })
-}

package/src/registration/DappRegistrationService.ts

@@ -1,180 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import {
-  forget, fulfilled, rejected,
-} from '@xylabs/sdk-js'
-import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
-import type { ModuleFactoryLocatorInstance } from '@xyo-network/module-model'
-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 { ManageSystemDapps } from '../system/index.ts'
-import { DappSeedPhraseRepository } from '../wallet/index.ts'
-import { XyOsDapp } from '../XyOsDapp.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 context: XyOsContext
-
-  private dappAccessRequestConnection = dappAccessRequestConnection()
-  private developmentMode?: boolean
-
-  private exposeDappRequestConnection = exposeDappRequestConnection()
-
-  private locator: ModuleFactoryLocatorInstance
-
-  private params: DappRegistrationServiceParams
-
-  constructor(
-    context: XyOsContext,
-    params?: DappRegistrationServiceParams,
-    locator: ModuleFactoryLocatorInstance = new ModuleFactoryLocator(),
-    developmentMode?: boolean,
-  ) {
-    this.context = context
-    this.params = params ?? {
-      dappNames: [], dappParams: {}, dappPayloads: [],
-    }
-    this.locator = locator
-    this.developmentMode = developmentMode
-
-    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()
-  }
-
-  async buildDapp(
-    manifest: DappPackageManifestPayload,
-    dappId = NameTransforms.slug(manifest.nodes[0]?.config.name),
-    name = NameTransforms.moduleName(manifest.nodes[0]?.config.name),
-  ): Promise<XyOsDappContext> {
-    const dapp = new XyOsDapp({
-      dapp: { id: dappId, name },
-      locator: this.locator,
-      manifest,
-      parent: this.context,
-      user: await this.getUser(),
-    }) 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)
-  }
-
-  /**
-   * A method to get the user property from context and eventually modify it before handing it to a dapp
-   * i.e. curating user-approved signers
-   */
-  private getUser(): Promisable<XyOsContext['user']> {
-    return this.context.user
-  }
-
-  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/registration/DappRegistry.ts

@@ -1,129 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type {
-  DappPackageManifestPayload,
-  DappParams,
-  RegisteredDapp,
-  RegisteredDappAccess,
-  UnregisteredDapp,
-  UnregisteredDappAccess,
-} from '@xyo-network/os-model'
-import {
-  DappRegisteredSchema,
-  DappRegisteredState,
-  isRegisteredDappAccess,
-} from '@xyo-network/os-model'
-import { HDWallet } from '@xyo-network/wallet'
-
-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()
-  private dappSeedPhraseRepository: DappSeedPhraseRepository
-
-  constructor(dappSeedPhraseRepository: DappSeedPhraseRepository) {
-    this.dappSeedPhraseRepository = dappSeedPhraseRepository
-  }
-
-  /**
-   * Register a Dapp with window manager and if successful, return its id
-   * @param dapp Manifest and UI of the Dapp to register
-   * @returns 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 FailedAccessor[]
-    const registeredAccessors = payloads.filter(isRegisteredDappAccess) as RegisteredDappAccess[]
-
-    if (failedAccessors.length > 0) {
-      console.error('Failed to register all dapp accessors', failedAccessors)
-    }
-
-    return registeredAccessors
-  }
-}

package/src/registration/ValidateDappAccessDiviner/Config.ts

@@ -1,24 +0,0 @@
-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 } from '@xyo-network/payload-model'
-import { asSchema, isPayloadOfSchemaType } from '@xyo-network/payload-model'
-
-export const FailedAccessorSchema = asSchema('network.xyo.os.failed.accessor.registration', true)
-export type FailedAccessorSchema = typeof FailedAccessorSchema
-
-export type FailedAccessor = Payload<{
-  accessor: UnregisteredDappAccess
-  errorMessage: string
-}, FailedAccessorSchema>
-
-export const isFailedAccessor = isPayloadOfSchemaType<FailedAccessor>(FailedAccessorSchema)
-
-export type ValidateDappAccessDivinerParams = DivinerParams & { dappParams: DappParams }
-export type ValidateDappAccessDivinerIn = DappPackageManifestPayload | PackageManifestPayload | UnregisteredDappAccess
-export type ValidateDappAccessDivinerOut = RegisteredDappAccess | FailedAccessor
-
-export const ValidateDappAccessDivinerConfigSchema = asSchema('network.xyo.os.dapp.access.registration.validate', true)
-export type ValidateDappAccessDivinerConfigSchema = typeof ValidateDappAccessDivinerConfigSchema