@xyo-network/chain-bridge 1.15.2

package/dist/node/index.mjs

@@ -0,0 +1,751 @@
+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 { assertEx } from "@xylabs/assert";
+import { asyncHandler } from "@xylabs/express";
+import { asAddress, toAddress } from "@xylabs/hex";
+import { isModuleIdentifierPart } from "@xyo-network/module-model";
+import { StatusCodes } from "http-status-codes";
+var handler = /* @__PURE__ */ __name(async (req, res, next) => {
+  const { address: rawAddress } = req.params;
+  const { node } = req.app;
+  const address = asAddress(rawAddress);
+  if (address !== void 0) {
+    let mod = node.address === address ? node : await node.resolve(address, {
+      direction: "down"
+    });
+    if (mod) {
+      res.json(await mod.state());
+      return;
+    }
+  }
+  if (isModuleIdentifierPart(rawAddress)) {
+    const moduleIdentifier = toAddress(rawAddress);
+    const mod = await node.resolve(moduleIdentifier, {
+      direction: "down"
+    });
+    if (mod) {
+      const moduleAddress = assertEx(mod?.address, () => "Error redirecting to module by address");
+      res.redirect(StatusCodes.MOVED_TEMPORARILY, `/${moduleAddress}`);
+      return;
+    }
+  }
+  next("route");
+}, "handler");
+var getAddress = asyncHandler(handler);
+
+// src/server/routes/address/post/post.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { asyncHandler as asyncHandler2 } from "@xylabs/express";
+import { asAddress as asAddress2, isAddress, toAddress as toAddress2 } 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 = toAddress2(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 = assertEx2(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 } 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 (isDefined(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 = isDefined(req.query.limit) ? Number(req.query.limit) : void 0;
+    const open = isDefined(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 (isDefined(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 (isDefined(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/rpc/routes/addRpcRoutes.ts
+import { setRawResponseFormat as setRawResponseFormat2 } from "@xylabs/express";
+import { NodeXyoViewer } from "@xyo-network/chain-rpc";
+import { NodeXyoRunner, rpcEngineFromConnection, XyoBaseConnection } from "@xyo-network/xl1-rpc";
+var addRpcRoutes = /* @__PURE__ */ __name((app) => {
+  const { node } = app;
+  const runner = new NodeXyoRunner(node);
+  const viewer = new NodeXyoViewer(node);
+  const connection = new XyoBaseConnection({
+    runner,
+    viewer
+  });
+  const engine = rpcEngineFromConnection(connection);
+  app.post("/rpc", (req, res) => {
+    setRawResponseFormat2(res);
+    engine.handle(req.body, (_, rpcResponse) => {
+      res.json(rpcResponse);
+    });
+  });
+}, "addRpcRoutes");
+
+// src/server/routes/addRoutes.ts
+var addRoutes = /* @__PURE__ */ __name((app) => {
+  addRpcRoutes(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 assertEx5 } from "@xylabs/assert";
+import { isDefined as isDefined3, isString } from "@xylabs/typeof";
+import { boot } from "@xyo-network/bios";
+import { HDWallet } from "@xyo-network/wallet";
+
+// src/manifest/getLocator.ts
+import { assertEx as assertEx4 } from "@xylabs/assert";
+import { asAddress as asAddress3, ZERO_ADDRESS } from "@xylabs/hex";
+import { BaseMongoSdk } from "@xylabs/mongo";
+import { isDefined as isDefined2 } 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 { AddressBalanceDivinerV2, ArchivistSyncDiviner, balanceSummaryRepositoryFromMap, 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";
+
+// src/driver/mongo/MongoMap.ts
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { AbstractCreatable, creatable } from "@xylabs/creatable";
+import { isNull } from "@xylabs/typeof";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function stripMongoId(doc) {
+  const { _id, ...rest } = doc;
+  return rest;
+}
+__name(stripMongoId, "stripMongoId");
+var MongoMap = class extends AbstractCreatable {
+  static {
+    __name(this, "MongoMap");
+  }
+  get sdk() {
+    return assertEx3(this.params.sdk, () => "No sdk specified");
+  }
+  async clear() {
+    await this.sdk.deleteMany({});
+  }
+  async delete(id) {
+    const filter = {
+      _id: id
+    };
+    const result = await this.sdk.deleteOne(filter);
+    return result.deletedCount > 0;
+  }
+  async get(id) {
+    const filter = {
+      _id: id
+    };
+    const doc = await this.sdk.findOne(filter);
+    return isNull(doc) ? void 0 : stripMongoId(doc);
+  }
+  async has(id) {
+    const filter = {
+      _id: id
+    };
+    const exists = await this.sdk.findOne(filter);
+    return isNull(exists) ? false : true;
+  }
+  async set(id, data) {
+    const filter = {
+      _id: id
+    };
+    const value = {
+      ...data,
+      _id: id
+    };
+    await this.sdk.replaceOne(filter, value, {
+      upsert: true
+    });
+    return this;
+  }
+  async startHandler() {
+    await super.startHandler();
+  }
+};
+MongoMap = _ts_decorate([
+  creatable()
+], MongoMap);
+
+// src/manifest/getLocator.ts
+var getLocator = /* @__PURE__ */ __name(async (context) => {
+  const { config, logger } = context;
+  const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { traceProvider, meterProvider } = await initTelemetry({
+    attributes: {
+      serviceName: "xl1-bridge",
+      serviceVersion: "1.0.0"
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint: "/metrics",
+      port: 9465
+    }
+  });
+  if (isDefined2(logger)) AbstractModule.defaultLogger = logger;
+  const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
+  const locator = new ModuleFactoryLocator();
+  let summaryMap = /* @__PURE__ */ new Map();
+  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 sdk = new BaseMongoSdk({
+      ...payloadSdkConfig,
+      collection: "balance_summary_map"
+    });
+    summaryMap = await MongoMap.create({
+      sdk
+    });
+  }
+  const summaryRepository = balanceSummaryRepositoryFromMap(summaryMap);
+  locator.register(AddressBalanceDivinerV2.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter,
+    summaryRepository
+  }));
+  const chainId = isDefined2(config.chain.id) ? assertEx4(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
+  }));
+  locator.register(ArchivistSyncDiviner.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: "Chain:Submissions",
+                  targetModuleFunction: "divine"
+                }
+              ],
+              inArchivist: "Chain:Submissions",
+              outArchivist: "Chain: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: 6e4,
+                  frequencyUnits: "millis",
+                  schema: "network.xyo.automation.interval",
+                  type: "interval"
+                }
+              ],
+              name: "AddressBalancePollingSentinel",
+              schema: "network.xyo.sentinel.config",
+              synchronous: true,
+              tasks: [
+                {
+                  mod: "AddressBalanceDiviner",
+                  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: 5e3
+              },
+              originArchivist: "Chain:Validated",
+              schema: "network.xyo.archivist.view.config"
+            }
+          },
+          {
+            config: {
+              accountPath: "1/1/3",
+              schema: "network.xyo.diviner.chain.address.balance.config",
+              archivist: "Chain:Validated",
+              name: "AddressBalanceDiviner",
+              eventSubscriptions: [
+                {
+                  sourceEvent: "inserted",
+                  sourceModule: "Chain:Validated",
+                  targetModuleFunction: "divine"
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  ],
+  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/2",
+              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(`[Bridge] Stored mnemonic: ${storedSeedPhrase}`);
+  const { mnemonic } = config.api;
+  if (isString(storedSeedPhrase) && isString(mnemonic)) {
+    logger?.warn("[Bridge] 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("[Bridge] No mnemonic provided, using random mnemonic. This is not recommended for production use.");
+      logger?.log(`[Bridge] Mnemonic: ${seedPhrase}`);
+    }
+    await bios.seedPhraseStore.set("os", seedPhrase);
+  }
+  return assertEx5(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.api;
+  const bios = await boot();
+  const seedPhrase = isDefined3(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
+  const wallet = await HDWallet.fromPhrase(seedPhrase);
+  const nodeContext = {
+    wallet,
+    logger,
+    config
+  };
+  const app = getApp(node ?? await getNode(nodeContext));
+  const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`));
+  server.setTimeout(2e4);
+  return server;
+}, "getServer");
+export {
+  getApp,
+  getServer
+};
+//# sourceMappingURL=index.mjs.map