@xyo-network/sdk 2.102.4 → 7.0.3

package/dist/_pkg/sdk-protocol/_pkg/manifest-model/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Manifest.ts';
+export * from './Payload.ts';

package/dist/_pkg/sdk-protocol/_pkg/manifest-model/neutral/index.mjs

@@ -0,0 +1,192 @@
+// src/Manifest.zod.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import * as z from "zod/mini";
+var isString = (value) => typeof value === "string";
+var stringZod = z.string();
+var optionalStringZod = z.optional(stringZod);
+var optionalStringArrayZod = z.optional(z.array(stringZod));
+var optionalStringRecordZod = z.optional(z.record(stringZod, optionalStringZod));
+var xyoAddressZod = z.custom(isString);
+var nullableStringZod = z.nullable(stringZod);
+var optionalAddressChildrenRecordZod = z.optional(z.record(xyoAddressZod, nullableStringZod));
+var schemaZod = z.custom(isString);
+var asBrandedZod = (schema) => {
+  return z.pipe(schema, z.transform((value) => value));
+};
+var ModuleAliasZod = asBrandedZod(z.string());
+var ManifestZod = z.object({
+  $schema: z.optional(z.string()),
+  description: z.optional(z.string())
+});
+var isManifest = zodIsFactory(ManifestZod);
+var asManifest = zodAsFactory(ManifestZod, "asManifest");
+var toManifest = zodToFactory(ManifestZod, "toManifest");
+var ConfigManifestZod = z.looseObject({
+  accountPath: optionalStringZod,
+  features: optionalStringArrayZod,
+  labels: optionalStringRecordZod,
+  language: optionalStringZod,
+  name: stringZod,
+  os: optionalStringZod,
+  schema: schemaZod
+});
+var isConfigManifest = zodIsFactory(ConfigManifestZod);
+var asConfigManifest = zodAsFactory(ConfigManifestZod, "asConfigManifest");
+var toConfigManifest = zodToFactory(ConfigManifestZod, "toConfigManifest");
+var ModuleManifestStatusZod = z.object({
+  address: xyoAddressZod,
+  children: optionalAddressChildrenRecordZod
+});
+var ModuleManifestZod = z.extend(ManifestZod, {
+  config: ConfigManifestZod,
+  lazyStart: z.optional(z.boolean()),
+  status: z.optional(ModuleManifestStatusZod)
+});
+var isModuleManifest = zodIsFactory(ModuleManifestZod);
+var asModuleManifest = zodAsFactory(ModuleManifestZod, "asModuleManifest");
+var toModuleManifest = zodToFactory(ModuleManifestZod, "toModuleManifest");
+var ModuleManifestReferenceZod = z.union([ModuleManifestZod, ModuleAliasZod]);
+var moduleManifestReferenceArrayZod = z.optional(z.array(ModuleManifestReferenceZod));
+var nodeModulesZod = z.optional(z.object({ private: moduleManifestReferenceArrayZod, public: moduleManifestReferenceArrayZod }));
+var NodeManifestZod = z.extend(ModuleManifestZod, { modules: nodeModulesZod });
+var isNodeManifest = zodIsFactory(NodeManifestZod);
+var asNodeManifest = zodAsFactory(NodeManifestZod, "asNodeManifest");
+var toNodeManifest = zodToFactory(NodeManifestZod, "toNodeManifest");
+var PackageManifestZod = z.extend(ManifestZod, {
+  modules: z.optional(z.record(ModuleAliasZod, ModuleManifestZod)),
+  nodes: z.array(NodeManifestZod)
+});
+var isPackageManifest = zodIsFactory(PackageManifestZod);
+var asPackageManifest = zodAsFactory(PackageManifestZod, "asPackageManifest");
+var toPackageManifest = zodToFactory(PackageManifestZod, "toPackageManifest");
+var AuthoredModuleManifestBaseZod = z.strictObject({
+  config: ConfigManifestZod,
+  description: z.optional(z.string())
+});
+var AuthoredModuleManifestZod = AuthoredModuleManifestBaseZod;
+var isAuthoredModuleManifest = zodIsFactory(AuthoredModuleManifestZod);
+var asAuthoredModuleManifest = zodAsFactory(AuthoredModuleManifestZod, "asAuthoredModuleManifest");
+var toAuthoredModuleManifest = zodToFactory(AuthoredModuleManifestZod, "toAuthoredModuleManifest");
+var authoredModuleManifestArrayZod = z.optional(z.array(AuthoredModuleManifestBaseZod));
+var authoredNodeModulesZod = z.optional(z.strictObject({
+  private: authoredModuleManifestArrayZod,
+  public: authoredModuleManifestArrayZod
+}));
+var AuthoredNodeManifestZod = z.extend(AuthoredModuleManifestBaseZod, {
+  modules: authoredNodeModulesZod,
+  name: optionalStringZod
+});
+var isAuthoredNodeManifest = zodIsFactory(AuthoredNodeManifestZod);
+var asAuthoredNodeManifest = zodAsFactory(AuthoredNodeManifestZod, "asAuthoredNodeManifest");
+var toAuthoredNodeManifest = zodToFactory(AuthoredNodeManifestZod, "toAuthoredNodeManifest");
+var AuthoredPackageManifestZod = z.strictObject({
+  $schema: z.optional(z.string()),
+  description: z.optional(z.string()),
+  nodes: z.array(AuthoredNodeManifestZod),
+  schema: z.literal("network.xyo.manifest")
+});
+var isAuthoredPackageManifest = zodIsFactory(AuthoredPackageManifestZod);
+var asAuthoredPackageManifest = zodAsFactory(AuthoredPackageManifestZod, "asAuthoredPackageManifest");
+var toAuthoredPackageManifest = zodToFactory(AuthoredPackageManifestZod, "toAuthoredPackageManifest");
+var ExternalModuleRequestZod = z.strictObject({ name: z.string() });
+var ExternalManifestZod = z.strictObject({ modules: z.array(ExternalModuleRequestZod) });
+var AuthoredDappPackageManifestZod = z.strictObject({
+  $schema: z.optional(z.string()),
+  description: z.optional(z.string()),
+  external: z.optional(ExternalManifestZod),
+  nodes: z.array(AuthoredNodeManifestZod),
+  schema: z.literal("network.xyo.manifest.package.dapp")
+});
+var isAuthoredDappPackageManifest = zodIsFactory(AuthoredDappPackageManifestZod);
+var asAuthoredDappPackageManifest = zodAsFactory(AuthoredDappPackageManifestZod, "asAuthoredDappPackageManifest");
+var toAuthoredDappPackageManifest = zodToFactory(AuthoredDappPackageManifestZod, "toAuthoredDappPackageManifest");
+
+// src/Payload.zod.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk";
+import { asSchema } from "../../payload-model/neutral/index.mjs";
+import * as z2 from "zod/mini";
+var DappPackageManifestPayloadSchema = asSchema("network.xyo.manifest.package.dapp", true);
+var PackageManifestPayloadSchema = asSchema("network.xyo.manifest.package", true);
+var ModuleManifestPayloadSchema = asSchema("network.xyo.module.manifest", true);
+var NodeManifestPayloadSchema = asSchema("network.xyo.node.manifest", true);
+var NodeManifestPayloadZod = z2.extend(NodeManifestZod, { schema: z2.literal(NodeManifestPayloadSchema) });
+var isNodeManifestPayload = zodIsFactory2(NodeManifestPayloadZod);
+var asNodeManifestPayload = zodAsFactory2(NodeManifestPayloadZod, "asNodeManifestPayload");
+var toNodeManifestPayload = zodToFactory2(NodeManifestPayloadZod, "toNodeManifestPayload");
+var ModuleManifestPayloadZod = z2.extend(ModuleManifestZod, { schema: z2.union([z2.literal(ModuleManifestPayloadSchema), z2.literal(NodeManifestPayloadSchema)]) });
+var isModuleManifestPayload = zodIsFactory2(ModuleManifestPayloadZod);
+var asModuleManifestPayload = zodAsFactory2(ModuleManifestPayloadZod, "asModuleManifestPayload");
+var toModuleManifestPayload = zodToFactory2(ModuleManifestPayloadZod, "toModuleManifestPayload");
+var PackageManifestPayloadZod = z2.extend(PackageManifestZod, { schema: z2.literal(PackageManifestPayloadSchema) });
+var isPackageManifestPayload = zodIsFactory2(PackageManifestPayloadZod);
+var asPackageManifestPayload = zodAsFactory2(PackageManifestPayloadZod, "asPackageManifestPayload");
+var toPackageManifestPayload = zodToFactory2(PackageManifestPayloadZod, "toPackageManifestPayload");
+export {
+  AuthoredDappPackageManifestZod,
+  AuthoredModuleManifestZod,
+  AuthoredNodeManifestZod,
+  AuthoredPackageManifestZod,
+  ConfigManifestZod,
+  DappPackageManifestPayloadSchema,
+  ExternalManifestZod,
+  ExternalModuleRequestZod,
+  ManifestZod,
+  ModuleAliasZod,
+  ModuleAliasZod as ModuleAliasZodSchema,
+  ModuleManifestPayloadSchema,
+  ModuleManifestPayloadZod,
+  ModuleManifestReferenceZod,
+  ModuleManifestStatusZod,
+  ModuleManifestZod,
+  NodeManifestPayloadSchema,
+  NodeManifestPayloadZod,
+  NodeManifestZod,
+  PackageManifestPayloadSchema,
+  PackageManifestPayloadZod,
+  PackageManifestZod,
+  asAuthoredDappPackageManifest,
+  asAuthoredModuleManifest,
+  asAuthoredNodeManifest,
+  asAuthoredPackageManifest,
+  asBrandedZod,
+  asConfigManifest,
+  asManifest,
+  asModuleManifest,
+  asModuleManifestPayload,
+  asNodeManifest,
+  asNodeManifestPayload,
+  asPackageManifest,
+  asPackageManifestPayload,
+  isAuthoredDappPackageManifest,
+  isAuthoredModuleManifest,
+  isAuthoredNodeManifest,
+  isAuthoredPackageManifest,
+  isConfigManifest,
+  isManifest,
+  isModuleManifest,
+  isModuleManifestPayload,
+  isNodeManifest,
+  isNodeManifestPayload,
+  isPackageManifest,
+  isPackageManifestPayload,
+  toAuthoredDappPackageManifest,
+  toAuthoredModuleManifest,
+  toAuthoredNodeManifest,
+  toAuthoredPackageManifest,
+  toConfigManifest,
+  toManifest,
+  toModuleManifest,
+  toModuleManifestPayload,
+  toNodeManifest,
+  toNodeManifestPayload,
+  toPackageManifest,
+  toPackageManifestPayload
+};

package/dist/_pkg/sdk-protocol/_pkg/metamask-connector/browser/MetaMaskConnector.d.ts

@@ -0,0 +1,37 @@
+import type { MetaMaskInpageProvider } from '@metamask/providers';
+import type { Listener } from 'ethers';
+import { BrowserProvider } from 'ethers';
+declare global {
+    var ethereum: MetaMaskInpageProvider | undefined;
+}
+export declare class MetaMaskConnector {
+    private account;
+    private ethereum;
+    private listeners;
+    private provider;
+    private providerListeners;
+    constructor(provider?: BrowserProvider);
+    get chainId(): string | null | undefined;
+    get currentAccount(): string | null | undefined;
+    connectWallet(): Promise<void>;
+    isMetaMaskInstalled(): true | undefined;
+    isWalletIsConnected(): boolean;
+    /**
+     * EIP-1193 Event Listeners
+     *
+     * .on in Web3Provider does not understand EIP-1193 events
+     * see - https://github.com/ethers-io/ethers.js/discussions/1560#discussioncomment-730893
+     */
+    providerOnAccountsChanged(listener: Listener): void;
+    providerOnChainChanged(listener: Listener): void;
+    providerOnConnect(listener: Listener): void;
+    providerOnDisconnect(listener: Listener): void;
+    providerRemoveListener(event: string, listener: Listener): void;
+    providerRemoveListeners(): void;
+    requestAccounts(): Promise<string[] | null>;
+    signMessage(message: string): Promise<string | undefined>;
+    /** Web3Provider Listeners - https://docs.ethers.org/v5/api/providers/provider/#Provider--events */
+    web3ProviderOn(event: string, listener: Listener): void;
+    web3ProviderRemoveListener(event: string, listener: Listener): void;
+    web3ProviderRemoveListeners(): void;
+}

package/dist/_pkg/sdk-protocol/_pkg/metamask-connector/browser/index.d.ts

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

package/dist/_pkg/sdk-protocol/_pkg/metamask-connector/browser/index.mjs

@@ -0,0 +1,113 @@
+// src/MetaMaskConnector.ts
+import { forget, isString } from "@xylabs/sdk";
+import { BrowserProvider } from "ethers";
+var MetaMaskConnector = class {
+  account = "";
+  ethereum = globalThis.ethereum;
+  listeners = [];
+  provider;
+  providerListeners = [];
+  constructor(provider) {
+    if (provider) {
+      this.provider = provider;
+    } else if (this.ethereum) {
+      this.provider = new BrowserProvider(this.ethereum);
+    }
+  }
+  get chainId() {
+    return this.ethereum?.networkVersion;
+  }
+  get currentAccount() {
+    return this.ethereum?.selectedAddress;
+  }
+  async connectWallet() {
+    if (!this.provider) {
+      logProviderMissing();
+      return;
+    }
+    const accounts = await this.provider.send("eth_requestAccounts", []);
+    if (accounts.length > 0) {
+      this.account = accounts[0];
+      console.log("Connected:", this.account);
+    } else {
+      console.log("No authorized account found.");
+    }
+  }
+  isMetaMaskInstalled() {
+    return this.ethereum?.isMetaMask;
+  }
+  isWalletIsConnected() {
+    if (isString(this.currentAccount)) {
+      console.log("Found an authorized account:", this.ethereum?.selectedAddress);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * EIP-1193 Event Listeners
+   *
+   * .on in Web3Provider does not understand EIP-1193 events
+   * see - https://github.com/ethers-io/ethers.js/discussions/1560#discussioncomment-730893
+   */
+  providerOnAccountsChanged(listener) {
+    this.ethereum?.on("accountsChanged", listener);
+    this.providerListeners.push(["accountsChanged", listener]);
+  }
+  providerOnChainChanged(listener) {
+    this.ethereum?.on("chainChanged", listener);
+    this.providerListeners.push(["chainChanged", listener]);
+  }
+  providerOnConnect(listener) {
+    this.ethereum?.on("connect", listener);
+    this.providerListeners.push(["connect", listener]);
+  }
+  providerOnDisconnect(listener) {
+    this.ethereum?.on("disconnect", listener);
+    this.providerListeners.push(["disconnect", listener]);
+  }
+  providerRemoveListener(event, listener) {
+    this.providerListeners = this.providerListeners.filter(([, savedListener]) => listener !== savedListener);
+  }
+  providerRemoveListeners() {
+  }
+  async requestAccounts() {
+    if (!this.provider) {
+      logProviderMissing();
+      return null;
+    }
+    return await this.provider.send("eth_requestAccounts", []);
+  }
+  async signMessage(message) {
+    if (!this.provider) {
+      logProviderMissing();
+      return;
+    }
+    const signer = await this.provider.getSigner();
+    await signer.getAddress();
+    return await signer.signMessage(message);
+  }
+  /** Web3Provider Listeners - https://docs.ethers.org/v5/api/providers/provider/#Provider--events */
+  web3ProviderOn(event, listener) {
+    if (this.provider) {
+      forget(this.provider.on(event, listener));
+    }
+    this.listeners.push(listener);
+  }
+  web3ProviderRemoveListener(event, listener) {
+    if (this.provider) {
+      forget(this.provider.removeListener(event, listener));
+    }
+    this.listeners = this.listeners.filter((savedListener) => listener !== savedListener);
+  }
+  web3ProviderRemoveListeners() {
+    if (this.provider) {
+      forget(this.provider.removeAllListeners());
+    }
+  }
+};
+function logProviderMissing() {
+  console.warn("Cannot call this method because there is no web3 provider connected.  Please confirm that metamask is installed");
+}
+export {
+  MetaMaskConnector
+};

package/dist/_pkg/sdk-protocol/_pkg/network/neutral/NetworkNodePayload.d.ts

@@ -0,0 +1,78 @@
+import * as z from 'zod/mini';
+export declare const NetworkNodeTypeZod: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"archivist">, z.ZodMiniLiteral<"diviner">, z.ZodMiniLiteral<"bridge">, z.ZodMiniLiteral<"sentinel">]>;
+export type NetworkNodeType = z.infer<typeof NetworkNodeTypeZod>;
+export declare const NetworkNodeSchema: "network.xyo.network.node" & {
+    readonly __schema: true;
+};
+export type NetworkNodeSchema = typeof NetworkNodeSchema;
+export declare const NetworkNodePayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.network.node" & {
+        readonly __schema: true;
+    }>;
+    docs: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    slug: z.ZodMiniString<string>;
+    type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"archivist">, z.ZodMiniLiteral<"diviner">, z.ZodMiniLiteral<"bridge">, z.ZodMiniLiteral<"sentinel">]>;
+    uri: z.ZodMiniString<string>;
+    web: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export type NetworkNodePayload = z.infer<typeof NetworkNodePayloadZod>;
+export declare const isNetworkNodePayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.network.node" & {
+        readonly __schema: true;
+    };
+    slug: string;
+    type: "archivist" | "diviner" | "bridge" | "sentinel";
+    uri: string;
+    docs?: string | undefined;
+    name?: string | undefined;
+    web?: string | undefined;
+};
+export declare const asNetworkNodePayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    };
+};
+export declare const toNetworkNodePayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    };
+};

package/dist/_pkg/sdk-protocol/_pkg/network/neutral/NetworkNodePayloadWrapper.d.ts

@@ -0,0 +1,16 @@
+import type { Hash } from '@xylabs/sdk';
+import { PayloadWrapper } from '../../payload-wrapper/neutral/index.ts';
+import type { NetworkNodePayload } from './NetworkNodePayload.ts';
+export declare class NetworkNodePayloadWrapper<T extends NetworkNodePayload = NetworkNodePayload> extends PayloadWrapper<T> {
+    static known(hash: Hash): Promise<NetworkNodePayloadWrapper<{
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }>>;
+}

package/dist/_pkg/sdk-protocol/_pkg/network/neutral/NetworkPayload.d.ts

@@ -0,0 +1,118 @@
+import * as z from 'zod/mini';
+export declare const NetworkSchema: "network.xyo.network" & {
+    readonly __schema: true;
+};
+export type NetworkSchema = typeof NetworkSchema;
+export declare const NetworkPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.network" & {
+        readonly __schema: true;
+    }>;
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    nodes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
+        schema: z.ZodMiniLiteral<"network.xyo.network.node" & {
+            readonly __schema: true;
+        }>;
+        docs: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        slug: z.ZodMiniString<string>;
+        type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"archivist">, z.ZodMiniLiteral<"diviner">, z.ZodMiniLiteral<"bridge">, z.ZodMiniLiteral<"sentinel">]>;
+        uri: z.ZodMiniString<string>;
+        web: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>>>;
+    slug: z.ZodMiniString<string>;
+}, z.core.$strip>;
+export type NetworkPayload = z.infer<typeof NetworkPayloadZod>;
+export declare const isNetworkPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.network" & {
+        readonly __schema: true;
+    };
+    slug: string;
+    name?: string | undefined;
+    nodes?: {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }[] | undefined;
+};
+export declare const asNetworkPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    };
+};
+export declare const toNetworkPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.network" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        name?: string | undefined;
+        nodes?: {
+            schema: "network.xyo.network.node" & {
+                readonly __schema: true;
+            };
+            slug: string;
+            type: "archivist" | "diviner" | "bridge" | "sentinel";
+            uri: string;
+            docs?: string | undefined;
+            name?: string | undefined;
+            web?: string | undefined;
+        }[] | undefined;
+    };
+};

package/dist/_pkg/sdk-protocol/_pkg/network/neutral/NetworkPayloadWrapper.d.ts

@@ -0,0 +1,62 @@
+import type { Hash } from '@xylabs/sdk';
+import { PayloadWrapper } from '../../payload-wrapper/neutral/index.ts';
+import type { NetworkNodeType } from './NetworkNodePayload.ts';
+import type { NetworkPayload } from './NetworkPayload.ts';
+export declare class NetworkPayloadWrapper extends PayloadWrapper<NetworkPayload> {
+    static known(hash: Hash): Promise<NetworkPayload | undefined>;
+    get archivists(): {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }[] | undefined;
+    get bridges(): {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }[] | undefined;
+    get diviners(): {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }[] | undefined;
+    get sentinels(): {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }[] | undefined;
+    filterNodesByType(type: NetworkNodeType): {
+        schema: "network.xyo.network.node" & {
+            readonly __schema: true;
+        };
+        slug: string;
+        type: "archivist" | "diviner" | "bridge" | "sentinel";
+        uri: string;
+        docs?: string | undefined;
+        name?: string | undefined;
+        web?: string | undefined;
+    }[] | undefined;
+}

package/dist/_pkg/sdk-protocol/_pkg/network/neutral/index.d.ts

@@ -0,0 +1,7 @@
+export * from './knownArchivists.ts';
+export * from './knownDiviners.ts';
+export * from './knownNetworks.ts';
+export * from './NetworkNodePayload.ts';
+export * from './NetworkNodePayloadWrapper.ts';
+export * from './NetworkPayload.ts';
+export * from './NetworkPayloadWrapper.ts';