@xyo-network/os-runtime 7.2.1 → 7.3.0

package/src/stack/Base.ts

@@ -1,165 +0,0 @@
-import type { BaseParams, Promisable } from '@xylabs/sdk-js'
-import {
-  assertEx, BaseEmitter, forget,
-} from '@xylabs/sdk-js'
-import type { ModuleIdentifier } from '@xyo-network/module-model'
-import { isModuleInstance } from '@xyo-network/module-model'
-import type { AttachableNodeInstance } from '@xyo-network/node-model'
-import { asAttachableNodeInstance } from '@xyo-network/node-model'
-import type {
-  AdapterSetCreator, NodeAdapter, NodeAdapterBaseEvents, StackBaseEvents, StackInitializer, XyOsContext,
-} from '@xyo-network/os-model'
-
-/**
- * Stack Base Class
- *
- * Listens for changes in adapter connections, update the stack node, and emits events when the stack is ready
- */
-export class StackBase extends BaseEmitter<BaseParams, StackBaseEvents> implements StackInitializer {
-  // flag to check that all adapters are initialized
-  initialized = false
-
-  // adapters to initialize into the stack
-  private _adapterSet: NodeAdapter[]
-
-  private _context: XyOsContext
-
-  // stack node
-  private _stack: AttachableNodeInstance | undefined
-
-  // stack node module identifier for the stack
-  private _stackNodeModuleId: ModuleIdentifier
-
-  // list of initialized nodes
-  private initializedNodes: AttachableNodeInstance[] = []
-
-  // list of listeners - lister type not important since its only recalled to stop listening
-
-  private listeners: {
-    adapter: NodeAdapter
-    eventName: string
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    listener: (args: any) => Promisable<void>
-  }[] = []
-
-  constructor(context: XyOsContext, adapterSet: AdapterSetCreator, stackNodeModuleId: ModuleIdentifier) {
-    super({})
-    this._context = context
-    this._adapterSet = adapterSet(assertEx(this.context.kernel, () => 'Kernel access required'))
-    this._stackNodeModuleId = stackNodeModuleId
-  }
-
-  get adapterSet(): NodeAdapter[] {
-    return assertEx(this._adapterSet, () => `${this.stackNodeModuleId} adapters not initialized`)
-  }
-
-  get context(): XyOsContext {
-    return assertEx(this._context, () => `${this.stackNodeModuleId} stack context not initialized`)
-  }
-
-  get stack(): AttachableNodeInstance {
-    return assertEx(this._stack, () => `${this.stackNodeModuleId} stack node not initialized`)
-  }
-
-  get stackNodeModuleId(): ModuleIdentifier {
-    return assertEx(this._stackNodeModuleId, () => 'Stack node module identifier not initialized')
-  }
-
-  initialize() {
-    this.assignStack()
-    // watch for adapter connection changes
-    for (const adapter of this.adapterSet) {
-      // listen for driver ready events
-      const driverReadyListener = async ({ node }: NodeAdapterBaseEvents['driverReady']) => await this.handleDriverReady(node)
-      adapter.on('driverReady', driverReadyListener)
-      this.listeners.push({
-        adapter: adapter, eventName: 'driverReady', listener: driverReadyListener,
-      })
-
-      // listen for driver error events
-      const driverErrorListener = async ({ error }: NodeAdapterBaseEvents['driverError']) => {
-        console.error(`Error updating ${this.stackNodeModuleId} stack node`, error)
-        await this.emit('driverError', { error })
-      }
-      adapter.on('driverError', driverErrorListener)
-      this.listeners.push({
-        adapter: adapter, eventName: 'driverError', listener: driverErrorListener,
-      })
-
-      // start the adapter
-      const startAdapter = async () => await adapter.start()
-      forget(startAdapter())
-    }
-  }
-
-  /**
-   * Stops the stack
-   */
-  stop() {
-    for (const {
-      eventName, listener, adapter,
-    } of this.listeners) {
-      // stop the adapter
-      adapter.off(eventName, listener)
-    }
-  }
-
-  /**
-   * Adds a node to the stack. Idempotent to avoid adding the
-   * same node multiple times
-   * @param node The node to add to the stack
-   * @returns
-   */
-  private async addNodeToStackNode(node: AttachableNodeInstance) {
-    // Locate the stack node
-    const stackNode = await this.getStackNode()
-
-    // If the node is already attached as there's no need to re-attach
-    const existingModule = await stackNode.resolve(node.address, { direction: 'down' })
-    if (isModuleInstance(existingModule)) return
-
-    // Register & attach the new node
-    await stackNode.register?.(node)
-    await stackNode.attach?.(node.address, true)
-  }
-
-  private assignStack() {
-    const assign = async () => {
-      const stackNode = await this.getStackNode()
-      this._stack = stackNode
-    }
-    forget(assign())
-  }
-
-  private async getStackNode() {
-    const mod = assertEx(await this.context.root.resolve(this.stackNodeModuleId), () => `${this.stackNodeModuleId} not found`)
-    return asAttachableNodeInstance(mod, () => `${this.stackNodeModuleId} not a NodeInstance`, { required: true })
-  }
-
-  private async handleDriverReady(node: AttachableNodeInstance) {
-    try {
-      // eagerly emit that the driver is ready
-      await this.emit('driverReady', { node })
-
-      await this.addNodeToStackNode(node)
-
-      await this.updateInitializationState(node)
-    } catch (error) {
-      console.error(`Error updating ${this.stackNodeModuleId} stack node`, node.id, error)
-      await this.emit('stackError', { error: error as Error })
-    }
-  }
-
-  private async updateInitializationState(node: AttachableNodeInstance) {
-    // update the initialized nodes list
-    this.initializedNodes.push(node)
-
-    // update the initialized flag
-    this.initialized = this.adapterSet.every(n => n.initialized)
-
-    // notify all initialized listeners
-    if (this.initialized) {
-      await this.emit('initialized', { stack: await this.getStackNode() })
-    }
-  }
-}

package/src/stack/Manager.ts

@@ -1,51 +0,0 @@
-import type {
-  AdapterSetCreator, StackInitializer, XyOsContext,
-} from '@xyo-network/os-model'
-
-import type { StackBase } from './Base.ts'
-
-export interface StackConstructor { new (context: XyOsContext, adapters: AdapterSetCreator): StackBase }
-
-export interface UninitializedStackSet {
-  adapters: AdapterSetCreator
-  stack: StackConstructor
-}
-
-export interface UninitializedStackMap { [key: string]: UninitializedStackSet }
-
-export class StackManager {
-  private initializedStacksMap: Map<string, StackInitializer> = new Map()
-  private stackMap: UninitializedStackMap
-
-  constructor(stackMap: UninitializedStackMap) {
-    this.stackMap = stackMap
-  }
-
-  get stacks() {
-    return Object.keys(this.initializedStacksMap)
-  }
-
-  private get initializedStacks() {
-    return this.initializedStacksMap
-  }
-
-  getStack<TStack = StackBase>(key: string) {
-    return this.initializedStacksMap.get(key) as TStack | undefined
-  }
-
-  initialize(context: XyOsContext) {
-    for (const [key, stackSet] of Object.entries(this.stackMap)) {
-      console.log('stack-initialize', key)
-      const { stack: Stack, adapters: stackNodeModuleId } = stackSet
-      const initializedStack = new Stack(context, stackNodeModuleId)
-      initializedStack.initialize()
-      this.initializedStacks.set(key, initializedStack)
-    }
-  }
-
-  stop() {
-    for (const stack of this.initializedStacks.values()) {
-      stack.stop()
-    }
-  }
-}

package/src/stack/Map.ts

@@ -1,22 +0,0 @@
-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

@@ -1,70 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-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

@@ -1,24 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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/system/ManageSystemDapps.ts

@@ -1,148 +0,0 @@
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import type { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
-import type { ModuleFactoryLocatorInstance } from '@xyo-network/module-model'
-import type {
-  DappConfig, DappIcon, DappParams, DappSet, PayloadWithVersion, XyOsContext,
-} from '@xyo-network/os-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { WithStorageMeta } from '@xyo-network/payload-model'
-import semver from 'semver'
-
-import { OsCallerBase } from '../OsCallerBase.ts'
-import { SystemDappQueries } from './Queries.ts'
-
-export type ErrorListener = (failedPayloads: DappConfig[]) => void
-export type DappSetsAndPayloads = {
-  dappPayloads: (DappConfig | DappIcon)[]
-  dappSets: DappSet[]
-}
-
-/**
- * Manage the installation of system dapps from payloads and return the built sets
- */
-export class ManageSystemDapps extends OsCallerBase {
-  private defaultSystemDappParams: Record<string, DappParams>
-  private defaultSystemDapps: PayloadWithVersion[]
-  private defaultSystemNames: string[]
-  private developmentMode?: boolean
-  private locator?: ModuleFactoryLocatorInstance
-
-  private onErrorCallbacks: ErrorListener[] = []
-
-  constructor(
-    context: XyOsContext,
-    defaultSystemNames: string[],
-    defaultSystemDapps: PayloadWithVersion[],
-    defaultSystemDappParams: Record<string, DappParams>,
-    locator?: ModuleFactoryLocatorInstance,
-    developmentMode?: boolean,
-  ) {
-    super(context)
-    this.defaultSystemNames = defaultSystemNames
-    this.defaultSystemDapps = defaultSystemDapps
-    this.defaultSystemDappParams = defaultSystemDappParams
-    this.locator = locator
-    this.developmentMode = developmentMode
-  }
-
-  /**
-   * Add a callback to listen for errors throwing during system dapp registration
-   * @param errorListener
-   */
-  addErrorListener(errorListener: ErrorListener) {
-    this.onErrorCallbacks.push(errorListener)
-  }
-
-  /**
-   * Installs the dapps into the OS and builds the appropriate DappSet
-   */
-  async install(): Promise<DappSet[]> {
-    await this.insertPayloads()
-    return await this.latestSets()
-  }
-
-  private async freshInstall(archivist: ArchivistInstance): Promise<void> {
-    await archivist.insert(this.defaultSystemDapps)
-  }
-
-  private async insertPayloads(): Promise<boolean> {
-    const archivist = this.developmentMode ? await this.getDappsArchivistDevelopment() : await this.getDappsArchivist()
-    try {
-      const allPayloads = (await archivist.all()) as WithStorageMeta<(DappIcon | DappConfig)>[]
-      if (allPayloads.length === 0) {
-        await this.freshInstall(archivist)
-        return true
-      }
-
-      // only insert unseen system dapp payloads
-      for (const systemDappPayload of this.defaultSystemDapps) {
-        try {
-          const validSemver = semver.valid(systemDappPayload.version)
-          if (!validSemver) throw new Error('semver is a valid type (string) but was not able to be parsed')
-        } catch (e) {
-          console.error(`${systemDappPayload.version} does not appear to be a valid semver value`, e)
-          continue
-        }
-        const [existing] = await archivist.get([await PayloadBuilder.dataHash(systemDappPayload)])
-        if (existing) continue
-        await archivist.insert([systemDappPayload])
-      }
-      return true
-    } catch (e) {
-      console.error('error installing system dapps')
-      throw e
-    }
-  }
-
-  private async latestSets() {
-    const diviner = this.developmentMode ? await this.getDappsArchivistPayloadDivinerDevelopment() : await this.getDappsArchivistPayloadDiviner()
-    const dappSets: DappSet[] = []
-    const failedPayloads: DappConfig[] = []
-
-    for (const name of this.defaultSystemNames) {
-      try {
-        const dappConfig = await SystemDappQueries.getLatestConfig(diviner, name)
-        if (!dappConfig) {
-          console.error(`No config found for dapp ${name}`)
-          continue
-        }
-
-        const dappIcon = await SystemDappQueries.getLatestIcon(diviner, name, dappConfig.version)
-        if (!dappIcon) {
-          console.error(`No icon found for dapp ${dappConfig.name}`)
-          failedPayloads.push(dappConfig)
-          continue
-        }
-
-        const dappAccess = await SystemDappQueries.getDappAccess(diviner, name, dappConfig.version)
-
-        const dappParams = this.defaultSystemDappParams[dappConfig.name]
-        if (!dappParams) {
-          console.error(`No params found for dapp ${dappConfig.name}.  Did you forget to add it to OsDappParams?`)
-          failedPayloads.push(dappConfig)
-          continue
-        }
-
-        const dappWidgetConfigs = await SystemDappQueries.getWidgetConfigs(diviner, name, dappConfig.version)
-
-        dappSets.push({
-          dapp: {
-            accessors: dappAccess,
-            config: dappConfig,
-            icon: dappIcon,
-            params: dappParams,
-            widgetConfigs: dappWidgetConfigs,
-          },
-        })
-      } catch {
-        console.error(`Failed to build dapp ${name}`)
-      }
-    }
-
-    if (failedPayloads.length > 0) {
-      for (const cb of this.onErrorCallbacks) cb(failedPayloads)
-    }
-
-    return dappSets
-  }
-}

package/src/system/Queries.ts

@@ -1,69 +0,0 @@
-import type { DivinerInstance } from '@xyo-network/diviner-model'
-import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
-import type {
-  DappConfig,
-  DappIcon,
-  DappId,
-  DappWidgetConfig,
-  UnregisteredDappAccess,
-} from '@xyo-network/os-model'
-import {
-  DappConfigSchema,
-  DappIconSchema,
-  DappWidgetConfigSchema,
-  UnregisteredDappAccessSchema,
-} from '@xyo-network/os-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-
-export const SystemDappQueries = {
-  async getDappAccess(diviner: DivinerInstance, name: string, version: string) {
-    const accessQuery = {
-      order: 'desc',
-      registeringDappId: name,
-      schema: PayloadDivinerQuerySchema,
-      schemas: [UnregisteredDappAccessSchema],
-      version: version,
-    }
-    return (await diviner.divine([accessQuery])) as UnregisteredDappAccess[]
-  },
-  async getLatestConfig(diviner: DivinerInstance, name: string) {
-    const configQuery = {
-      limit: 1,
-      name,
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [DappConfigSchema],
-    }
-    const [dappConfig] = (await diviner.divine([configQuery])) as DappConfig[]
-    return dappConfig
-  },
-  async getLatestIcon(diviner: DivinerInstance, name: string, version: string) {
-    const iconQuery = {
-      name,
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [DappIconSchema],
-      version,
-    }
-    const [dappIcon] = (await diviner.divine([iconQuery])) as DappIcon[]
-    return dappIcon
-  },
-  async getWidgetConfigs(diviner: DivinerInstance, name: DappId, version: string): Promise<DappWidgetConfig[]> {
-    const widgetConfigQuery = {
-      dappId: name,
-      order: 'desc',
-      schema: PayloadDivinerQuerySchema,
-      schemas: [DappWidgetConfigSchema],
-      version,
-    }
-    const widgetConfigs = (await diviner.divine([widgetConfigQuery])) as DappWidgetConfig[]
-
-    const uniqueConfigs: Record<string, DappWidgetConfig> = {}
-    for (const widgetConfig of widgetConfigs) {
-      const hash = await PayloadBuilder.dataHash(widgetConfig)
-      uniqueConfigs[widgetConfig.mode ?? hash] = widgetConfig
-    }
-
-    return Object.values(uniqueConfigs)
-  },
-}

package/src/system/index.ts

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

package/src/types/global.d.ts

@@ -1,9 +0,0 @@
-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

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

package/src/utils/buildWalletSeedPhrasePayload.ts

@@ -1,51 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-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,
-    },
-    $label,
-    $timestamp: Date.now(),
-  }
-  const payload = new PayloadBuilder<WalletSeedPhrase>({ schema: WalletSeedPhraseSchema }).fields(fields).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

@@ -1,14 +0,0 @@
-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

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