@xyo-network/react-standard-node 2.45.2

package/dist/types/lib/Builders/SentinelBuilder.d.ts

@@ -0,0 +1,48 @@
+import { AccountInstance } from '@xyo-network/account-model';
+import { MemorySentinel, SentinelParams } from '@xyo-network/sentinel';
+export type SentinelCallbacks = Pick<SentinelParams, 'onReportEnd' | 'onReportStart' | 'onWitnessReportStart' | 'onWitnessReportEnd'>;
+export interface SentinelBuilderConfig {
+    name: string;
+    witnesses: string[];
+}
+export declare class SentinelBuilder {
+    private config;
+    private account;
+    private _sentinel;
+    protected constructor(config: SentinelBuilderConfig, account: AccountInstance);
+    get sentinel(): MemorySentinel<import("@xyo-network/sentinel").MemorySentinelParams<import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
+        name?: string | undefined;
+        security?: {
+            allowAnonymous?: boolean | undefined;
+            allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        storeQueries?: boolean | undefined;
+    } & {
+        archivists?: string[] | undefined;
+        schema: string;
+    } & {
+        witnesses?: string[] | undefined;
+    } & {
+        schema: string;
+    }>>;
+    static create(config: SentinelBuilderConfig, account: AccountInstance, callbacks: SentinelCallbacks): Promise<SentinelBuilder>;
+    buildSentinel(callbacks: SentinelCallbacks): Promise<MemorySentinel<import("@xyo-network/sentinel").MemorySentinelParams<import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & {
+        name?: string | undefined;
+        security?: {
+            allowAnonymous?: boolean | undefined;
+            allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        storeQueries?: boolean | undefined;
+    } & {
+        archivists?: string[] | undefined;
+        schema: string;
+    } & {
+        witnesses?: string[] | undefined;
+    } & {
+        schema: string;
+    }>>>;
+    private buildParams;
+}
+//# sourceMappingURL=SentinelBuilder.d.ts.map

package/dist/types/lib/Builders/SentinelBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SentinelBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/Builders/SentinelBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAE5D,OAAO,EAAE,cAAc,EAAwB,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAE5F,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,cAAc,EAAE,aAAa,GAAG,eAAe,GAAG,sBAAsB,GAAG,oBAAoB,CAAC,CAAA;AAErI,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB;AAED,qBAAa,eAAe;IAGJ,OAAO,CAAC,MAAM;IAAyB,OAAO,CAAC,OAAO;IAF5E,OAAO,CAAC,SAAS,CAA4B;IAE7C,SAAS,aAAqB,MAAM,EAAE,qBAAqB,EAAU,OAAO,EAAE,eAAe;IAI7F,IAAI,QAAQ;;;;;;;;;;;;;;;QAEX;WAEY,MAAM,CAAC,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IAM9H,aAAa,CAAC,SAAS,EAAE,iBAAiB;;;;;;;;;;;;;;;;IAKhD,OAAO,CAAC,WAAW;CAUpB"}

package/dist/types/lib/Builders/StorageArchivistBuilder.d.ts

@@ -0,0 +1,21 @@
+import { AccountInstance } from '@xyo-network/account-model';
+import { ArchivistModule, StorageArchivistConfig, XyoStorageArchivist } from '@xyo-network/archivist';
+import { MemoryNode } from '@xyo-network/node';
+export interface ArchivistBuilderConfig {
+    name: string;
+    namespace: string;
+}
+export declare class StorageArchivistBuilder {
+    private config;
+    private account;
+    private node;
+    private _archivist;
+    private remoteArchivist;
+    protected constructor(config: ArchivistBuilderConfig, account: AccountInstance, node: MemoryNode);
+    get archivist(): XyoStorageArchivist;
+    static create(config: ArchivistBuilderConfig, account: AccountInstance, node: MemoryNode): Promise<StorageArchivistBuilder>;
+    buildArchivist(): Promise<XyoStorageArchivist>;
+    buildConfig(): StorageArchivistConfig;
+    findParentArchivist(): Promise<ArchivistModule | undefined>;
+}
+//# sourceMappingURL=StorageArchivistBuilder.d.ts.map

package/dist/types/lib/Builders/StorageArchivistBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageArchivistBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/Builders/StorageArchivistBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAC5D,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAgC,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AACnI,OAAO,EAAE,UAAU,EAAe,MAAM,mBAAmB,CAAA;AAG3D,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;CAClB;AACD,qBAAa,uBAAuB;IAIZ,OAAO,CAAC,MAAM;IAA0B,OAAO,CAAC,OAAO;IAAmB,OAAO,CAAC,IAAI;IAH5G,OAAO,CAAC,UAAU,CAAiC;IACnD,OAAO,CAAC,eAAe,CAA6B;IAEpD,SAAS,aAAqB,MAAM,EAAE,sBAAsB,EAAU,OAAO,EAAE,eAAe,EAAU,IAAI,EAAE,UAAU;IAExH,IAAI,SAAS,wBAEZ;WAEY,MAAM,CAAC,MAAM,EAAE,sBAAsB,EAAE,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAO3H,cAAc;IAKpB,WAAW,IAAI,sBAAsB;IAa/B,mBAAmB;CAY1B"}

package/dist/types/lib/Builders/index.d.ts

@@ -0,0 +1,4 @@
+export * from './MemoryNodeBuilder';
+export * from './SentinelBuilder';
+export * from './StorageArchivistBuilder';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/Builders/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/Builders/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,2BAA2B,CAAA"}

package/dist/types/lib/ModuleAccountPaths.d.ts

@@ -0,0 +1,4 @@
+export declare const GlobalNodeOffsetPath = "15";
+export declare const RemoteNodeOffsetPaths: Record<string, string>;
+export declare const RemoteNodeArchivistOffsetPaths: Record<string, Record<string, string>>;
+//# sourceMappingURL=ModuleAccountPaths.d.ts.map

package/dist/types/lib/ModuleAccountPaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleAccountPaths.d.ts","sourceRoot":"","sources":["../../../src/lib/ModuleAccountPaths.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,OAAO,CAAA;AAExC,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAIxD,CAAA;AAED,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAajF,CAAA"}

package/dist/types/lib/ModuleNames.d.ts

@@ -0,0 +1,3 @@
+export declare const GlobalNode = "GlobalNode";
+export declare const RootStorageArchivist = "RootStorageArchivist";
+//# sourceMappingURL=ModuleNames.d.ts.map

package/dist/types/lib/ModuleNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleNames.d.ts","sourceRoot":"","sources":["../../../src/lib/ModuleNames.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,eAAe,CAAA;AAEtC,eAAO,MAAM,oBAAoB,yBAAyB,CAAA"}

package/dist/types/lib/buildNodes.d.ts

@@ -0,0 +1,4 @@
+import { MemoryNode } from '@xyo-network/node';
+import { HDWallet } from '@xyo-network/protocol';
+export declare const BuildStandardNodes: (wallet: HDWallet) => Promise<MemoryNode[]>;
+//# sourceMappingURL=buildNodes.d.ts.map

package/dist/types/lib/buildNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildNodes.d.ts","sourceRoot":"","sources":["../../../src/lib/buildNodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAwBhD,eAAO,MAAM,kBAAkB,WAAkB,QAAQ,KAAG,QAAQ,UAAU,EAAE,CAoB/E,CAAA"}

package/dist/types/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Builders';
+export * from './buildNodes';
+export * from './ModuleAccountPaths';
+export * from './ModuleNames';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA"}

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@xyo-network/react-standard-node",
+  "author": {
+    "email": "support@xyo.network",
+    "name": "XYO Development Team",
+    "url": "https://xyo.network"
+  },
+  "bugs": {
+    "email": "support@xyo.network",
+    "url": "https://github.com/XYOracleNetwork/sdk-xyo-react-js/issues"
+  },
+  "dependencies": {
+    "@xylabs/react-shared": "^2.16.11",
+    "@xyo-network/account-model": "^2.51.9",
+    "@xyo-network/archivist": "^2.51.9",
+    "@xyo-network/bridge": "^2.51.9",
+    "@xyo-network/module": "^2.51.9",
+    "@xyo-network/node": "^2.51.9",
+    "@xyo-network/payloadset-plugin": "^2.51.9",
+    "@xyo-network/protocol": "^2.51.9",
+    "@xyo-network/react-network": "^2.45.2",
+    "@xyo-network/react-node": "^2.45.2",
+    "@xyo-network/react-shared": "^2.45.2",
+    "@xyo-network/react-wallet": "^2.45.2",
+    "@xyo-network/sentinel": "^2.51.9",
+    "@xyo-network/witness": "^2.51.9"
+  },
+  "devDependencies": {
+    "@storybook/react": "^6.5.16",
+    "@xylabs/ts-scripts-yarn3": "^2.16.1",
+    "@xylabs/tsconfig-react": "^2.16.1",
+    "require-from-string": "^2.0.2",
+    "typescript": "^4.9.5"
+  },
+  "peerDependencies": {
+    "@mui/icons-material": "^5",
+    "@mui/material": "^5",
+    "@mui/styles": "^5",
+    "axios": "^1",
+    "react": "^18",
+    "react-dom": "^18",
+    "react-router-dom": "^6"
+  },
+  "description": "Common React library for all XYO projects that use React",
+  "browser": "dist/esm/index.js",
+  "docs": "dist/docs.json",
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./dist/esm/index.js",
+        "require": "./dist/cjs/index.js"
+      },
+      "browser": {
+        "import": "./dist/esm/index.js",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/esm/index.js"
+    },
+    "./dist/docs.json": {
+      "default": "./dist/docs.json"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "homepage": "https://xyo.network",
+  "keywords": [
+    "xyo",
+    "utility",
+    "typescript",
+    "react"
+  ],
+  "license": "LGPL-3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/XYOracleNetwork/sdk-xyo-react-js.git"
+  },
+  "scripts": {
+    "lint-pkg": "npmPkgJsonLint .",
+    "license": "yarn license-checker --exclude \"MIT, ISC, Apache-2.0, BSD, BSD-2-Clause, CC-BY-4.0, Unlicense, CC-BY-3.0, CC0-1.0\""
+  },
+  "sideEffects": false,
+  "types": "dist/types/index.d.ts",
+  "version": "2.45.2"
+}

package/src/components/ActiveStandardNode.tsx

@@ -0,0 +1,53 @@
+import { useAsyncEffect, WithChildren } from '@xylabs/react-shared'
+import { useNetwork } from '@xyo-network/react-network'
+import { useNode } from '@xyo-network/react-node'
+import { assertDefinedEx } from '@xyo-network/react-shared'
+import { useMemo, useState } from 'react'
+
+import { useStandardNodes } from '../contexts'
+
+export interface ActiveStandardNodeProps extends WithChildren {
+  nodeNameOrAddress?: string
+}
+
+export const ActiveStandardNode: React.FC<ActiveStandardNodeProps> = ({ children, nodeNameOrAddress }) => {
+  const { network } = useNetwork(true)
+  const [node] = useNode(nodeNameOrAddress)
+  const [activeRemoteNodeAddress, setActiveRemoteNodeAddress] = useState<string>()
+  const { nodes, findAddressByName } = useStandardNodes()
+
+  const selectedNodeAddress = useMemo(() => {
+    if (node && nodes && findAddressByName && network) {
+      const selectedNodeAddress = findAddressByName(network.name)
+      return assertDefinedEx(selectedNodeAddress, `${network.name} was not found in known remote nodes`)
+    }
+  }, [findAddressByName, network, node, nodes])
+
+  // Probably needs to rely on node events rather than provider values to ensure its registered
+  useAsyncEffect(
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    async (mounted) => {
+      if (node && selectedNodeAddress) {
+        try {
+          if ((await node?.attached())?.includes(selectedNodeAddress)) {
+            return
+          }
+          await node?.attach(selectedNodeAddress, true)
+
+          if (mounted()) {
+            // cleanup
+            if (activeRemoteNodeAddress) {
+              await node?.detach(activeRemoteNodeAddress)
+            }
+            setActiveRemoteNodeAddress(selectedNodeAddress)
+          }
+        } catch (e) {
+          console.error('Error Attaching Selected Node Address', e)
+        }
+      }
+    },
+    [activeRemoteNodeAddress, node, selectedNodeAddress, nodes],
+  )
+
+  return <>{children}</>
+}

package/src/components/index.ts

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

package/src/contexts/StandardRemoteNodes/Context.ts

@@ -0,0 +1,5 @@
+import { createContextEx } from '@xyo-network/react-shared'
+
+import { StandardNodesState } from './State'
+
+export const StandardNodesContext = createContextEx<StandardNodesState>()

package/src/contexts/StandardRemoteNodes/Providers.tsx

@@ -0,0 +1,59 @@
+import { useAsyncEffect, WithChildren } from '@xylabs/react-shared'
+import { HDWallet } from '@xyo-network/protocol'
+import { assertDefinedEx } from '@xyo-network/react-shared'
+import { useWallet } from '@xyo-network/react-wallet'
+import { useEffect, useMemo, useState } from 'react'
+
+import { BuildStandardNodes } from '../../lib'
+import { StandardNodesContext } from './Context'
+import { StandardNodesState } from './State'
+
+export interface StandardNodesProviderProps extends WithChildren {
+  defaultRemoteNodes?: StandardNodesState['nodes']
+  wallet?: HDWallet
+}
+
+export const StandardNodesProvider: React.FC<StandardNodesProviderProps> = ({ children, defaultRemoteNodes, wallet }) => {
+  const [nodes, setNodes] = useState<StandardNodesState['nodes']>(defaultRemoteNodes)
+
+  useEffect(() => {
+    setNodes(defaultRemoteNodes)
+  }, [defaultRemoteNodes])
+
+  useAsyncEffect(
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    async () => {
+      if (wallet) {
+        const builtNodes = await BuildStandardNodes(wallet)
+        setNodes(builtNodes)
+      }
+    },
+    [wallet],
+  )
+
+  const findAddressByName = (name?: string) => {
+    const validNetworkName = assertDefinedEx(name, 'name was not defined')
+    return nodes?.find((node) => node.config.name === validNetworkName)?.address
+  }
+
+  return (
+    <StandardNodesContext.Provider
+      value={{
+        findAddressByName,
+        nodes,
+        provided: true,
+      }}
+    >
+      {children}
+    </StandardNodesContext.Provider>
+  )
+}
+
+export const StandardNodesProviderWithWallet: React.FC<Omit<StandardNodesProviderProps, 'wallet'>> = (props) => {
+  const { wallet: walletFromCtx, activeAccountIndex } = useWallet()
+  const wallet = useMemo(
+    () => (walletFromCtx && activeAccountIndex !== undefined ? walletFromCtx.derivePath(activeAccountIndex.toString()) : undefined),
+    [activeAccountIndex, walletFromCtx],
+  )
+  return <StandardNodesProvider wallet={wallet} {...props} />
+}

package/src/contexts/StandardRemoteNodes/State.ts

@@ -0,0 +1,7 @@
+import { MemoryNode } from '@xyo-network/node'
+import { ContextExState } from '@xyo-network/react-shared'
+
+export interface StandardNodesState extends ContextExState {
+  findAddressByName?: (name?: string) => string | undefined
+  nodes?: MemoryNode[]
+}

package/src/contexts/StandardRemoteNodes/index.ts

@@ -0,0 +1,4 @@
+export * from './Context'
+export * from './Providers'
+export * from './State'
+export * from './use'

package/src/contexts/StandardRemoteNodes/use.tsx

@@ -0,0 +1,5 @@
+import { useContextEx } from '@xyo-network/react-shared'
+
+import { StandardNodesContext } from './Context'
+
+export const useStandardNodes = (required = false) => useContextEx(StandardNodesContext, 'StandardNodes', required)

package/src/contexts/index.ts

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

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './components'
+export * from './contexts'
+export * from './lib'

package/src/lib/Builders/MemoryNodeBuilder.ts

@@ -0,0 +1,98 @@
+import { AccountInstance } from '@xyo-network/account-model'
+import { HttpBridge, HttpBridgeConfigSchema } from '@xyo-network/bridge'
+import { Module } from '@xyo-network/module'
+import { MemoryNode, NodeConfigSchema, NodeWrapper } from '@xyo-network/node'
+import { PayloadSetPluginResolver } from '@xyo-network/payloadset-plugin'
+import { assertDefinedEx } from '@xyo-network/react-shared'
+import { WitnessModule } from '@xyo-network/witness'
+
+import { SentinelBuilder, SentinelBuilderConfig, SentinelCallbacks } from './SentinelBuilder'
+import { StorageArchivistBuilder } from './StorageArchivistBuilder'
+
+interface MemoryNodeBuilderConfig {
+  name?: string
+  node?: MemoryNode
+}
+
+export class MemoryNodeBuilder {
+  private _node: MemoryNode | undefined
+  private _wrappedNode: NodeWrapper | undefined
+
+  get node() {
+    return assertDefinedEx(this._node, 'this._node was not defined upon create')
+  }
+
+  get wrappedNode() {
+    return assertDefinedEx(this._wrappedNode, 'this._wrappedNode was not defined upon create')
+  }
+
+  static async create({ name, node }: MemoryNodeBuilderConfig, account?: AccountInstance): Promise<MemoryNodeBuilder> {
+    const instance = new this()
+
+    let memoryNode: MemoryNode
+    if (node) {
+      memoryNode = node
+    } else {
+      memoryNode = await MemoryNode.create({ account, config: { name, schema: NodeConfigSchema } })
+    }
+    instance._node = memoryNode
+    instance._wrappedNode = NodeWrapper.wrap(memoryNode)
+    return instance
+  }
+
+  async addArchivist(account: AccountInstance, moduleName: string, namespace: string) {
+    const config = { name: moduleName, namespace }
+    const { archivist } = await StorageArchivistBuilder.create(config, account, this.node)
+
+    await this.attach(archivist, true)
+  }
+
+  async addBridge(apiDomain: string) {
+    try {
+      const bridge = await HttpBridge.create({
+        config: { name: 'RemoteNodeBridge', nodeUri: `${apiDomain}/node`, schema: HttpBridgeConfigSchema, security: { allowAnonymous: true } },
+      })
+      await this.attach(bridge, true)
+    } catch (e) {
+      console.error('Error Creating Bridge', e)
+    }
+  }
+
+  async addSentinel(config: SentinelBuilderConfig, account: AccountInstance, callbacks: SentinelCallbacks) {
+    const { sentinel } = await SentinelBuilder.create(config, account, callbacks)
+    await this.attach(sentinel, true, true)
+    return sentinel
+  }
+
+  async addWitnesses(pluginSetResolver: PayloadSetPluginResolver, witnesses: (() => Promise<WitnessModule>)[] = []) {
+    await Promise.all(
+      pluginSetResolver.witnesses().map(async (pluginSet, index) => {
+        // Pass the prebuilt witness at the same index
+        const witness = await witnesses?.[index]?.()
+        if (witness) {
+          try {
+            await this.node.register(witness).attach(witness.address, true)
+          } catch (e) {
+            console.error('Error attaching witness', JSON.stringify(pluginSet, null, 2), e)
+          }
+        }
+      }),
+    )
+  }
+
+  private async attach(module: Module, external?: boolean, safeAttach?: boolean) {
+    try {
+      if (safeAttach) {
+        const existingModule = await this.wrappedNode.resolve(module.address)
+        if (existingModule) {
+          await this.node.detach(existingModule.address)
+          await this.node.unregister(existingModule)
+        }
+      }
+      this.node.register(module)
+      await this.node.attach(module.address, external)
+    } catch (e) {
+      throw Error(`Error adding ${module.config.name ?? module.address} to MemoryNode: ${e}`)
+    }
+  }
+}

package/src/lib/Builders/SentinelBuilder.ts

@@ -0,0 +1,44 @@
+import { AccountInstance } from '@xyo-network/account-model'
+import { assertDefinedEx } from '@xyo-network/react-shared'
+import { MemorySentinel, SentinelConfigSchema, SentinelParams } from '@xyo-network/sentinel'
+
+export type SentinelCallbacks = Pick<SentinelParams, 'onReportEnd' | 'onReportStart' | 'onWitnessReportStart' | 'onWitnessReportEnd'>
+
+export interface SentinelBuilderConfig {
+  name: string
+  witnesses: string[]
+}
+
+export class SentinelBuilder {
+  private _sentinel: MemorySentinel | undefined
+
+  protected constructor(private config: SentinelBuilderConfig, private account: AccountInstance) {
+    assertDefinedEx(config, 'config was not defined')
+  }
+
+  get sentinel() {
+    return assertDefinedEx(this._sentinel, 'this._sentinel not defined upon create')
+  }
+
+  static async create(config: SentinelBuilderConfig, account: AccountInstance, callbacks: SentinelCallbacks): Promise<SentinelBuilder> {
+    const instance = new this(config, account)
+    instance._sentinel = await instance.buildSentinel(callbacks)
+    return instance
+  }
+
+  async buildSentinel(callbacks: SentinelCallbacks) {
+    const params = this.buildParams(callbacks)
+    return await MemorySentinel.create(params)
+  }
+
+  private buildParams(callbacks: SentinelCallbacks): SentinelParams {
+    return {
+      config: {
+        ...this.config,
+        schema: SentinelConfigSchema,
+      },
+      ...callbacks,
+      account: this.account,
+    }
+  }
+}

package/src/lib/Builders/StorageArchivistBuilder.ts

@@ -0,0 +1,57 @@
+import { AccountInstance } from '@xyo-network/account-model'
+import { ArchivistModule, StorageArchivistConfig, StorageArchivistConfigSchema, XyoStorageArchivist } from '@xyo-network/archivist'
+import { MemoryNode, NodeWrapper } from '@xyo-network/node'
+import { assertDefinedEx } from '@xyo-network/react-shared'
+
+export interface ArchivistBuilderConfig {
+  name: string
+  namespace: string
+}
+export class StorageArchivistBuilder {
+  private _archivist: XyoStorageArchivist | undefined
+  private remoteArchivist: ArchivistModule | undefined
+
+  protected constructor(private config: ArchivistBuilderConfig, private account: AccountInstance, private node: MemoryNode) {}
+
+  get archivist() {
+    return assertDefinedEx(this._archivist, 'archivist was not defined upon create')
+  }
+
+  static async create(config: ArchivistBuilderConfig, account: AccountInstance, node: MemoryNode): Promise<StorageArchivistBuilder> {
+    const instance = new this(config, account, node)
+    instance.remoteArchivist = await instance.findParentArchivist()
+    instance._archivist = await instance.buildArchivist()
+    return instance
+  }
+
+  async buildArchivist() {
+    const config = this.buildConfig()
+    return await XyoStorageArchivist.create({ account: this.account, config })
+  }
+
+  buildConfig(): StorageArchivistConfig {
+    return {
+      name: this.config.name,
+      namespace: this.config.namespace,
+      parents: {
+        commit: this.remoteArchivist ? [this.remoteArchivist?.address] : undefined,
+        read: this.remoteArchivist ? [this.remoteArchivist?.address] : undefined,
+      },
+      schema: StorageArchivistConfigSchema,
+      type: 'local',
+    }
+  }
+
+  async findParentArchivist() {
+    const wrappedNode = new NodeWrapper(assertDefinedEx(this.node, 'node not defined'), this.account)
+    const [bridge] = (await wrappedNode.resolve({ name: ['RemoteNodeBridge'] })) ?? []
+    if (bridge) {
+      try {
+        const [archivist] = (await bridge.downResolver.resolve({ name: ['Archivist'] })) ?? []
+        return archivist as ArchivistModule
+      } catch (e) {
+        console.error('Error Resolving Parent Archivist', this.node?.config.name, this.config)
+      }
+    }
+  }
+}

package/src/lib/Builders/index.ts

@@ -0,0 +1,3 @@
+export * from './MemoryNodeBuilder'
+export * from './SentinelBuilder'
+export * from './StorageArchivistBuilder'

package/src/lib/ModuleAccountPaths.ts

@@ -0,0 +1,24 @@
+import { RootStorageArchivist } from './ModuleNames'
+
+export const GlobalNodeOffsetPath = '15'
+
+export const RemoteNodeOffsetPaths: Record<string, string> = {
+  Kerplunk: '112',
+  Local: '111',
+  Main: '113',
+}
+
+export const RemoteNodeArchivistOffsetPaths: Record<string, Record<string, string>> = {
+  Kerplunk: {
+    MemoryNode: '117',
+    [RootStorageArchivist]: '119',
+  },
+  Local: {
+    MemoryNode: '114',
+    [RootStorageArchivist]: '116',
+  },
+  Main: {
+    MemoryNode: '120',
+    [RootStorageArchivist]: '122',
+  },
+}

package/src/lib/ModuleNames.ts

@@ -0,0 +1,3 @@
+export const GlobalNode = 'GlobalNode'
+
+export const RootStorageArchivist = 'RootStorageArchivist'

package/src/lib/buildNodes.ts

@@ -0,0 +1,46 @@
+import { MemoryNode } from '@xyo-network/node'
+import { HDWallet } from '@xyo-network/protocol'
+import { defaultNetworkConfigs } from '@xyo-network/react-network'
+import { assertDefinedEx } from '@xyo-network/react-shared'
+
+import { MemoryNodeBuilder } from './Builders'
+import { RemoteNodeArchivistOffsetPaths, RemoteNodeOffsetPaths } from './ModuleAccountPaths'
+import { RootStorageArchivist } from './ModuleNames'
+
+const MainApiUrlFallback = 'https://beta.api.archivist.xyo.network'
+
+const knownRemoteNodes = (): { apiDomain: string; name: string }[] => {
+  const networkNames = defaultNetworkConfigs.map((config) => config.name)
+  return networkNames.map((networkName) => {
+    const name = assertDefinedEx<string>(networkName, 'missing name in network config')
+    const uri = defaultNetworkConfigs.filter((config) => config.name === networkName)[0].nodes?.filter((node) => node.type === 'archivist')[0].uri
+    const apiDomain = assertDefinedEx<string>(uri, 'missing node type "archivist" in network config')
+    return {
+      // Temporary till main is compatible with /node endpoint
+      apiDomain: name === 'Main' ? MainApiUrlFallback : apiDomain,
+      name,
+    }
+  })
+}
+
+export const BuildStandardNodes = async (wallet: HDWallet): Promise<MemoryNode[]> => {
+  try {
+    return await Promise.all(
+      knownRemoteNodes().map(async ({ apiDomain, name }) => {
+        const remoteNodeOffset = RemoteNodeOffsetPaths[name]
+        const remoteNodeWallet = wallet.derivePath(remoteNodeOffset)
+
+        const memoryNodeBuilder = await MemoryNodeBuilder.create({ name }, remoteNodeWallet.deriveAccount('0'))
+        await memoryNodeBuilder.addBridge(apiDomain)
+
+        const rootArchivistPath = `${remoteNodeOffset}/${RemoteNodeArchivistOffsetPaths[name][RootStorageArchivist]}`
+        const rootArchivistAccount = wallet.deriveAccount(rootArchivistPath)
+        await memoryNodeBuilder.addArchivist(rootArchivistAccount, RootStorageArchivist, 'root')
+
+        return assertDefinedEx(memoryNodeBuilder.node, 'Memory Node was not built successfully')
+      }),
+    )
+  } catch (e) {
+    throw new Error(`Error Creating Known Remote Nodes: ${e}`)
+  }
+}