@xyo-network/chain-mempool 1.16.3

package/dist/node/index.mjs

@@ -0,0 +1,618 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/server/app.ts
+import { customPoweredByHeader, disableCaseSensitiveRouting, disableExpressDefaultPoweredByHeader, getJsonBodyParser, getJsonBodyParserOptions, responseProfiler, standardErrors, standardResponses } from "@xylabs/express";
+import compression from "compression";
+import cors from "cors";
+import express2 from "express";
+
+// src/server/instrumentation.ts
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+var addInstrumentation = /* @__PURE__ */ __name(() => {
+  const instrumentations = [
+    new HttpInstrumentation(),
+    new ExpressInstrumentation()
+  ];
+  registerInstrumentations({
+    instrumentations
+  });
+}, "addInstrumentation");
+
+// src/server/routes/address/addNodeRoutes.ts
+import { StatusCodes as StatusCodes3 } from "http-status-codes";
+
+// src/server/routes/address/get/get.ts
+import { asyncHandler } from "@xylabs/express";
+import { asAddress } from "@xylabs/hex";
+import { isDefined } from "@xylabs/typeof";
+import { isModuleName } from "@xyo-network/module-model";
+import { StatusCodes } from "http-status-codes";
+var handler = /* @__PURE__ */ __name(async (req, res, next) => {
+  const { address: moduleIdentifier } = req.params;
+  const { node } = req.app;
+  const address = asAddress(moduleIdentifier);
+  if (isDefined(address)) {
+    let mod = node.address === address ? node : await node.resolve(address, {
+      direction: "down"
+    });
+    if (mod) {
+      res.json(await mod.state());
+      return;
+    }
+  }
+  if (isModuleName(moduleIdentifier)) {
+    const mod = await node.resolve(moduleIdentifier, {
+      direction: "down"
+    });
+    if (mod) {
+      res.redirect(StatusCodes.MOVED_TEMPORARILY, `/${mod.address}`);
+      return;
+    }
+  }
+  next("route");
+}, "handler");
+var getAddress = asyncHandler(handler);
+
+// src/server/routes/address/post/post.ts
+import { assertEx } from "@xylabs/assert";
+import { asyncHandler as asyncHandler2 } from "@xylabs/express";
+import { asAddress as asAddress2, isAddress, toAddress } from "@xylabs/hex";
+import { isQueryBoundWitness } from "@xyo-network/boundwitness-model";
+import { ModuleErrorBuilder } from "@xyo-network/module-abstract";
+import { StatusCodes as StatusCodes2 } from "http-status-codes";
+
+// src/server/routes/address/post/getQueryConfig.ts
+import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
+import { ModuleConfigSchema } from "@xyo-network/module-model";
+var DEFAULT_DEPTH = 5;
+var getQueryConfig = /* @__PURE__ */ __name((mod, req, bw, payloads) => {
+  const nestedBwAddresses = payloads?.flat(DEFAULT_DEPTH).filter((payload) => payload?.schema === BoundWitnessSchema).map((bw2) => bw2.addresses) ?? [];
+  const addresses = [
+    bw.addresses,
+    ...nestedBwAddresses
+  ].filter((address) => address.length > 0);
+  const allowed = addresses.length > 0 ? Object.fromEntries(mod.queries.map((schema) => [
+    schema,
+    addresses
+  ])) : {};
+  const security = {
+    allowed
+  };
+  return {
+    schema: ModuleConfigSchema,
+    security
+  };
+}, "getQueryConfig");
+
+// src/server/routes/address/post/post.ts
+var handler2 = /* @__PURE__ */ __name(async (req, res, next) => {
+  const returnError = /* @__PURE__ */ __name((code, message = "An error occurred", details) => {
+    const error = new ModuleErrorBuilder().message(message).details(details).build();
+    res.locals.rawResponse = false;
+    res.status(code).json(error);
+    next();
+  }, "returnError");
+  const { address } = req.params;
+  const { node } = req.app;
+  const [bw, payloads] = Array.isArray(req.body) ? req.body : [];
+  if (!isAddress(address)) {
+    return returnError(StatusCodes2.BAD_REQUEST, "Missing address");
+  }
+  if (!bw) {
+    return returnError(StatusCodes2.BAD_REQUEST, "Missing boundwitness");
+  }
+  if (!isQueryBoundWitness(bw)) {
+    return returnError(StatusCodes2.BAD_REQUEST, "Invalid query boundwitness");
+  }
+  let modules = [];
+  const normalizedAddress = toAddress(address);
+  if (node.address === normalizedAddress) modules = [
+    node
+  ];
+  else {
+    const typedAddress = asAddress2(address);
+    const byAddress = typedAddress === void 0 ? void 0 : await node.resolve(typedAddress, {
+      maxDepth: 10
+    });
+    if (byAddress) modules = [
+      byAddress
+    ];
+    else {
+      const byName = await node.resolve(address, {
+        direction: "down"
+      });
+      if (byName) {
+        const moduleAddress = assertEx(byName?.address, () => "Error redirecting to module by address");
+        res.redirect(StatusCodes2.TEMPORARY_REDIRECT, `/${moduleAddress}`);
+        return;
+      } else {
+        return returnError(StatusCodes2.NOT_FOUND, "Module not found", {
+          address
+        });
+      }
+    }
+  }
+  if (modules.length > 0) {
+    const mod = modules[0];
+    const queryConfig = getQueryConfig(mod, req, bw, payloads);
+    try {
+      const queryResult = await mod.query(bw, payloads, queryConfig);
+      res.json(queryResult);
+    } catch (ex) {
+      return returnError(StatusCodes2.INTERNAL_SERVER_ERROR, "Query Failed", {
+        message: ex?.message ?? "Unknown Error"
+      });
+    }
+  } else {
+    return returnError(StatusCodes2.NOT_FOUND, "Module not found", {
+      address
+    });
+  }
+}, "handler");
+var postAddress = asyncHandler2(handler2);
+
+// src/server/routes/address/addNodeRoutes.ts
+var addNodeRoutes = /* @__PURE__ */ __name((app) => {
+  const defaultModule = app.node;
+  const address = defaultModule.address;
+  const defaultModuleEndpoint = `/${address}`;
+  app.get("/", (_req, res) => res.redirect(StatusCodes3.MOVED_TEMPORARILY, defaultModuleEndpoint));
+  app.post("/", (_req, res) => res.redirect(StatusCodes3.TEMPORARY_REDIRECT, defaultModuleEndpoint));
+  app.get("/:address", getAddress);
+  app.post("/:address", postAddress);
+  app.get("/:hash", (_req, res) => {
+    res.sendStatus(StatusCodes3.NOT_FOUND);
+  });
+  app.post("/:hash", (_req, res) => {
+    res.sendStatus(StatusCodes3.NOT_FOUND);
+  });
+}, "addNodeRoutes");
+
+// src/server/routes/dataLake/archivistMiddleware.ts
+import { setRawResponseFormat } from "@xylabs/express";
+import { asHash } from "@xylabs/hex";
+import { isDefined as isDefined2 } from "@xylabs/typeof";
+import { asArchivistInstance } from "@xyo-network/archivist-model";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { isAnyPayload, isSequence } from "@xyo-network/payload-model";
+import express from "express";
+var resolveArchivist = /* @__PURE__ */ __name(async (node, archivistModuleIdentifier) => {
+  const mod = await node.resolve(archivistModuleIdentifier);
+  return asArchivistInstance(mod, {
+    required: true
+  });
+}, "resolveArchivist");
+var archivistInstance;
+var getArchivist = /* @__PURE__ */ __name(async (node, archivistModuleIdentifier) => {
+  if (isDefined2(archivistInstance)) return archivistInstance;
+  archivistInstance = await resolveArchivist(node, archivistModuleIdentifier);
+  return archivistInstance;
+}, "getArchivist");
+var archivistMiddleware = /* @__PURE__ */ __name((options) => {
+  const { node, archivistModuleIdentifier } = options;
+  const router = express.Router({
+    mergeParams: true
+  });
+  router.post("/insert", async (req, res) => {
+    setRawResponseFormat(res);
+    const body = Array.isArray(req.body) ? req.body : [
+      req.body
+    ];
+    const payloads = (await PayloadBuilder.hashPairs(body)).map((p) => p[0]);
+    const archivist = await getArchivist(node, archivistModuleIdentifier);
+    const result = await archivist.insert(payloads);
+    res.status(200).json(result);
+  });
+  router.get("/next", async (req, res) => {
+    setRawResponseFormat(res);
+    const cursor = isSequence(req.query.cursor) ? req.query.cursor : void 0;
+    const limit = isDefined2(req.query.limit) ? Number(req.query.limit) : void 0;
+    const open = isDefined2(req.query.open) ? Boolean(req.query.open) : void 0;
+    const order = req.query.order === "asc" ? "asc" : "desc";
+    const options2 = {
+      limit,
+      open,
+      order,
+      cursor
+    };
+    const archivist = await getArchivist(node, archivistModuleIdentifier);
+    const result = await archivist.next(options2);
+    res.status(200).json(result);
+  });
+  router.post("/next", async (req, res) => {
+    setRawResponseFormat(res);
+    const options2 = req.body;
+    const archivist = await getArchivist(node, archivistModuleIdentifier);
+    const result = await (isDefined2(options2) ? archivist.next(options2) : archivist.next());
+    res.status(200).json(result);
+  });
+  router.get("/get/:hash", async (req, res) => {
+    setRawResponseFormat(res);
+    const { hash: rawHash } = req.params;
+    const hash = asHash(rawHash);
+    if (isDefined2(hash)) {
+      const archivist = await getArchivist(node, archivistModuleIdentifier);
+      const [payload] = await archivist.get([
+        hash
+      ]);
+      if (isAnyPayload(payload)) {
+        res.json(payload);
+        return;
+      }
+    }
+    res.status(400).send();
+  });
+  return router;
+}, "archivistMiddleware");
+
+// src/server/routes/dataLake/addDataLakeRoutes.ts
+var addDataLakeRoutes = /* @__PURE__ */ __name((app) => {
+  const { node } = app;
+  const archivistModuleIdentifier = "Chain:Finalized";
+  app.use("/chain", archivistMiddleware({
+    node,
+    archivistModuleIdentifier
+  }));
+}, "addDataLakeRoutes");
+
+// src/server/routes/healthz/addHealthRoutes.ts
+import { StatusCodes as StatusCodes4 } from "http-status-codes";
+var addHealthRoutes = /* @__PURE__ */ __name((app) => {
+  app.get("/healthz", (_req, res) => {
+    res.status(StatusCodes4.OK).send();
+  });
+  app.get("/livez", (_req, res) => {
+    res.status(StatusCodes4.OK).send();
+  });
+  app.get("/readyz", (_req, res) => {
+    res.status(StatusCodes4.OK).send();
+  });
+}, "addHealthRoutes");
+
+// src/server/routes/addRoutes.ts
+var addRoutes = /* @__PURE__ */ __name((app) => {
+  addHealthRoutes(app);
+  addDataLakeRoutes(app);
+  addNodeRoutes(app);
+}, "addRoutes");
+
+// src/server/app.ts
+var getApp = /* @__PURE__ */ __name((node) => {
+  addInstrumentation();
+  const app = express2();
+  app.set("etag", false);
+  app.use(cors());
+  app.use(compression());
+  app.use(responseProfiler);
+  app.use(getJsonBodyParser(getJsonBodyParserOptions({
+    limit: "1mb"
+  })));
+  app.use(standardResponses);
+  disableExpressDefaultPoweredByHeader(app);
+  app.use(customPoweredByHeader);
+  disableCaseSensitiveRouting(app);
+  app.node = node;
+  addRoutes(app);
+  app.use(standardErrors);
+  return app;
+}, "getApp");
+
+// src/server/server.ts
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { isDefined as isDefined4, isString } from "@xylabs/typeof";
+import { boot } from "@xyo-network/bios";
+import { HDWallet } from "@xyo-network/wallet";
+
+// src/manifest/getLocator.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { asAddress as asAddress3, ZERO_ADDRESS } from "@xylabs/hex";
+import { isDefined as isDefined3 } from "@xylabs/typeof";
+import { MemoryArchivist } from "@xyo-network/archivist-memory";
+import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
+import { ViewArchivist } from "@xyo-network/archivist-view";
+import { 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 } from "@xyo-network/sentinel-memory";
+import { hasMongoConfig } from "@xyo-network/xl1-protocol-sdk";
+var getLocator = /* @__PURE__ */ __name(async (context) => {
+  const { config, logger } = context;
+  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 (isDefined3(logger)) AbstractModule.defaultLogger = logger;
+  const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
+  const locator = new ModuleFactoryLocator();
+  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 params = {
+      meterProvider,
+      payloadSdkConfig,
+      statusReporter,
+      traceProvider
+    };
+    locator.register(MongoDBArchivistV2.factory(params), void 0, true);
+  }
+  const chainId = isDefined3(config.chain.id) ? assertEx2(asAddress3(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(MemoryArchivist.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  locator.register(MemorySentinel.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  locator.register(ViewArchivist.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  return locator;
+}, "getLocator");
+
+// src/manifest/getNode.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/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"
+                }
+              ]
+            }
+          }
+        ],
+        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"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/manifest/public/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/index.ts
+var ChainNodeManifest = Chain_default;
+var PendingNodeManifest = Pending_default;
+var PublicChildManifests = [
+  ...ChainNodeManifest.nodes,
+  ...PendingNodeManifest.nodes
+];
+
+// src/manifest/getNode.ts
+var getNode = /* @__PURE__ */ __name(async (context) => {
+  const { wallet } = context;
+  const locator = await getLocator(context);
+  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;
+}, "getNode");
+
+// src/server/server.ts
+var hostname = "::";
+var getSeedPhrase = /* @__PURE__ */ __name(async (bios, config, logger) => {
+  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 = HDWallet.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 assertEx3(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+}, "getSeedPhrase");
+var getServer = /* @__PURE__ */ __name(async (context) => {
+  const { config, logger, node } = context;
+  const { mnemonic, port } = context.config.mempool;
+  const bios = await boot();
+  const seedPhrase = isDefined4(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
+  const wallet = await HDWallet.fromPhrase(seedPhrase);
+  const nodeContext = {
+    wallet,
+    logger,
+    config
+  };
+  const resolvedNode = node ?? await getNode(nodeContext);
+  const mods = await resolvedNode.resolve("*");
+  const startResults = await Promise.all(mods.map((mod) => mod.start?.() ?? true));
+  assertEx3(startResults.every((r) => r === true), () => "[Mempool] Not all modules started successfully");
+  const app = getApp(resolvedNode);
+  const server = app.listen(port, hostname, () => logger?.log(`[Mempool] Server listening at http://${hostname}:${port}`));
+  server.setTimeout(2e4);
+  return server;
+}, "getServer");
+export {
+  getApp,
+  getServer
+};
+//# sourceMappingURL=index.mjs.map