@xyo-network/os-runtime 3.0.0

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@xyo-network/os-runtime",
+  "author": {
+    "email": "support@xyo.network",
+    "name": "XYO Development Team",
+    "url": "https://xyo.network"
+  },
+  "bugs": {
+    "email": "support@xyo.network",
+    "url": "git+https://github.com/XYOracleNetwork/sdk-xyo-client-js/issues"
+  },
+  "dependencies": {
+    "@xylabs/assert": "^4.0.2",
+    "@xylabs/forget": "^4.0.2",
+    "@xylabs/hex": "^4.0.2",
+    "@xylabs/lodash": "^4.0.2",
+    "@xylabs/object": "^4.0.2",
+    "@xylabs/promise": "^4.0.2",
+    "@xyo-network/account": "^3.0.3",
+    "@xyo-network/archivist": "^3.0.3",
+    "@xyo-network/archivist-indexeddb": "^3.0.3",
+    "@xyo-network/archivist-model": "^3.0.3",
+    "@xyo-network/bridge-model": "^3.0.3",
+    "@xyo-network/diviner-abstract": "^3.0.3",
+    "@xyo-network/diviner-model": "^3.0.3",
+    "@xyo-network/diviner-payload-generic": "^3.0.3",
+    "@xyo-network/diviner-payload-indexeddb": "^3.0.3",
+    "@xyo-network/diviner-payload-model": "^3.0.3",
+    "@xyo-network/diviner-temporal-indexing-model": "^3.0.3",
+    "@xyo-network/kernel": "^3.0.0",
+    "@xyo-network/kernel-model": "^3.0.0",
+    "@xyo-network/manifest": "^3.0.3",
+    "@xyo-network/manifest-wrapper": "^3.0.3",
+    "@xyo-network/module-abstract": "^3.0.3",
+    "@xyo-network/module-events": "^3.0.3",
+    "@xyo-network/module-factory-locator": "^3.0.3",
+    "@xyo-network/module-model": "^3.0.3",
+    "@xyo-network/module-resolver": "^3.0.3",
+    "@xyo-network/node-model": "^3.0.3",
+    "@xyo-network/os-model": "^3.0.0",
+    "@xyo-network/payload-builder": "^3.0.3",
+    "@xyo-network/payload-model": "^3.0.3",
+    "@xyo-network/wallet-model": "^3.0.3",
+    "async-mutex": "^0.5.0",
+    "ethers": "^6.13.2",
+    "semver": "^7.6.3",
+    "uuid": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/semver": "^7.5.8",
+    "@types/uuid": "^10.0.0",
+    "@xylabs/ts-scripts-yarn3": "^4.0.0-rc.20",
+    "@xylabs/tsconfig": "^4.0.0-rc.20",
+    "typescript": "^5.5.4"
+  },
+  "description": "Primary SDK for using XYO Protocol 2.0",
+  "exports": {
+    ".": {
+      "types": "./dist/neutral/index.d.ts",
+      "default": "./dist/neutral/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "dist/neutral/index.mjs",
+  "types": "dist/neutral/index.d.ts",
+  "homepage": "https://xyo.network",
+  "license": "LGPL-3.0-only",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/XYOracleNetwork/sdk-xyo-client-js.git"
+  },
+  "sideEffects": false,
+  "version": "3.0.0",
+  "type": "module"
+}

package/src/Caller.ts

@@ -0,0 +1,221 @@
+import { assertEx } from '@xylabs/assert'
+import type { Hash } from '@xylabs/hex'
+import type { AccountInstance } from '@xyo-network/account'
+import { Account } from '@xyo-network/account'
+import type { PayloadDivinerQueryPayload } from '@xyo-network/diviner-payload-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type {
+  DappAccessRequest,
+  DappId,
+  DappInjectableParams,
+  DappIntent,
+  RegisteredDappAccess,
+  SigningKey,
+  SigningKeyFields,
+  XyOsContext } from '@xyo-network/os-model'
+import {
+  DappAccessRequestSchema,
+  DappInjectableParamsSchema,
+  DappIntentTypes,
+  DappMode,
+  RegisteredDappAccessSchema,
+  SigningKeySchema,
+} from '@xyo-network/os-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload, WithMeta } from '@xyo-network/payload-model'
+
+import { DappCallerBase } from './DappCallerBase.ts'
+import { DappDefaultsResourceQueries } from './DefaultsQueries.ts'
+import { DappIntentCaller } from './intent/index.ts'
+
+export class DappCaller extends DappCallerBase {
+  constructor(context: XyOsContext) {
+    super(context)
+  }
+
+  /**
+   * Add payloads to the dapp archivist
+   * @param  {Payload[]} payloads
+   * @param  {Boolean} force
+   */
+  async addPayloadsToDappArchivist(payloads: Payload[] = [], force: boolean = false) {
+    const dappArchivist = await this.getDappArchivist()
+    if (force) {
+      await dappArchivist.insert(payloads)
+    } else {
+      for (const payload of payloads) {
+        const hash = await PayloadBuilder.dataHash(payload)
+        const [existing] = await dappArchivist.get([hash])
+        if (existing) continue
+        await dappArchivist.insert([payload])
+      }
+    }
+  }
+
+  /**
+   * Build Access Request
+   * @param  {DappAccessRequest['mode']} mode
+   * @param  {Hash} registeredDappAccessHash
+   * @param  {string} requestingDappId
+   * @param  {string | undefined} destinationArchivist
+   */
+  buildAccessRequest(mode: DappAccessRequest['mode'], registeredDappAccessHash: Hash, requestingDappId: string, destinationArchivist?: string) {
+    const accessRequest: DappAccessRequest = {
+      destinationArchivist,
+      mode,
+      registeredDappAccessHash,
+      requestingDappId,
+      schema: DappAccessRequestSchema,
+      timestamp: Date.now(),
+    }
+    return accessRequest
+  }
+
+  /**
+   * Get all available dapp access requests
+   */
+  async getDappAccessPayloads() {
+    const diviner = await this.getDappArchivistPayloadDiviner()
+    const query: PayloadDivinerQueryPayload = {
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [RegisteredDappAccessSchema],
+    }
+
+    return diviner.divine([query])
+  }
+
+  /**
+   * Get the most recent dapp injectable params
+   * @returns Promise
+   */
+  async getDappInjectableParams(): Promise<DappInjectableParams[] | undefined> {
+    const diviner = await this.getDappArchivistPayloadDiviner()
+
+    return await DappDefaultsResourceQueries.getDappInjectableParamsFromRoute(diviner)
+  }
+
+  /**
+   * Get the most recent dapp intent
+   * @param  {string} name
+   */
+  async getRegisteredDappAccessByName(name: string) {
+    const diviner = await this.getDappArchivistPayloadDiviner()
+    const query = {
+      limit: 1,
+      name,
+      schema: PayloadDivinerQuerySchema,
+      schemas: [RegisteredDappAccessSchema],
+    }
+
+    const [payload] = assertEx(await diviner.divine([query]), () => 'Unable to find registered dapp access') as WithMeta<RegisteredDappAccess>[]
+    return payload
+  }
+
+  /**
+   * Get the user wallet
+   */
+  async getUserAccount(dappName: string): Promise<AccountInstance> {
+    const diviner = await this.getDappArchivistPayloadDiviner()
+    const query: PayloadDivinerQueryPayload<SigningKeyFields> = {
+      dappName,
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [SigningKeySchema],
+    }
+    const [payload] = assertEx(await diviner.divine([query]), () => 'Unable to find user wallet') as WithMeta<SigningKey>[]
+    if (payload) {
+      return await Account.fromPrivateKey(payload.privateKey)
+    } else {
+      throw new Error('Unable to find user wallet')
+    }
+  }
+
+  /**
+   * Get all wallets for the user
+   */
+  async getUserAccountsAll(): Promise<SigningKey[]> {
+    const diviner = await this.getDappArchivistPayloadDiviner()
+    const query: PayloadDivinerQueryPayload<SigningKeyFields> = {
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [SigningKeySchema],
+    }
+    const payloads = assertEx(await diviner.divine([query]), () => 'Unable to find user wallet') as WithMeta<SigningKey>[]
+    if (payloads?.length) {
+      return payloads
+    } else {
+      throw new Error('Unable to find user wallet')
+    }
+  }
+
+  /**
+   * Make Dapp Access Request
+   * @param {string} requestingDappId
+   * @param {string} registeredDappAccessHash
+   * @param {string} mode
+   * @param {string} destinationArchivist
+   */
+  async makeDappAccessRequest(
+    requestingDappId: DappAccessRequest['requestingDappId'],
+    registeredDappAccessHash: DappAccessRequest['registeredDappAccessHash'],
+    mode?: DappAccessRequest['mode'],
+    destinationArchivist?: DappAccessRequest['destinationArchivist'],
+  ) {
+    const archivist = await this.getDappArchivist()
+    const registeredDappAccessPayload = await archivist.get([registeredDappAccessHash])
+    if (!registeredDappAccessPayload) {
+      throw new Error('No registered dapp access found')
+    }
+    const accessRequest = this.buildAccessRequest(mode, registeredDappAccessHash, requestingDappId, destinationArchivist)
+    await archivist.insert([accessRequest])
+  }
+
+  /**
+   * Make Dapp Intent Request
+   * @param  {DappId} sourceDappId
+   * @param  {DappId} targetDappId
+   * @param  {DappIntentTypes=DappIntentTypes.Launch} intent
+   * @param  {DappIntent['params']} mode
+   */
+  async makeDappIntentRequest(
+    sourceDappId: DappId,
+    targetDappId: DappId,
+    intent: DappIntentTypes = DappIntentTypes.Launch,
+    mode: DappMode = DappMode.Window,
+    params?: DappIntent['params'],
+  ) {
+    if (!sourceDappId) {
+      throw new Error('No source dapp id provided, dApps must declare a sourceDappId')
+    }
+    const archivist = await this.getDappArchivist()
+    const dappIntent: DappIntent = DappIntentCaller.buildIntent(sourceDappId, intent, targetDappId, mode, params)
+    return await archivist.insert([dappIntent])
+  }
+
+  /**
+   * Set the dapp injectable params
+   *
+   * @param  {URLSearchParams} searchParams
+   * @param  {string} pathname
+   */
+  async setDappInjectableRouteParams(searchParams: URLSearchParams = new URLSearchParams(), pathname: string): Promise<void> {
+    const dappArchivist = await this.getDappArchivist()
+
+    const params: DappInjectableParams['params'] = {}
+    for (const [key, value] of searchParams.entries()) {
+      params[key] = value
+    }
+
+    const payload: DappInjectableParams = {
+      params,
+      path: pathname,
+      schema: DappInjectableParamsSchema,
+      source: 'route',
+      timestamp: Date.now(),
+    }
+
+    await dappArchivist.insert([payload])
+  }
+}

package/src/DappCallerBase.ts

@@ -0,0 +1,52 @@
+import { assertEx } from '@xylabs/assert'
+import { toJsonString } from '@xylabs/object'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import type { XyOsContext } from '@xyo-network/os-model'
+
+export const DappArchivistModuleName = 'DappArchivist'
+export const IntentArchivistModuleName = 'IntentArchivist'
+export const IntentArchivistPayloadDivinerModuleName = 'IntentArchivistPayloadDiviner'
+export const DappArchivistPayloadDivinerModuleName = 'DappArchivistPayloadDiviner'
+
+export class DappCallerBase {
+  constructor(protected context: XyOsContext) {}
+  /**
+   * Get the DappArchivist
+   */
+  async getDappArchivist() {
+    const mod = assertEx(
+      await this.context.root.resolve(DappArchivistModuleName),
+      () => `${DappArchivistModuleName} not found [${toJsonString(this.context.root.publicChildren())}]`,
+    )
+    return asArchivistInstance(mod, () => `${DappArchivistModuleName} is not an archivist`)
+  }
+
+  /**
+   * Get the DappArchivistPayloadDiviner
+   */
+  async getDappArchivistPayloadDiviner() {
+    const mod = assertEx(
+      await this.context.root.resolve(DappArchivistPayloadDivinerModuleName),
+      () => `${DappArchivistPayloadDivinerModuleName} not found`,
+    )
+    return asDivinerInstance(mod, () => `${DappArchivistPayloadDivinerModuleName} is not a diviner`)
+  }
+
+  /**
+   * Get the IntentArchivist
+   */
+  async getDappIntentArchivist() {
+    const mod = assertEx(await this.context.root.resolve(IntentArchivistModuleName), () => `${IntentArchivistModuleName} not found`)
+    return asArchivistInstance(mod, () => `${IntentArchivistModuleName} is not an archivist`)
+  }
+
+  // Get the IntentArchivistPayloadDiviner
+  async getDappIntentArchivistPayloadDiviner() {
+    const mod = assertEx(
+      await this.context.root.resolve(IntentArchivistPayloadDivinerModuleName),
+      () => `${IntentArchivistPayloadDivinerModuleName} not found`,
+    )
+    return asDivinerInstance(mod, () => `${IntentArchivistPayloadDivinerModuleName} is not a diviner`)
+  }
+}

package/src/DefaultsQueries.ts

@@ -0,0 +1,27 @@
+import type { DivinerInstance } from '@xyo-network/diviner-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type { DappInjectableParams, NodeOsInfo } from '@xyo-network/os-model'
+import { DappInjectableParamsSchema, NodeOsInfoSchema } from '@xyo-network/os-model'
+import type { WithMeta } from '@xyo-network/payload-model'
+
+export const DappDefaultsResourceQueries = {
+  async getDappInjectableParamsFromRoute(diviner: DivinerInstance) {
+    const query = {
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappInjectableParamsSchema],
+      source: 'route',
+    }
+    return (await diviner.divine([query])) as WithMeta<DappInjectableParams>[]
+  },
+  async getNodeOsInfo(diviner: DivinerInstance) {
+    const query = {
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [NodeOsInfoSchema],
+    }
+    return (await diviner.divine([query])) as WithMeta<NodeOsInfo>[]
+  },
+}

package/src/OsCallerBase.ts

@@ -0,0 +1,55 @@
+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'
+
+export const DappsArchivistModuleName = 'DappsArchivist'
+export const DappsArchivistDevelopmentModuleName = `${DappsArchivistModuleName}Development`
+export const DappsArchivistPayloadDivinerModuleName = 'DappsArchivistPayloadDiviner'
+export const DappsArchivistPayloadDevelopmentDivinerModuleName = `${DappsArchivistPayloadDivinerModuleName}Development`
+export const RegisteredDappInterfacesArchivistModuleName = 'RegisteredDappInterfacesArchivist'
+
+export class OsCallerBase {
+  constructor(protected context: XyOsContext) {}
+  // Get the dapps archivist
+  async getDappsArchivist() {
+    const mod = assertEx(await this.context.root.resolve(DappsArchivistModuleName), () => `${DappsArchivistModuleName} not found`)
+    return asArchivistInstance(mod, () => `${DappsArchivistModuleName} is not an archivist`)
+  }
+
+  // Get the dapps archivist development
+  async getDappsArchivistDevelopment() {
+    const mod = assertEx(
+      await this.context.root.resolve(DappsArchivistDevelopmentModuleName),
+      () => `${DappsArchivistDevelopmentModuleName} not found`,
+    )
+    return asArchivistInstance(mod, () => `${DappsArchivistDevelopmentModuleName} is not an archivist`)
+  }
+
+  // Get the dapps archivist payload diviner
+  async getDappsArchivistPayloadDiviner() {
+    const mod = assertEx(
+      await this.context.root.resolve(DappsArchivistPayloadDivinerModuleName),
+      () => `${DappsArchivistPayloadDivinerModuleName} not found`,
+    )
+    return asDivinerInstance(mod, () => `${DappsArchivistPayloadDivinerModuleName} is not a diviner`)
+  }
+
+  // Get the dapps archivist payload diviner development
+  async getDappsArchivistPayloadDivinerDevelopment() {
+    const mod = assertEx(
+      await this.context.root.resolve(DappsArchivistPayloadDevelopmentDivinerModuleName),
+      () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} not found`,
+    )
+    return asDivinerInstance(mod, () => `${DappsArchivistPayloadDevelopmentDivinerModuleName} is not a diviner`)
+  }
+
+  // Get the registered dapp interfaces archivist
+  async getRegisteredDappInterfacesArchivist() {
+    const mod = assertEx(
+      await this.context.root.resolve(RegisteredDappInterfacesArchivistModuleName),
+      () => `${RegisteredDappInterfacesArchivistModuleName} not found`,
+    )
+    return asArchivistInstance(mod, () => `${RegisteredDappInterfacesArchivistModuleName} is not an archivist`)
+  }
+}

package/src/PubSubBridgeCaller.ts

@@ -0,0 +1,30 @@
+import { assertEx } from '@xylabs/assert'
+import type { Address } from '@xylabs/hex'
+import type { BridgeExposeOptions } from '@xyo-network/bridge-model'
+import { asBridgeInstance } from '@xyo-network/bridge-model'
+import type { NodeInstance } from '@xyo-network/node-model'
+import { BridgedPubSubModuleName } from '@xyo-network/os-model'
+
+export class PubSubBridgeCaller {
+  constructor(private node: NodeInstance) {}
+
+  async exposeAddresses(addresses: Address[], options?: BridgeExposeOptions) {
+    const pubSubBridge = await this.getPubSubBridge()
+    for (const address of addresses) {
+      console.log(`Exposing: ${address}`)
+      await pubSubBridge.expose(address, options)
+    }
+  }
+
+  async unExposeAddresses(addresses: Address[]) {
+    const pubSubBridge = await this.getPubSubBridge()
+    for (const address of addresses) {
+      await pubSubBridge.unexpose?.(address)
+    }
+  }
+
+  private async getPubSubBridge() {
+    const mod = assertEx(await this.node.resolve(BridgedPubSubModuleName), () => `${BridgedPubSubModuleName} not found`)
+    return asBridgeInstance(mod, () => `${BridgedPubSubModuleName} is not a bridge`)
+  }
+}

package/src/XyOs.ts

@@ -0,0 +1,125 @@
+import { assertEx } from '@xylabs/assert'
+import type { Promisable } from '@xylabs/promise'
+import type { KernelExternal } from '@xyo-network/kernel-model'
+import type { PackageManifest } from '@xyo-network/manifest'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type { NodeInstance } from '@xyo-network/node-model'
+import type {
+  DappId,
+  DappPackageManifestPayload,
+  DappParams,
+  StackInitializer,
+  XyOsContext,
+  XyOsDappContext,
+  XyOsGlobal,
+} from '@xyo-network/os-model'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+
+import type { DappRegistrationServiceParams } from './classes/registration/index.ts'
+import { DappRegistrationService } from './classes/registration/index.ts'
+import type { MonitorEventConfig, XyOsMonitor } from './helpers/index.ts'
+import { NameTransforms } from './lib/index.ts'
+import { loadOsNode } from './loadOsNode.ts'
+import type { OsPubSubNetworkStack } from './stack/index.ts'
+import { OsStackMap, StackManager } from './stack/index.ts'
+import type { XyOsContextParams } from './XyOsBase.ts'
+import { XyOsContextBase } from './XyOsBase.ts'
+
+export interface XyOsParams<TManifest extends PackageManifest = PackageManifest> extends XyOsContextParams<TManifest> {
+  kernel: XyOsContext['kernel']
+}
+
+export class XyOs extends XyOsContextBase<XyOsParams> implements XyOsContext {
+  protected _exposedNode: NodeInstance | undefined
+  protected _exposedNodeOuter: NodeInstance | undefined
+  protected _locator: ModuleFactoryLocator
+  protected dappRegistrationService: DappRegistrationService
+  private stackManager: StackManager
+
+  constructor(params: XyOsParams, dappsConfiguration?: DappRegistrationServiceParams, developmentMode?: boolean) {
+    super(params)
+    this._locator = params.locator ?? new ModuleFactoryLocator()
+    this.stackManager = new StackManager(OsStackMap)
+    this.dappRegistrationService = new DappRegistrationService(this, dappsConfiguration, this.locator, developmentMode)
+  }
+
+  static get monitoring(): XyOsMonitor | undefined {
+    return
+  }
+
+  static get xyOsGlobal(): XyOsGlobal {
+    return getXyOsGlobal()
+  }
+
+  override get bios(): KernelExternal['bios'] | undefined {
+    return assertEx(this.params.kernel?.bios, () => 'Missing bios')
+  }
+
+  override get exposedNode() {
+    return this.stackManager.getStack<OsPubSubNetworkStack>('osPubSubNetworkStack')?.exposedNode
+  }
+
+  override get exposedNodeOuter() {
+    return this.stackManager.getStack<OsPubSubNetworkStack>('osPubSubNetworkStack')?.exposedNodeOuter
+  }
+
+  override get kernel(): XyOsContext['kernel'] | undefined {
+    return assertEx(this.params.kernel, () => 'Missing kernel')
+  }
+
+  get locator() {
+    return this._locator
+  }
+
+  static async monitor<T>(fn: () => Promise<T>, eventConfig: MonitorEventConfig): Promise<T> {
+    const { name, additionalProperties } = eventConfig
+    const monitor = this.monitoring
+    monitor?.startTimer(name)
+    const result = await fn()
+    monitor?.stopTimer({ additionalProperties, name })
+
+    return result
+  }
+
+  override async boot(wallet: WalletInstance, locator = new ModuleFactoryLocator()): Promise<void> {
+    console.warn('XyOs:boot', wallet.address)
+    const fullLocator = this._locator.merge(locator)
+    return await this._bootMutex.runExclusive(async () => {
+      assertEx(this._root === undefined, () => 'XyOs already booted')
+      const [root] = await XyOs.monitor(async () => await loadOsNode(wallet, fullLocator), { name: 'Load XyOs' })
+      this._root = root
+
+      this.stackManager.initialize(this)
+    })
+  }
+
+  override buildDapp(
+    manifest: DappPackageManifestPayload,
+    dappId = NameTransforms.slug(manifest.nodes[0]?.config.name),
+    name = NameTransforms.moduleName(manifest.nodes[0]?.config.name),
+  ): Promisable<XyOsDappContext> {
+    return this.dappRegistrationService.buildDapp(manifest, dappId, name)
+  }
+
+  override dappByName(dappId: DappId): Promisable<XyOsDappContext | undefined> {
+    return this.dappRegistrationService.builtDapps[dappId]
+  }
+
+  override getDappParams(dappId: DappId): DappParams {
+    return this.dappRegistrationService.getParamsForRegisteredDapp(dappId)
+  }
+
+  override getStack(stackName: string): StackInitializer {
+    return assertEx(this.stackManager.getStack(stackName), () => `Stack not found: ${stackName}`)
+  }
+
+  override async monitor<T>(fn: () => Promise<T>, eventConfig: MonitorEventConfig): Promise<T> {
+    return await XyOs.monitor<T>(fn, eventConfig)
+  }
+
+  override shutdown() {
+    assertEx(this._root !== undefined, () => 'XyOs not booted')
+    this._root = undefined
+    this.stackManager.stop()
+  }
+}