@xyo-network/os-runtime 7.2.1 → 7.3.1

package/src/registration/ValidateDappAccessDiviner/Diviner.ts

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

package/src/registration/ValidateDappAccessDiviner/index.ts

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

package/src/registration/index.ts

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

package/src/scripts/xyos/command/config.ts

@@ -1,19 +0,0 @@
-import type { Argv } from 'yargs'
-
-export const commandConfig = (argv: Argv) => {
-  return argv.command('config [action] <target>', 'Create an xyos project', (yargs) => {
-    return yargs
-      .positional('action', {
-        choices: ['create', 'validate', 'display'],
-        description: 'Action to take on config',
-        type: 'string',
-      })
-      .positional('target', {
-        description: 'Location of config file',
-        type: 'string',
-      })
-  }, async ({ action, target }) => {
-    console.log(`Taking action [${action}] on manifest at ${target}`)
-    return await Promise.resolve()
-  })
-}

package/src/scripts/xyos/command/create.ts

@@ -1,22 +0,0 @@
-import type { Argv } from 'yargs'
-
-import type { TemplateName } from '../lib/index.ts'
-import { createFromTemplate } from '../lib/index.ts'
-
-export const commandCreate = (argv: Argv) => {
-  return argv.command('create [template] <target>', 'Create an xyos project', (yargs) => {
-    return yargs
-      .positional('template', {
-        choices: ['react', 'headless', 'dapp', 'diviner', 'witness'] as TemplateName[],
-        description: 'Template to use',
-        type: 'string',
-      })
-      .positional('target', {
-        description: 'Location into which to create the template project',
-        type: 'string',
-      })
-  }, async ({ template, target }) => {
-    console.log(`Using template ${template} at location ${target}`)
-    return await createFromTemplate({ target, template })
-  })
-}

package/src/scripts/xyos/command/index.ts

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-// TODO - figure out how to keep the above line from being removed by the build process
-
-export * from './config.ts'
-export * from './create.ts'
-export * from './manifest.ts'
-export * from './start.ts'

package/src/scripts/xyos/command/manifest.ts

@@ -1,19 +0,0 @@
-import type { Argv } from 'yargs'
-
-export const commandManifest = (argv: Argv) => {
-  return argv.command('manifest [action] <target>', 'Create an xyos project', (yargs) => {
-    return yargs
-      .positional('action', {
-        choices: ['create', 'validate', 'display'],
-        description: 'Action to take on manifest',
-        type: 'string',
-      })
-      .positional('target', {
-        description: 'Location of manifest file',
-        type: 'string',
-      })
-  }, async ({ action, target }) => {
-    console.log(`Taking action [${action}] on manifest at ${target}`)
-    return await Promise.resolve()
-  })
-}

package/src/scripts/xyos/command/start.ts

@@ -1,35 +0,0 @@
-import type { NativeKernelDrivers } from '@xyo-network/kernel-model'
-import type { Argv } from 'yargs'
-
-import { headless } from '../lib/index.ts'
-
-export const commandStart = (argv: Argv) => {
-  return argv.command('start', 'Start xyOS in headless mode', (yargs) => {
-    return yargs
-      .option('config', {
-        alias: 'c',
-        description: 'Config file to use',
-        type: 'string',
-      }).option('manifest', {
-        alias: 'm',
-        description: 'Manifest file to use',
-        type: 'string',
-      }).option('kernelDriver', {
-        alias: 'k',
-        description: 'Kernel driver to load',
-        type: 'string',
-      })
-  }, async ({
-    config, manifest, kernelDriver,
-  }) => {
-    if (config) {
-      console.log(`Using config: ${config}`)
-    }
-    if (config) {
-      console.log(`Using manifest: ${manifest}`)
-    }
-    await headless({
-      manifest, config, kernelDrivers: kernelDriver ? [kernelDriver as NativeKernelDrivers] : [],
-    })
-  })
-}

package/src/scripts/xyos/index.ts

@@ -1,31 +0,0 @@
-import yargs from 'yargs'
-import { hideBin } from 'yargs/helpers'
-
-import {
-  commandConfig, commandCreate, commandManifest, commandStart,
-} from './command/index.ts'
-
-(
-  (
-    commandManifest(
-      commandConfig(
-        commandCreate(
-          commandStart(
-            yargs(
-              hideBin(
-                process.argv,
-              ),
-            ),
-          ),
-        ),
-      ),
-    )
-      .usage('Usage: $0 <command> [options]')
-      .scriptName('xyos')
-      .demandCommand(1)
-      .parse()
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ) as Promise<any>
-).catch(
-  console.error,
-)

package/src/scripts/xyos/lib/createFromTemplate.ts

@@ -1,11 +0,0 @@
-export type TemplateName = 'react' | 'headless' | 'dapp' | 'diviner' | 'witness'
-
-export interface CreateFromTemplateParams {
-  target?: string
-  template?: TemplateName
-}
-
-export const createFromTemplate = async ({ target, template }: CreateFromTemplateParams) => {
-  console.log('Creating from template', template, 'at', target)
-  return await Promise.resolve()
-}

package/src/scripts/xyos/lib/headless.ts

@@ -1,68 +0,0 @@
-import fs from 'node:fs'
-
-import { boot } from '@xyo-network/bios'
-import { Kernel } from '@xyo-network/kernel'
-import type { NativeKernelDrivers } from '@xyo-network/kernel-model'
-import type { PackageManifest } from '@xyo-network/manifest'
-import { HDWallet } from '@xyo-network/wallet'
-import chalk from 'chalk'
-import { cosmiconfig } from 'cosmiconfig'
-import { TypeScriptLoader } from 'cosmiconfig-typescript-loader'
-import tk from 'terminal-kit'
-
-const { terminal } = tk
-
-import { XyOs } from '../../../XyOs.ts'
-
-const terminate = () => {
-  terminal.grabInput(false)
-  setTimeout(function () {
-    // eslint-disable-next-line unicorn/no-process-exit
-    process.exit(0)
-  }, 100)
-}
-
-interface XyOsConfig {
-  developmentMode?: boolean
-  manifest?: string | PackageManifest
-}
-
-export interface HeadlessParams {
-  config?: string
-  kernelDrivers?: NativeKernelDrivers[]
-  manifest?: string
-}
-
-export const headless = async ({
-  manifest, config, kernelDrivers,
-}: HeadlessParams = {}) => {
-  console.log(chalk.green('Starting Headless xyOS...'))
-  const configExplorer = cosmiconfig('xyos', { cache: true, loaders: { '.ts': TypeScriptLoader() } })
-  const configResult = await (config ? configExplorer.load(config) : configExplorer.search())
-  const xyosConfig: XyOsConfig = (configResult?.config ?? {}) as XyOsConfig
-  const manifestToLoad: string | undefined = manifest ?? (typeof xyosConfig.manifest === 'string' ? xyosConfig.manifest : undefined)
-  const manifestObject: PackageManifest | undefined = manifestToLoad
-    ? JSON.parse(fs.readFileSync(manifestToLoad, 'utf8')) as PackageManifest
-    : typeof xyosConfig.manifest === 'object' ? xyosConfig.manifest : undefined
-
-  const osWallet = await HDWallet.random()
-  const kernel = new Kernel({ logColor: 'cyan', logger: console })
-  await kernel.boot(await boot(), { kernelDrivers })
-  const xyOs = new XyOs({
-    kernel,
-    stackMap: {},
-    manifest: manifestObject,
-    developmentMode: xyosConfig.developmentMode,
-  })
-  await xyOs.boot(osWallet)
-  console.log(chalk.green('Started Headless xyOS...'))
-
-  terminal.grabInput({ mouse: 'button' })
-
-  terminal.on('key', function (name: string) {
-    console.log("'key' event:", name)
-    if (name === 'CTRL_C') {
-      terminate()
-    }
-  })
-}

package/src/scripts/xyos/lib/index.ts

@@ -1,2 +0,0 @@
-export * from './createFromTemplate.ts'
-export * from './headless.ts'

package/src/signer/Signer.spec.ts

@@ -1,65 +0,0 @@
-import type { WalletKindSignerPaths } from '@xyo-network/os-model'
-import type { WalletKind, WalletSeedPhraseStore } from '@xyo-network/storage-model'
-import { HDWallet } from '@xyo-network/wallet'
-import {
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-} from 'vitest'
-
-import { Signers } from './Signers.ts'
-
-describe('Signer', () => {
-  let osWallet: string
-  let userWallet: string
-  let seedPhraseStore: WalletSeedPhraseStore
-
-  const testSigner1Path = '0/0'
-  const testSigner2Path = '0/1'
-  const testSigner3Path = '0/2'
-  const testSigner4Path = '0/3'
-
-  const osPaths = new Map([['testSigner0', testSigner1Path], ['testSigner1', testSigner2Path]])
-  const userPaths = new Map([['testSigner2', testSigner3Path], ['testSigner3', testSigner4Path]])
-  const paths: WalletKindSignerPaths = new Map([['os', osPaths], ['user', userPaths]])
-
-  let signers: Signers
-
-  beforeEach(async () => {
-    osWallet = HDWallet.generateMnemonic()
-    userWallet = HDWallet.generateMnemonic()
-    seedPhraseStore = {
-      get: vi.fn().mockImplementation((key: WalletKind) => {
-        if (key === 'os') {
-          return osWallet
-        }
-        if (key === 'user') {
-          return userWallet
-        }
-        return
-      }),
-      set: vi.fn(),
-      delete: vi.fn(),
-    }
-    signers = new Signers(paths, seedPhraseStore)
-    await signers.initialize()
-  })
-
-  it('should initialize signers', () => {
-    expect(signers.getSigner('os', 'testSigner0')).toBeDefined()
-    expect(signers.getSigner('os', 'testSigner1')).toBeDefined()
-    expect(signers.getSigner('user', 'testSigner2')).toBeDefined()
-    expect(signers.getSigner('user', 'testSigner3')).toBeDefined()
-  })
-
-  it('should return undefined for non-existent signer', () => {
-    expect(signers.getSigner('os', 'nonExistentSigner')).toBeUndefined()
-  })
-
-  it('should use paths correctly', async () => {
-    const osWalletAddress = (await (await HDWallet.fromPhrase(osWallet)).derivePath(testSigner1Path)).address
-    expect(signers.getSigner('os', 'testSigner0')?.address).toBe(osWalletAddress)
-  })
-})

package/src/signer/Signers.ts

@@ -1,74 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import { type AccountInstance } from '@xyo-network/account-model'
-import type {
-  SignerAccounts, SignersExternal, WalletKindSignerPaths,
-} from '@xyo-network/os-model'
-import type {
-  WalletKind,
-  WalletSeedPhraseStore,
-} from '@xyo-network/storage-model'
-import { HDWallet } from '@xyo-network/wallet'
-
-export class Signers implements SignersExternal {
-  private _paths: WalletKindSignerPaths
-  private _signerAccounts: Map<WalletKind, SignerAccounts>
-  private _walletStore: WalletSeedPhraseStore
-
-  constructor(paths: WalletKindSignerPaths, walletStore: WalletSeedPhraseStore) {
-    this._paths = paths
-    this._walletStore = walletStore
-    this._signerAccounts = new Map()
-  }
-
-  private get paths(): WalletKindSignerPaths {
-    return assertEx(this._paths, () => 'Paths not initialized')
-  }
-
-  private get signerAccounts(): Map<WalletKind, SignerAccounts> {
-    return assertEx(this._signerAccounts, () => 'Signer accounts not initialized')
-  }
-
-  private get walletStore(): WalletSeedPhraseStore {
-    return assertEx(this._walletStore, () => 'Wallet store not initialized')
-  }
-
-  getSigner(walletKind: WalletKind, signer: string): AccountInstance | undefined {
-    return this.signerAccounts.get(walletKind)?.get(signer)
-  }
-
-  getWalletKindSigner(walletKind: WalletKind): SignerAccounts | undefined {
-    return this.signerAccounts.get(walletKind)
-  }
-
-  async initialize() {
-    for (const [walletKindName, signerPaths] of this.paths) {
-      for (const [signerName, walletPath] of signerPaths.entries()) {
-        await this.initializeSigners(walletKindName, signerName, walletPath)
-      }
-    }
-  }
-
-  private async initializeSigners(walletKindName: WalletKind, signerName: string, path: string) {
-    // test if the name and path are valid
-    assertEx(signerName, () => 'Name not found in signer paths')
-    assertEx(path, () => 'Path not found in signer paths')
-
-    // test if the wallet exists
-    const phrase = assertEx(await this.walletStore.get(walletKindName), () => `Wallet not found: ${walletKindName}`)
-
-    if (path) {
-      // get the signer map for the wallet kind or create a new one
-      const signerMap = this.signerAccounts.get(walletKindName) ?? new Map()
-
-      // derive the wallet from the path
-      const wallet = await HDWallet.fromPhrase(phrase)
-      const derivedWallet = await wallet.derivePath(path)
-
-      // add the derived wallet to the signer map
-      signerMap.set(signerName, derivedWallet)
-
-      // set the signer map for the wallet kind
-      this.signerAccounts.set(walletKindName, signerMap)
-    }
-  }
-}

package/src/signer/index.ts

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

package/src/spec/boot.spec.ts

@@ -1,89 +0,0 @@
-import type { BiosExternalInterface } from '@xyo-network/bios-model'
-import { boot } from '@xyo-network/bios-nodejs'
-import { Kernel } from '@xyo-network/kernel'
-import type { KernelExternal } from '@xyo-network/kernel-model'
-import type { WalletKindSignerPaths } from '@xyo-network/os-model'
-import { HDWallet } from '@xyo-network/wallet'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-import {
-  beforeEach,
-  describe, expect, test,
-} from 'vitest'
-
-import type { DappRegistrationServiceParams } from '../registration/index.ts'
-import { XyOs } from '../XyOs.ts'
-
-describe('os', () => {
-  let bios: BiosExternalInterface
-  let osWallet: WalletInstance
-  let kernel: KernelExternal
-
-  const testSigner0Path = '0/0'
-  const testSigner1Path = '0/1'
-  const userPaths = new Map([['testSigner0', testSigner0Path], ['testSigner1', testSigner1Path]])
-  const paths: WalletKindSignerPaths = new Map([['user', userPaths]])
-
-  beforeEach(async () => {
-    bios = await boot()
-    const osWalletSeedPhrase = await bios.seedPhraseStore.get('os')
-    osWallet = await HDWallet.fromPhrase(osWalletSeedPhrase as string)
-    kernel = new Kernel({ bios })
-  })
-
-  describe('boot', () => {
-    test('with default params', async () => {
-      const xyOs = new XyOs()
-      await xyOs.boot(osWallet)
-      expect(xyOs).toBeDefined()
-    })
-
-    test('with dapps', async () => {
-      const dappsConfiguration: DappRegistrationServiceParams = {
-        dappNames: ['testDapp'],
-        dappParams: {},
-        dappPayloads: [],
-      }
-
-      const xyOs = new XyOs({ dappsConfiguration })
-      await xyOs.boot(osWallet)
-      expect(xyOs).toBeDefined()
-    })
-
-    test('default stacks', async () => {
-      const bios = await boot()
-      const kernel = new Kernel()
-      await kernel.boot(bios)
-      const xyOs = new XyOs({ kernel })
-      expect(xyOs).toBeDefined()
-      if (xyOs) {
-        const osWalletSeedPhrase = await bios.seedPhraseStore.get('os')
-        expect(osWalletSeedPhrase).toBeDefined()
-        const osWallet = await HDWallet.fromPhrase(osWalletSeedPhrase as string)
-        expect(osWallet).toBeDefined()
-        await xyOs.boot(osWallet)
-      }
-    })
-
-    test('no stacks', async () => {
-      const xyOs = new XyOs({ stackMap: {} })
-      expect(xyOs).toBeDefined()
-      if (xyOs) {
-        await xyOs.boot(osWallet)
-      }
-    })
-
-    test('supports users signing', async () => {
-      const params = { kernel, signerPaths: paths }
-
-      const xyOs = new XyOs(params)
-
-      expect(xyOs).toBeDefined()
-
-      if (xyOs) {
-        await xyOs.boot(osWallet)
-        expect(xyOs.user).toBeDefined()
-        expect(xyOs.user.signers).toBeDefined()
-      }
-    })
-  })
-})