@xyo-network/os-runtime 3.0.0

package/src/stack/Map.ts

@@ -0,0 +1,20 @@
+import { OsPubSubBridgeNetworkAdapters, OsSettingsAdapters, OsXyoPublicNetworkAdapters } from '../adapters/index.ts'
+import type { UninitializedStackMap } from './Manager.ts'
+import { OsPubSubNetworkStack } from './OsPubSubNetworkStack.ts'
+import { OsSettingsStack } from './OsSettingsStack.ts'
+import { XyoPublicNetworkStack } from './XyoPublicNetworkStack.ts'
+
+export const OsStackMap: UninitializedStackMap = {
+  osPubSubNetworkStack: {
+    stack: OsPubSubNetworkStack,
+    adapters: OsPubSubBridgeNetworkAdapters,
+  },
+  xyoPublicNetworkStack: {
+    stack: XyoPublicNetworkStack,
+    adapters: OsXyoPublicNetworkAdapters,
+  },
+  osSettingsStack: {
+    stack: OsSettingsStack,
+    adapters: OsSettingsAdapters,
+  },
+}

package/src/stack/OsPubSubNetworkStack.ts

@@ -0,0 +1,70 @@
+import { assertEx } from '@xylabs/assert'
+import type { NodeInstance } from '@xyo-network/node-model'
+import { asAttachableNodeInstance, asNodeInstance } from '@xyo-network/node-model'
+import type { AdapterSetCreator, XyOsContext } from '@xyo-network/os-model'
+import { ExposedNodeOuterNodeName, PubSubBridgeNodeNodeName } from '@xyo-network/os-model'
+
+import type { EventBusPubSubConnection } from '../event/index.ts'
+import { osPubSubNetworkReadyConnection, OsPubSubNetworkReadyEvent } from '../event/index.ts'
+import { initializeXns } from '../lib/index.ts'
+import { StackBase } from './Base.ts'
+
+export class OsPubSubNetworkStack extends StackBase {
+  protected _exposedNode: NodeInstance | undefined
+  protected _exposedNodeOuter: NodeInstance | undefined
+
+  private busConnection: EventBusPubSubConnection = osPubSubNetworkReadyConnection()
+
+  constructor(context: XyOsContext, adapters: AdapterSetCreator) {
+    super(context, adapters, 'OsPubSubNetworkStackNode')
+  }
+
+  get exposedNode() {
+    return this._exposedNode
+  }
+
+  get exposedNodeOuter() {
+    return this._exposedNodeOuter
+  }
+
+  override initialize() {
+    super.initialize()
+    // connect to the bus
+    this.context.eventBus.addConnection(this.busConnection)
+    this.on('initialized', () => this.busConnection.emit(OsPubSubNetworkReadyEvent, {}))
+
+    // listen for drivers
+    super.on('driverReady', async ({ node }) => {
+      if (node.id === PubSubBridgeNodeNodeName) {
+        const httpBridge = assertEx(await node.resolve('NsHttpBridge'), () => 'HttpBridge not found')
+        const xnsNode = asNodeInstance(await httpBridge.resolve('XNS'))
+
+        if (xnsNode) {
+          const initializedXns = await initializeXns(xnsNode)
+          console.log(`Xns: ${initializedXns}`)
+        } else {
+          console.log('Xns: Failed to contact Xns Node')
+        }
+      }
+    })
+
+    super.on('driverReady', async ({ node }) => {
+      if (node.id === ExposedNodeOuterNodeName) {
+        this._exposedNodeOuter = node
+        const mod = assertEx(await node.resolve('ExposedNode'), () => 'ExposedNode not found')
+        const exposedNode = asAttachableNodeInstance(mod, () => 'ExposedNode is not a node')
+        this._exposedNode = exposedNode
+      }
+    })
+    super.on('driverError', error => console.error('Unable to assign exposed node(s) to context', error))
+  }
+
+  override stop() {
+    super.stop()
+    this._exposedNode = undefined
+    this._exposedNodeOuter = undefined
+    // prevent throwing an error if the connection is not initialized
+    if (this.busConnection._id)
+      this.context.eventBus.removeConnection(this.busConnection.id)
+  }
+}

package/src/stack/OsSettingsStack.ts

@@ -0,0 +1,24 @@
+import type { AdapterSetCreator, XyOsContext } from '@xyo-network/os-model'
+
+import type { EventBusPubSubConnection } from '../event/index.ts'
+import { osSettingsReadyConnection, OsSettingsReadyEvent } from '../event/index.ts'
+import { StackBase } from './Base.ts'
+
+export class OsSettingsStack extends StackBase {
+  private busConnection: EventBusPubSubConnection = osSettingsReadyConnection()
+
+  constructor(context: XyOsContext, adapters: AdapterSetCreator) {
+    super(context, adapters, 'OsSettingsStackNode')
+  }
+
+  override initialize() {
+    super.initialize()
+    // connect to the bus
+    this.context.eventBus.addConnection(this.busConnection)
+    this.on('initialized', () => this.busConnection.emit(OsSettingsReadyEvent, {}))
+  }
+
+  override stop() {
+    super.stop()
+  }
+}

package/src/stack/XyoPublicNetworkStack.ts

@@ -0,0 +1,32 @@
+import type { AdapterSetCreator, XyOsContext } from '@xyo-network/os-model'
+import { XyoPublicNodeName } from '@xyo-network/os-model'
+
+import type { EventBusPubSubConnection } from '../event/index.ts'
+import { osXyoPublicNetworkReadyConnection, OsXyoPublicNetworkReadyEvent } from '../event/index.ts'
+import { StackBase } from './Base.ts'
+
+export class XyoPublicNetworkStack extends StackBase {
+  private busConnection: EventBusPubSubConnection = osXyoPublicNetworkReadyConnection()
+
+  constructor(context: XyOsContext, adapters: AdapterSetCreator) {
+    super(context, adapters, 'OsXyoPublicNetworkStackNode')
+  }
+
+  override initialize() {
+    super.initialize()
+    // connect to the bus
+    this.context.eventBus.addConnection(this.busConnection)
+    this.on('initialized', () => this.busConnection.emit(OsXyoPublicNetworkReadyEvent, {}))
+
+    this.on('driverReady', ({ node }) => {
+      if (node.id === XyoPublicNodeName) {
+        console.log('XyoPublicNode ready')
+      }
+    })
+    this.on('driverError', error => console.error('Error loading driver', error))
+  }
+
+  override stop() {
+    super.stop()
+  }
+}

package/src/stack/index.ts

@@ -0,0 +1,6 @@
+export * from './Base.ts'
+export * from './Manager.ts'
+export * from './Map.ts'
+export * from './OsPubSubNetworkStack.ts'
+export * from './OsSettingsStack.ts'
+export * from './XyoPublicNetworkStack.ts'

package/src/types/global.d.ts

@@ -0,0 +1,9 @@
+import type { XyOsGlobal } from '@xyo-network/os-model'
+
+export declare global {
+  interface Window {
+    ethereum: ethers
+    getXyOsGlobal: () => XyOsGlobalReact
+  }
+  function getXyOsGlobal(): XyOsGlobal
+}

package/src/types/images.d.ts

@@ -0,0 +1,5 @@
+declare module '*.png'
+declare module '*.jpg'
+declare module '*.svg'
+declare module '*.gif'
+declare module '*.webp'

package/src/utils/buildWalletSeedPhrasePayload.ts

@@ -0,0 +1,41 @@
+import type { Hash } from '@xylabs/hex'
+import type { WalletSeedPhrase } from '@xyo-network/os-model'
+import { WalletSeedPhraseSchema } from '@xyo-network/os-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+
+const language = 'english'
+const standard = 'bip-39'
+
+/**
+ * The label for the user wallet
+ */
+export const userWalletLabel = 'userWallet'
+
+/**
+ * The valid wallet labels
+ */
+export type WalletLabel = typeof userWalletLabel // TODO: More wallet types 'osWallet' | 'deviceWalletBackup' | ...
+
+/**
+ * Builds a WalletSeedPhrase payload from the supplied mnemonic seed phrase and label
+ * @param mnemonic The mnemonic seed phrase
+ * @param label The wallet label
+ * @returns A WalletSeedPhrase payload and its root hash
+ */
+export const buildWalletSeedPhrasePayload = async (mnemonic: string, label: WalletLabel): Promise<{ payload: WalletSeedPhrase; rootHash: Hash }> => {
+  const fields = { mnemonic: { language, mnemonic: mnemonic.split(' '), standard } }
+  const meta = { label, timestamp: Date.now() }
+  const builder = new PayloadBuilder<WalletSeedPhrase>({ fields, meta, schema: WalletSeedPhraseSchema })
+  const payload = await builder.build()
+  const rootHash = await PayloadBuilder.hash(payload)
+  return { payload, rootHash }
+}
+
+/**
+ * Builds a user WalletSeedPhrase payload from the supplied mnemonic seed phrase and label
+ * @param mnemonic The mnemonic seed phrase
+ * @returns A user WalletSeedPhrase payload and its root hash
+ */
+export const buildUserWalletSeedPhrasePayload = (mnemonic: string): Promise<{ payload: WalletSeedPhrase; rootHash: Hash }> => {
+  return buildWalletSeedPhrasePayload(mnemonic, userWalletLabel)
+}

package/src/utils/getApiDomain.ts

@@ -0,0 +1,14 @@
+const getApiDomain = (scope: 'localhost' | 'beta' | 'prod' | undefined, apiDomain: string | undefined) => {
+  if (apiDomain !== undefined) {
+    return apiDomain as string
+  }
+  if (scope === 'localhost') {
+    return 'http://localhost:8080'
+  }
+  if (scope === 'beta') {
+    return 'https://beta.archivist.xyo.network'
+  }
+  return 'https://archivist.xyo.network'
+}
+
+export { getApiDomain }

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './buildWalletSeedPhrasePayload.ts'
+export * from './getApiDomain.ts'
+export * from './renameObjKey.ts'

package/src/utils/renameObjKey.ts

@@ -0,0 +1,22 @@
+/**
+ * Renames a key on an existing object by returning a new one with the same insertion order
+ *
+ * inspired by - https://stackoverflow.com/a/48110891/2803259
+ */
+export const renameObjKey = <T extends Record<string, unknown> = Record<string, unknown>>(oldObj: T, oldKey: keyof T, newKey: string) => {
+  const oldObjKeys = Object.keys(oldObj) as Array<keyof T>
+  // eslint-disable-next-line unicorn/no-array-reduce
+  const newObj = oldObjKeys.reduce(
+    (acc, val) => {
+      if (val === oldKey) {
+        acc[newKey] = oldObj[oldKey]
+      } else {
+        acc[val as string] = oldObj[val]
+      }
+      return acc
+    },
+    {} as Record<string, unknown>,
+  )
+
+  return newObj as T
+}

package/src/wallet/DappSeedPhraseRepository.ts

@@ -0,0 +1,95 @@
+import { HDWallet } from '@xyo-network/account'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type { DappId, DappWalletSeedPhrase, WalletId, XyOsContext } from '@xyo-network/os-model'
+import { DappWalletSeedPhraseSchema } from '@xyo-network/os-model'
+import type { WithMeta } from '@xyo-network/payload-model'
+import { v4 as uuid } from 'uuid'
+
+import { OsCallerBase } from '../OsCallerBase.ts'
+import type { SeedPhraseId, SeedPhraseRepository } from './SeedPhraseRepository.ts'
+
+export class DappSeedPhraseRepository extends OsCallerBase implements SeedPhraseRepository {
+  // record of all dapps that have requested a seed phrase with the OS
+  private dappIdRepository = new Map<SeedPhraseId, DappWalletSeedPhrase>()
+  // record of all walletIds that have been issued to registered dapps
+  private walletIdRepository = new Map<WalletId, DappWalletSeedPhrase>()
+
+  constructor(
+    xyOs: XyOsContext,
+    protected readonly allowedNames: string[],
+  ) {
+    super(xyOs)
+  }
+
+  async add(dappId: DappId): Promise<string> {
+    const archivist = await this.getDappsArchivist()
+    const seedPhrase = this.newPhrase()
+    const walletId = uuid()
+    const payload: DappWalletSeedPhrase = {
+      dappId,
+      schema: DappWalletSeedPhraseSchema,
+      seedPhrase,
+      walletId,
+    }
+    await archivist.insert([payload])
+    this.dappIdRepository.set(dappId, payload)
+    this.walletIdRepository.set(walletId, payload)
+    return walletId
+  }
+
+  async findOrCreate(dappName: string): Promise<WalletId> {
+    if (this.allowedNames.includes(dappName)) {
+      const existingPayload = await this.checkDappId(dappName)
+      if (existingPayload) return existingPayload.walletId
+
+      // new dapp request so generate a new wallet Id and return it
+      try {
+        await this.add(dappName)
+        const existingPayload = await this.checkDappId(dappName)
+        if (existingPayload) return existingPayload.walletId
+        throw new Error(`failed to add seed phrase: ${dappName}`)
+      } catch (e) {
+        console.error(e)
+        throw new Error(`failed to add seed phrase: ${dappName}`)
+      }
+    } else {
+      throw new Error(`${dappName} is not allowed to register a seed phase. NOTE: this is a safeguard till 3rd party dApps can be validated`)
+    }
+  }
+
+  async request(walletId: WalletId) {
+    return (await this.checkWalletId(walletId))?.seedPhrase
+  }
+
+  private async checkDappId(dappId: DappId) {
+    const diviner = await this.getDappsArchivistPayloadDiviner()
+    const query = {
+      dappId,
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappWalletSeedPhraseSchema],
+    }
+
+    const results = (await diviner.divine([query])) as WithMeta<DappWalletSeedPhrase>[]
+    return results.length > 0 ? results[0] : undefined
+  }
+
+  private async checkWalletId(walletId: WalletId) {
+    const diviner = await this.getDappsArchivistPayloadDiviner()
+    const query = {
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappWalletSeedPhraseSchema],
+      walletId,
+    }
+
+    const results = (await diviner.divine([query])) as WithMeta<DappWalletSeedPhrase>[]
+    return results.length > 0 ? results[0] : undefined
+  }
+
+  private newPhrase(): string {
+    return HDWallet.generateMnemonic()
+  }
+}

package/src/wallet/SeedPhraseRepository.ts

@@ -0,0 +1,32 @@
+import type { WalletId } from '@xyo-network/os-model'
+
+/** Convenience Types for Entities in the Repository */
+export type SeedPhraseId = string
+export type SeedPhrase = string
+
+/**
+ * A repository for storing wallet seed phrases and requesting them by walletIds (i.e. UUIDs)
+ */
+export interface SeedPhraseRepository {
+  /**
+   * Add a seed phrase for a given SeedPhraseId
+   * @param  {SeedPhraseId} id
+   * @returns Promise
+   */
+  add(id: SeedPhraseId): Promise<string>
+
+  /**
+   * For a given DappId, find its wallet or create a new wallet and return its walletId
+   * @param  {SeedPhraseId} dappName
+   * @returns Promise
+   */
+  findOrCreate(dappName: SeedPhraseId): Promise<WalletId>
+
+  /**
+   * Request a seed phrase by supplying a walletId. Note: In the future, the OS might require verification along side the walletId
+   *
+   * @param  {WalletId} walletId
+   * @returns DappWalletSeedPhrase
+   */
+  request(walletId: WalletId): Promise<SeedPhrase | undefined>
+}

package/src/wallet/index.ts

@@ -0,0 +1,2 @@
+export * from './DappSeedPhraseRepository.ts'
+export * from './SeedPhraseRepository.ts'

package/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["./src/index.ts"],
+  "tsconfig": "./tsconfig.typedoc.json"
+}

package/xy.config.ts

@@ -0,0 +1,10 @@
+import type { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
+const config: XyTsupConfig = {
+  compile: {
+    browser: {},
+    node: {},
+    neutral: { src: true },
+  },
+}
+
+export default config