@xyo-network/chain-orchestration 1.16.21 → 1.16.23

package/dist/neutral/index.mjs

@@ -134,8 +134,44 @@ async function createProducerChainStakeIntentBlock(prevBlock, producerAccount, r
 }
 __name(createProducerChainStakeIntentBlock, "createProducerChainStakeIntentBlock");
 
-// src/initBridgedModule.ts
+// src/init/initBalanceSummaryMap.ts
+import { BaseMongoSdk } from "@xylabs/mongo";
 import { assertEx } from "@xylabs/sdk-js";
+import { MongoMap } from "@xyo-network/chain-protocol";
+import { hasMongoConfig, MemoryMap } from "@xyo-network/xl1-protocol-sdk";
+async function initBalanceSummaryMap({ config, logger }) {
+  const mongoConfig = config.storage?.mongo;
+  if (hasMongoConfig(mongoConfig)) {
+    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const payloadSdkConfig = {
+      dbConnectionString,
+      dbDomain,
+      dbName,
+      dbPassword,
+      dbUserName
+    };
+    const sdkBalanceSummaryMap = new BaseMongoSdk({
+      ...payloadSdkConfig,
+      collection: "balance_summary_map"
+    });
+    const result = await MongoMap.create({
+      sdk: sdkBalanceSummaryMap,
+      getCache: {
+        enabled: true,
+        maxEntries: 5e3
+      }
+    });
+    assertEx(await result.start(), () => "Failed to start transfer summary map");
+    return result;
+  } else {
+    logger?.warn("[API] Mongo configuration not found. Using MemoryMap for BalanceSummaryMap.");
+    return new MemoryMap();
+  }
+}
+__name(initBalanceSummaryMap, "initBalanceSummaryMap");
+
+// src/init/initBridgedModule.ts
+import { assertEx as assertEx2 } from "@xylabs/sdk-js";
 import { asAttachableArchivistInstance } from "@xyo-network/archivist-model";
 import { asAttachableModuleInstance } from "@xyo-network/module-model";
 import { Mutex as Mutex2 } from "async-mutex";
@@ -145,8 +181,8 @@ var initBridgedModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) =>
   return await initMutex2.runExclusive(async () => {
     const existing = bridgedModuleDictionary?.[bridge.address]?.[moduleName];
     if (existing) return existing;
-    const mod = assertEx(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
-    const moduleInstance = assertEx(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
+    const mod = assertEx2(await bridge.resolve(moduleName), () => `Could not resolve ${moduleName}`);
+    const moduleInstance = assertEx2(asAttachableModuleInstance(mod), () => `Could not convert ${moduleName} to attachable module instance`);
     let moduleMap = bridgedModuleDictionary[bridge.address];
     if (moduleMap === void 0) {
       moduleMap = {};
@@ -157,32 +193,32 @@ var initBridgedModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) =>
   });
 }, "initBridgedModule");
 var initBridgedArchivistModule = /* @__PURE__ */ __name(async ({ bridge, moduleName }) => {
-  return assertEx(asAttachableArchivistInstance(await initBridgedModule({
+  return assertEx2(asAttachableArchivistInstance(await initBridgedModule({
     bridge,
     moduleName
   })), () => `Could not convert ${moduleName} to attachable archivist instance`);
 }, "initBridgedArchivistModule");
 
-// src/initChainStakeViewer.ts
-import { assertEx as assertEx6, toEthAddress } from "@xylabs/sdk-js";
+// src/init/initChainStakeViewer.ts
+import { asAddress, assertEx as assertEx7, toAddress, toEthAddress } from "@xylabs/sdk-js";
 import { EthereumChainStakeEvents, EthereumChainStakeViewer } from "@xyo-network/chain-sdk";
 import { StakedXyoChainV2__factory } from "@xyo-network/typechain";
 import { SimpleChainStakeViewer } from "@xyo-network/xl1-protocol-sdk";
 
 // src/evm/initEvmProvider.ts
-import { assertEx as assertEx5 } from "@xylabs/sdk-js";
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
 
 // src/evm/initInfuraProvider.ts
-import { assertEx as assertEx3, isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx4, isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { InfuraProvider } from "ethers/providers";
 
 // src/evm/initChainId.ts
-import { assertEx as assertEx2, hexFrom, isDefined, isHex } from "@xylabs/sdk-js";
+import { assertEx as assertEx3, hexFrom, isDefined, isHex } from "@xylabs/sdk-js";
 var canUseChainId = /* @__PURE__ */ __name((config) => {
   return isDefined(config.evm.chainId);
 }, "canUseChainId");
 var getChainId = /* @__PURE__ */ __name((config) => {
-  const chainId = assertEx2(config.evm.chainId, () => "Missing config.evm.chainId");
+  const chainId = assertEx3(config.evm.chainId, () => "Missing config.evm.chainId");
   if (isHex(chainId, {
     prefix: true
   })) {
@@ -207,8 +243,8 @@ var canUseInfuraProvider = /* @__PURE__ */ __name((config) => {
   return canUseChainId(config) && isDefined2(config.evm?.infura?.projectId) && isDefined2(config.evm?.infura?.projectSecret);
 }, "canUseInfuraProvider");
 var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
-  const projectId = assertEx3(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
-  const projectSecret = assertEx3(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
+  const projectId = assertEx4(config.evm?.infura?.projectId, () => "Missing config.evm.infura.projectId");
+  const projectSecret = assertEx4(config.evm?.infura?.projectSecret, () => "Missing config.evm.infura.projectSecret");
   return [
     getChainId(config),
     projectId,
@@ -217,7 +253,7 @@ var getInfuraProviderConfig = /* @__PURE__ */ __name((config) => {
 }, "getInfuraProviderConfig");
 
 // src/evm/initJsonRpcProvider.ts
-import { assertEx as assertEx4, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx5, isDefined as isDefined3 } from "@xylabs/sdk-js";
 import { JsonRpcProvider } from "ethers/providers";
 var initJsonRpcProvider = /* @__PURE__ */ __name((config) => {
   const providerConfig = getJsonRpcProviderConfig(config);
@@ -227,7 +263,7 @@ var canUseJsonRpcProvider = /* @__PURE__ */ __name((config) => {
   return canUseChainId(config) && isDefined3(config.evm.jsonRpc?.url);
 }, "canUseJsonRpcProvider");
 var getJsonRpcProviderConfig = /* @__PURE__ */ __name((config) => {
-  const jsonRpcUrl = assertEx4(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
+  const jsonRpcUrl = assertEx5(config.evm.jsonRpc?.url, () => "Missing config.evm.jsonRpc.url");
   return [
     jsonRpcUrl,
     getChainId(config)
@@ -243,40 +279,41 @@ var initEvmProvider = /* @__PURE__ */ __name(async ({ config }) => {
   } else if (canUseJsonRpcProvider(config)) {
     provider = initJsonRpcProvider(config);
   }
-  return assertEx5(await provider, () => "No provider available");
+  return assertEx6(await provider, () => "No provider available");
 }, "initEvmProvider");
 var canUseEvmProvider = /* @__PURE__ */ __name(({ config }) => {
   return canUseInfuraProvider(config) || canUseJsonRpcProvider(config);
 }, "canUseEvmProvider");
 
-// src/initChainStakeViewer.ts
+// src/init/initChainStakeViewer.ts
 async function initEvmChainStakeViewer(config, logger) {
   const provider2 = await initEvmProvider({
     config,
     logger
   });
-  const contractAddress = assertEx6(config.chain.id, () => "Missing config.evm.chainId");
+  const contractAddress = assertEx7(config.chain.id, () => "Missing config.evm.chainId");
   const contract = StakedXyoChainV2__factory.connect(toEthAddress(contractAddress), provider2);
   const stakeEventsViewer = await EthereumChainStakeEvents.create({
     contract,
     logger
   });
-  assertEx6(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEvents reader");
+  assertEx7(await stakeEventsViewer.start(), () => "Failed to start EthereumChainStakeEvents reader");
   const stakeChainViewer = await EthereumChainStakeViewer.create({
     contract,
     stakeEventsViewer,
     logger
   });
-  assertEx6(await stakeChainViewer.start(), () => "Failed to start EthereumChainStake viewer");
+  assertEx7(await stakeChainViewer.start(), () => "Failed to start EthereumChainStake viewer");
   return stakeChainViewer;
 }
 __name(initEvmChainStakeViewer, "initEvmChainStakeViewer");
 async function initSimpleStakeViewer(config, logger) {
   const stakeChainViewer = await SimpleChainStakeViewer.create({
+    chainId: asAddress(toAddress(1n), true),
     logger,
     positions: []
   });
-  assertEx6(await stakeChainViewer.start(), () => "Failed to start SimpleChainStake viewer");
+  assertEx7(await stakeChainViewer.start(), () => "Failed to start SimpleChainStake viewer");
   return stakeChainViewer;
 }
 __name(initSimpleStakeViewer, "initSimpleStakeViewer");
@@ -292,7 +329,7 @@ async function initChainStakeViewer(config, logger) {
 }
 __name(initChainStakeViewer, "initChainStakeViewer");
 
-// src/initProducerAccount.ts
+// src/init/initProducerAccount.ts
 import { isUndefined } from "@xylabs/sdk-js";
 import { HDWallet } from "@xyo-network/wallet";
 import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-protocol-sdk";
@@ -315,17 +352,646 @@ ${randomMnemonic}
   accountServiceSingleton = account;
   return accountServiceSingleton;
 }, "initProducerAccount");
+
+// src/init/initSeedPhrase.ts
+import { assertEx as assertEx8, isString } from "@xylabs/sdk-js";
+import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
+async function initSeedPhrase({ config, logger, bios }) {
+  const storedSeedPhrase = await bios.seedPhraseStore.get("os");
+  logger?.debug(`[API] Stored mnemonic: ${storedSeedPhrase}`);
+  const { mnemonic } = config.api;
+  if (isString(storedSeedPhrase) && isString(mnemonic)) {
+    logger?.warn("[API] Stored mnemonic does not match supplied. Updating stored mnemonic to supplied.");
+    await bios.seedPhraseStore.set("os", mnemonic);
+  } else {
+    let seedPhrase;
+    if (isString(mnemonic)) {
+      seedPhrase = mnemonic;
+    } else {
+      seedPhrase = HDWallet2.generateMnemonic();
+      logger?.log("[API] No mnemonic provided, using random mnemonic. This is not recommended for production use.");
+      logger?.log(`[API] Mnemonic: ${seedPhrase}`);
+    }
+    await bios.seedPhraseStore.set("os", seedPhrase);
+  }
+  return assertEx8(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+}
+__name(initSeedPhrase, "initSeedPhrase");
+
+// src/init/initServerNode.ts
+import { assertEx as assertEx10 } from "@xylabs/sdk-js";
+import { asArchivistInstance } from "@xyo-network/archivist-model";
+
+// src/manifest/getLocator.ts
+import { asAddress as asAddress2, assertEx as assertEx9, isDefined as isDefined4, ZERO_ADDRESS } from "@xylabs/sdk-js";
+import { MemoryArchivist as MemoryArchivist2 } from "@xyo-network/archivist-memory";
+import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
+import { ViewArchivist } from "@xyo-network/archivist-view";
+import { AddressBalanceDivinerV2, AddressTransferDiviner, ArchivistSyncDiviner as ArchivistSyncDiviner2, HeadValidationDiviner } from "@xyo-network/chain-modules";
+import { initTelemetry } from "@xyo-network/chain-telemetry";
+import { AbstractModule, LoggerModuleStatusReporter } from "@xyo-network/module-abstract";
+import { ModuleFactoryLocator } from "@xyo-network/module-factory-locator";
+import { MemorySentinel as MemorySentinel2 } from "@xyo-network/sentinel-memory";
+import { StepSizes } from "@xyo-network/xl1-protocol";
+import { hasMongoConfig as hasMongoConfig2 } from "@xyo-network/xl1-protocol-sdk";
+import { Semaphore } from "async-mutex";
+var getLocator = /* @__PURE__ */ __name(async ({ config, logger, balanceSummaryMap, transferSummaryMap }) => {
+  const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { traceProvider, meterProvider } = await initTelemetry({
+    attributes: {
+      serviceName: "xl1-api",
+      serviceVersion: "1.0.0"
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint: "/metrics",
+      port: 9465
+    }
+  });
+  if (isDefined4(logger)) AbstractModule.defaultLogger = logger;
+  const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
+  const locator = new ModuleFactoryLocator();
+  const mongoConfig = config.storage?.mongo;
+  if (hasMongoConfig2(mongoConfig)) {
+    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const payloadSdkConfig = {
+      dbConnectionString,
+      dbDomain,
+      dbName,
+      dbPassword,
+      dbUserName
+    };
+    const params = {
+      meterProvider,
+      payloadSdkConfig,
+      statusReporter,
+      traceProvider
+    };
+    locator.register(MongoDBArchivistV2.factory(params), void 0, true);
+  }
+  locator.register(AddressBalanceDivinerV2.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter,
+    summaryMap: balanceSummaryMap,
+    stepSemaphores: StepSizes.map(() => new Semaphore(20))
+  }));
+  locator.register(AddressTransferDiviner.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter,
+    summaryMap: transferSummaryMap,
+    stepSemaphores: StepSizes.map(() => new Semaphore(20))
+  }));
+  const chainId = isDefined4(config.chain.id) ? assertEx9(asAddress2(config.chain.id), () => "chain.id must be an Address") : ZERO_ADDRESS;
+  locator.register(HeadValidationDiviner.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter,
+    chainId,
+    allowedProducers: config.producer.allowlist
+  }));
+  locator.register(MemoryArchivist2.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  locator.register(MemorySentinel2.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  locator.register(ViewArchivist.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  locator.register(ArchivistSyncDiviner2.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  return locator;
+}, "getLocator");
+
+// src/manifest/loadNode.ts
+import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
+
+// src/manifest/node.json
+var node_default = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "44'/60'/1",
+        name: "XYOChain",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [],
+        public: []
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/manifest/nodeManifest.ts
+var NodeManifest = node_default;
+
+// src/manifest/private/index.ts
+var PrivateChildManifests = [];
+
+// src/manifest/public/WithMempool/Chain.json
+var Chain_default = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "1",
+        name: "Chain",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [
+          {
+            config: {
+              accountPath: "1/1'/1'",
+              name: "Validated",
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              payloadSdkConfig: {
+                collection: "chain_validated"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1'/2'",
+              schema: "network.xyo.diviner.chain.head.validation.config",
+              eventSubscriptions: [
+                {
+                  sourceEvent: "inserted",
+                  sourceModule: "Submissions",
+                  targetModuleFunction: "divine"
+                }
+              ],
+              inArchivist: "Submissions",
+              outArchivist: "Validated",
+              name: "HeadValidationDiviner"
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1'/3'",
+              automations: [
+                {
+                  frequency: 1e3,
+                  frequencyUnits: "millis",
+                  schema: "network.xyo.automation.interval",
+                  type: "interval"
+                }
+              ],
+              name: "ChainValidationSentinel",
+              schema: "network.xyo.sentinel.config",
+              synchronous: true,
+              tasks: [
+                {
+                  mod: "HeadValidationDiviner",
+                  endPoint: "divine"
+                }
+              ]
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1'/4'",
+              automations: [
+                {
+                  frequency: 1e4,
+                  frequencyUnits: "millis",
+                  schema: "network.xyo.automation.interval",
+                  type: "interval"
+                }
+              ],
+              name: "AddressBalancePollingSentinel",
+              schema: "network.xyo.sentinel.config",
+              synchronous: true,
+              tasks: [
+                {
+                  mod: "AddressBalanceDiviner",
+                  endPoint: "divine"
+                }
+              ]
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1'/5'",
+              automations: [
+                {
+                  frequency: 1e4,
+                  frequencyUnits: "millis",
+                  schema: "network.xyo.automation.interval",
+                  type: "interval"
+                }
+              ],
+              name: "AddressTransferPollingSentinel",
+              schema: "network.xyo.sentinel.config",
+              synchronous: true,
+              tasks: [
+                {
+                  mod: "AddressTransferDiviner",
+                  endPoint: "divine"
+                }
+              ]
+            }
+          }
+        ],
+        public: [
+          {
+            config: {
+              accountPath: "1/1/1",
+              name: "Submissions",
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              payloadSdkConfig: {
+                collection: "chain_submissions"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1/2",
+              name: "Finalized",
+              allowedQueries: [
+                "network.xyo.query.archivist.get",
+                "network.xyo.query.archivist.next"
+              ],
+              getCache: {
+                enabled: true,
+                maxEntries: 5e4
+              },
+              originArchivist: "Validated",
+              schema: "network.xyo.archivist.view.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1/3'",
+              name: "AddressBalanceDiviner",
+              schema: "network.xyo.diviner.chain.address.balance.config",
+              map: {
+                lmdb: {
+                  dbName: "summaries",
+                  storeName: "address_balance",
+                  location: ".store"
+                }
+              },
+              archivist: "Validated"
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1/4'",
+              name: "AddressTransferDiviner",
+              schema: "network.xyo.diviner.chain.address.transfer.config",
+              map: {
+                lmdb: {
+                  dbName: "summaries",
+                  storeName: "address_transfer",
+                  location: ".store"
+                }
+              },
+              archivist: "Validated"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/manifest/public/WithMempool/Pending.json
+var Pending_default = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "2",
+        name: "Pending",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [],
+        public: [
+          {
+            config: {
+              accountPath: "2/1/1",
+              name: "PendingTransactions",
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              labels: {
+                "network.xyo.storage.class": "mongodb"
+              },
+              payloadSdkConfig: {
+                collection: "pending_bundles"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/manifest/public/WithMempool/index.ts
+var ChainNodeManifest = Chain_default;
+var PendingNodeManifest = Pending_default;
+var PublicChildManifestsWithMempool = [
+  ...ChainNodeManifest.nodes,
+  ...PendingNodeManifest.nodes
+];
+
+// src/manifest/public/WithoutMempool/Chain.json
+var Chain_default2 = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "1",
+        name: "Chain",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [
+          {
+            config: {
+              accountPath: "1/1'/1'",
+              name: "Validated",
+              allowedQueries: [
+                "network.xyo.query.archivist.get",
+                "network.xyo.query.archivist.next"
+              ],
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              payloadSdkConfig: {
+                collection: "chain_validated"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          }
+        ],
+        public: [
+          {
+            config: {
+              accountPath: "1/1/1",
+              name: "Submissions",
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              payloadSdkConfig: {
+                collection: "chain_submissions"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1/2",
+              name: "Finalized",
+              allowedQueries: [
+                "network.xyo.query.archivist.get",
+                "network.xyo.query.archivist.next"
+              ],
+              getCache: {
+                enabled: true,
+                maxEntries: 5e4
+              },
+              originArchivist: "Validated",
+              schema: "network.xyo.archivist.view.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1/3'",
+              name: "AddressBalanceDiviner",
+              schema: "network.xyo.diviner.chain.address.balance.config",
+              map: {
+                lmdb: {
+                  dbName: "summaries",
+                  storeName: "address_balance",
+                  location: ".store"
+                }
+              },
+              archivist: "Validated"
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1/4'",
+              name: "AddressTransferDiviner",
+              schema: "network.xyo.diviner.chain.address.transfer.config",
+              map: {
+                lmdb: {
+                  dbName: "summaries",
+                  storeName: "address_transfer",
+                  location: ".store"
+                }
+              },
+              archivist: "Validated"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/manifest/public/WithoutMempool/Pending.json
+var Pending_default2 = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "2",
+        name: "Pending",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [],
+        public: [
+          {
+            config: {
+              accountPath: "2/1/1",
+              name: "PendingTransactions",
+              getCache: {
+                enabled: true,
+                maxEntries: 5e3
+              },
+              labels: {
+                "network.xyo.storage.class": "mongodb"
+              },
+              payloadSdkConfig: {
+                collection: "pending_bundles"
+              },
+              schema: "network.xyo.archivist.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/manifest/public/WithoutMempool/index.ts
+var ChainNodeManifest2 = Chain_default2;
+var PendingNodeManifest2 = Pending_default2;
+var PublicChildManifestsWithoutMempool = [
+  ...ChainNodeManifest2.nodes,
+  ...PendingNodeManifest2.nodes
+];
+
+// src/manifest/loadNode.ts
+var loadNode = /* @__PURE__ */ __name(async ({ wallet, config, balanceSummaryMap, transferSummaryMap }) => {
+  const { enabled: mempoolEnabled } = config.mempool;
+  const PublicChildManifests = mempoolEnabled ? PublicChildManifestsWithoutMempool : PublicChildManifestsWithMempool;
+  const locator = await getLocator({
+    config,
+    balanceSummaryMap,
+    transferSummaryMap
+  });
+  const wrapper = new ManifestWrapper(NodeManifest, wallet, locator, PublicChildManifests, PrivateChildManifests);
+  const [node, ...childNodes] = await wrapper.loadNodes();
+  if (childNodes?.length > 0) {
+    await Promise.all(childNodes.map((childNode) => node.register(childNode)));
+    await Promise.all(childNodes.map((childNode) => node.attach(childNode.address, true)));
+  }
+  return node;
+}, "loadNode");
+
+// src/init/initServerNode.ts
+async function chainArchivistFromNode(node) {
+  const chainArchivist = assertEx10(asArchivistInstance(await node.resolve("Chain:Validated"), {
+    required: true
+  }), () => "FinalizedArchivist not found in node");
+  return chainArchivist;
+}
+__name(chainArchivistFromNode, "chainArchivistFromNode");
+async function pendingArchivistFromNode(node) {
+  const pendingArchivist = assertEx10(asArchivistInstance(await node.resolve("XYOChain:Pending:PendingTransactions"), {
+    required: true
+  }), () => "PendingArchivist not found in node");
+  return pendingArchivist;
+}
+__name(pendingArchivistFromNode, "pendingArchivistFromNode");
+async function initServerNode({ wallet, logger, config, node: providedNode, transferSummaryMap, balanceSummaryMap }) {
+  const node = providedNode ?? await loadNode({
+    wallet,
+    logger,
+    config,
+    transferSummaryMap,
+    balanceSummaryMap
+  });
+  const chainArchivist = await chainArchivistFromNode(node);
+  const pendingArchivist = await pendingArchivistFromNode(node);
+  return {
+    node,
+    chainArchivist,
+    pendingArchivist
+  };
+}
+__name(initServerNode, "initServerNode");
+
+// src/init/initServerWallet.ts
+import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+import { boot } from "@xyo-network/bios";
+import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
+async function initServerWallet({ config, logger }) {
+  const { mnemonic } = config.api;
+  const bios = await boot();
+  const seedPhrase = isDefined5(mnemonic) ? mnemonic : await initSeedPhrase({
+    bios,
+    config,
+    logger
+  });
+  return await HDWallet3.fromPhrase(seedPhrase);
+}
+__name(initServerWallet, "initServerWallet");
+
+// src/init/initTransferSummaryMap.ts
+import { BaseMongoSdk as BaseMongoSdk2 } from "@xylabs/mongo";
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { MongoMap as MongoMap2 } from "@xyo-network/chain-protocol";
+import { hasMongoConfig as hasMongoConfig3, MemoryMap as MemoryMap2 } from "@xyo-network/xl1-protocol-sdk";
+async function initTransferSummaryMap({ config, logger }) {
+  const mongoConfig = config.storage?.mongo;
+  if (hasMongoConfig3(mongoConfig)) {
+    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const payloadSdkConfig = {
+      dbConnectionString,
+      dbDomain,
+      dbName,
+      dbPassword,
+      dbUserName
+    };
+    const sdkTransferSummaryMap = new BaseMongoSdk2({
+      ...payloadSdkConfig,
+      collection: "transfer_summary_map"
+    });
+    const result = await MongoMap2.create({
+      sdk: sdkTransferSummaryMap,
+      getCache: {
+        enabled: true,
+        maxEntries: 5e3
+      }
+    });
+    assertEx11(await result.start(), () => "Failed to start transfer summary map");
+    return result;
+  } else {
+    logger?.warn("[API] Mongo configuration not found. Using MemoryMap for TransferSummaryMap.");
+    return new MemoryMap2();
+  }
+}
+__name(initTransferSummaryMap, "initTransferSummaryMap");
 export {
   DefaultReadCachingArchivistConfig,
+  NodeManifest,
+  PrivateChildManifests,
+  PublicChildManifestsWithMempool,
+  PublicChildManifestsWithoutMempool,
   createProducerChainStakeIntentBlock,
+  getLocator,
   initArchivistSync,
+  initBalanceSummaryMap,
   initBridge,
   initBridgedArchivistModule,
   initBridgedModule,
   initChainStakeViewer,
   initEvmChainStakeViewer,
   initProducerAccount,
+  initSeedPhrase,
+  initServerNode,
+  initServerWallet,
   initSimpleStakeViewer,
+  initTransferSummaryMap,
+  loadNode,
   wrapWithReadCachingArchivist
 };
 //# sourceMappingURL=index.mjs.map