@xyo-network/chain-bridge 1.15.2 → 1.15.4

package/dist/node/index.mjs

@@ -5,7 +5,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 import { customPoweredByHeader, disableCaseSensitiveRouting, disableExpressDefaultPoweredByHeader, getJsonBodyParser, getJsonBodyParserOptions, responseProfiler, standardErrors, standardResponses } from "@xylabs/express";
 import compression from "compression";
 import cors from "cors";
-import express2 from "express";
+import express from "express";
 
 // src/server/instrumentation.ts
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
@@ -21,277 +21,316 @@ var addInstrumentation = /* @__PURE__ */ __name(() => {
   });
 }, "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/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
+import { toAddress as toAddress2, toHex } from "@xylabs/hex";
+import { PayloadZodStrictOfSchema } from "@xyo-network/payload-model";
+import { BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema } from "@xyo-network/xl1-protocol";
+import { z as z2 } from "zod";
 
-// 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
+// src/server/routes/bridge/middleware/requestHandlerValidator.ts
+import { isPromise } from "@xylabs/typeof";
+import { ReasonPhrases, StatusCodes } from "http-status-codes";
+import { z } from "zod";
+var EmptyParamsZod = z.object({}).catchall(z.string());
+var EmptyQueryParamsZod = z.object({}).catchall(z.union([
+  z.string(),
+  z.array(z.string())
+]));
+var ValidateRequestDefaults = {
+  params: EmptyParamsZod,
+  query: EmptyQueryParamsZod,
+  body: z.json(),
+  response: z.json()
+};
+function requestHandlerValidator(schemas) {
+  const validators = {
+    ...ValidateRequestDefaults,
+    ...schemas
   };
-}, "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
-        });
+  return (handler) => {
+    return async (req, res, next) => {
+      const originalJson = res.json.bind(res);
+      try {
+        const errors = [];
+        const keys = [
+          "params",
+          "query",
+          "body"
+        ];
+        for (const key of keys) {
+          const validator = validators[key];
+          const result2 = validator.safeParse(req[key]);
+          if (result2.success) {
+            Object.assign(req[key], result2.data);
+          } else {
+            errors.push(...result2.error.issues.map((issue) => issue.path.length === 0 ? `${key}: ${issue.message}` : `${key}.${issue.path.join(".")}: ${issue.message}`));
+          }
+        }
+        if (errors.length > 0) {
+          const message = errors.join("; ");
+          const err = new Error(message);
+          err.name = ReasonPhrases.BAD_REQUEST;
+          err.statusCode = StatusCodes.BAD_REQUEST;
+          next(err);
+          return false;
+        }
+        res.json = (data) => {
+          const result2 = validators.response.safeParse(data);
+          if (result2.success) {
+            return originalJson(result2.data);
+          } else {
+            const message = result2.error.issues.map((issue) => issue.path.length === 0 ? `response: ${issue.message}` : `response.${issue.path.join(".")}: ${issue.message}`).join("; ");
+            const err = new Error(message);
+            err.name = ReasonPhrases.INTERNAL_SERVER_ERROR;
+            err.statusCode = StatusCodes.INTERNAL_SERVER_ERROR;
+            res.json = originalJson;
+            throw err;
+          }
+        };
+        const result = handler(req, res, next);
+        if (result && isPromise(result)) {
+          await result;
+        }
+      } catch (err) {
+        res.json = originalJson;
+        next(err);
       }
-    }
-  }
-  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);
+    };
+  };
+}
+__name(requestHandlerValidator, "requestHandlerValidator");
 
-// 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);
+// src/server/routes/bridge/routeDefinitions/pathParams/ChainIdPathParam.ts
+import { hexFromHexString, HexZod, isAddress, toAddress } from "@xylabs/hex";
+import { isUndefined } from "@xylabs/typeof";
+var remoteChainId = toAddress("0x01");
+var ChainIdPathParam = HexZod.refine((val) => {
+  const chainIdHex = hexFromHexString(val, {
+    prefix: true
   });
-}, "addNodeRoutes");
+  if (isAddress(chainIdHex)) return false;
+  const suppliedChainId = toAddress(chainIdHex);
+  if (isUndefined(suppliedChainId)) return false;
+  return suppliedChainId === remoteChainId;
+}, {
+  message: `Only ${remoteChainId} is supported`
+});
 
-// 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
+// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
+var params = z2.object({
+  chainId: ChainIdPathParam,
+  nonce: z2.string()
+});
+var response = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape);
+var validateRequest = requestHandlerValidator({
+  params,
+  response
+});
+var bridgeFromRemoteStatus = {
+  method: "get",
+  path: "/bridge/chains/:chainId/bridgeFromRemote/status/:nonce",
+  handlers: validateRequest(async (req, res) => {
+    const { chainId } = req.params;
+    const rand = await Promise.resolve(Math.random());
+    const found = rand > 0.5;
+    if (!found) return res.sendStatus(404);
+    const confirmed = rand > 0.8;
+    if (!confirmed) return res.sendStatus(204);
+    const observation = {
+      schema: BridgeDestinationObservationSchema,
+      dest: chainId,
+      destAddress: toAddress2("0xabc"),
+      destAmount: toHex("0x100"),
+      destToken: toAddress2("0xdef"),
+      src: toAddress2("0x02"),
+      srcAddress: toAddress2("0x123"),
+      srcAmount: toHex("0x200"),
+      srcToken: toHex("0x456"),
+      destConfirmation: toHex("0x9999")
     };
-    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");
+    res.json(observation);
+  })
+};
 
-// 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/bridge/routeDefinitions/routes/bridgeToRemote.ts
+import { asHash, toAddress as toAddress3 } from "@xylabs/hex";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/payload-model";
+import { BridgeIntentFieldsZod, BridgeIntentSchema, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, TransferSchema } from "@xyo-network/xl1-protocol";
+import { z as z3 } from "zod";
+var remoteChainId2 = toAddress3("0x01");
+var params2 = z3.object({
+  chainId: ChainIdPathParam
+});
+var body = z3.tuple([
+  // TODO: TransactionBoundWitness
+  PayloadZodStrictOfSchema2(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
+  PayloadZodLooseOfSchema(TransferSchema)
+]);
+var response2 = PayloadZodStrictOfSchema2(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape);
+var validateRequest2 = requestHandlerValidator({
+  params: params2,
+  body,
+  response: response2
+});
+var bridgeToRemote = {
+  method: "post",
+  path: "/bridge/chains/:chainId/bridgeToRemote",
+  handlers: validateRequest2(async (req, res) => {
+    const { body: body3 } = req;
+    const [bridgeIntent, transfer] = body3;
+    const srcConfirmation = await Promise.resolve(asHash("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"));
+    const bridgeCommonFieldsZod = z3.object({}).extend(BridgeSourceObservationFieldsZod.shape);
+    const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent);
+    const bridgeObservationFields = {
+      ...bridgeCommonFields,
+      srcConfirmation
+    };
+    const bridgeObservation = new PayloadBuilder({
+      schema: BridgeSourceObservationSchema
+    }).fields(bridgeObservationFields).build();
+    res.json(bridgeObservation);
+  })
+};
 
-// 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);
+// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
+import { hexToBigInt, toAddress as toAddress4, toHex as toHex2 } from "@xylabs/hex";
+import { createTransferPayload } from "@xyo-network/chain-protocol";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { PayloadZodLooseOfSchema as PayloadZodLooseOfSchema2, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3 } from "@xyo-network/payload-model";
+import { BridgeIntentFieldsZod as BridgeIntentFieldsZod2, BridgeIntentSchema as BridgeIntentSchema2, TransferSchema as TransferSchema2 } from "@xyo-network/xl1-protocol";
+import { v4 } from "uuid";
+import { z as z4 } from "zod";
+var TOKEN_ADDRESS = "0x5FbDB2315678afecb367f032d93F642f64180aa3";
+var bridgeableTokenContract = toHex2(TOKEN_ADDRESS);
+var xl1ChainId = toAddress4("0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9");
+var fixedFee = 1000000000000000n;
+var percentFee = 5n;
+var bridgeEscrowAddress = toAddress4("0x0a");
+var bridgeFeesAddress = toAddress4("0x0b");
+var remoteChainId3 = toHex2("0x01");
+var params3 = z4.object({
+  chainId: ChainIdPathParam
+});
+var body2 = BridgeIntentFieldsZod2.pick({
+  destAddress: true,
+  srcAddress: true,
+  srcAmount: true
+});
+var response3 = z4.tuple([
+  PayloadZodStrictOfSchema3(BridgeIntentSchema2).extend(BridgeIntentFieldsZod2.shape),
+  PayloadZodLooseOfSchema2(TransferSchema2)
+]);
+var validateRequest3 = requestHandlerValidator({
+  params: params3,
+  body: body2,
+  response: response3
+});
+var bridgeToRemoteEstimate = {
+  method: "post",
+  path: "/bridge/chains/:chainId/bridgeToRemote/estimate",
+  handlers: validateRequest3((req, res) => {
+    const { srcAddress, srcAmount, destAddress } = req.body;
+    const srcAmountBigInt = hexToBigInt(srcAmount);
+    const feeAmount = fixedFee + srcAmountBigInt * percentFee / 100n;
+    const destAmountBigInt = srcAmountBigInt > feeAmount ? srcAmountBigInt - feeAmount : 0n;
+    const destAmount = toHex2(destAmountBigInt);
+    const nonce = v4();
+    const sender = toAddress4(srcAddress);
+    const bridgeIntentFields = {
+      // Source
+      src: xl1ChainId,
+      srcAddress,
+      srcAmount,
+      srcToken: xl1ChainId,
+      // Destination
+      dest: remoteChainId3,
+      destAddress,
+      destAmount,
+      destToken: bridgeableTokenContract,
+      nonce
+    };
+    const bridgeIntent = new PayloadBuilder2({
+      schema: BridgeIntentSchema2
+    }).fields(bridgeIntentFields).build();
+    const transfer = createTransferPayload(sender, {
+      [bridgeEscrowAddress]: destAmountBigInt,
+      [bridgeFeesAddress]: feeAmount
     });
-  });
-}, "addRpcRoutes");
+    res.json([
+      bridgeIntent,
+      transfer
+    ]);
+  })
+};
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteStatus.ts
+import { toAddress as toAddress5, toHex as toHex3 } from "@xylabs/hex";
+import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema4 } from "@xyo-network/payload-model";
+import { BridgeDestinationObservationFieldsZod as BridgeDestinationObservationFieldsZod2, BridgeDestinationObservationSchema as BridgeDestinationObservationSchema2 } from "@xyo-network/xl1-protocol";
+import { z as z5 } from "zod";
+var params4 = z5.object({
+  chainId: ChainIdPathParam,
+  nonce: z5.string()
+});
+var response4 = PayloadZodStrictOfSchema4(BridgeDestinationObservationSchema2).extend(BridgeDestinationObservationFieldsZod2.shape);
+var validateRequest4 = requestHandlerValidator({
+  params: params4,
+  response: response4
+});
+var bridgeToRemoteStatus = {
+  method: "get",
+  path: "/bridge/chains/:chainId/bridgeToRemote/status/:nonce",
+  handlers: validateRequest4(async (req, res) => {
+    const { chainId } = req.params;
+    const rand = await Promise.resolve(Math.random());
+    const found = rand > 0.5;
+    if (!found) return res.sendStatus(404);
+    const confirmed = rand > 0.8;
+    if (!confirmed) return res.sendStatus(204);
+    const observation = {
+      schema: BridgeDestinationObservationSchema2,
+      dest: chainId,
+      destAddress: toAddress5("0xabc"),
+      destAmount: toHex3("0x100"),
+      destToken: toAddress5("0xdef"),
+      src: toAddress5("0x02"),
+      srcAddress: toAddress5("0x123"),
+      srcAmount: toHex3("0x200"),
+      srcToken: toHex3("0x456"),
+      destConfirmation: toHex3("0x9999")
+    };
+    res.json(observation);
+  })
+};
+
+// src/server/routes/bridge/routeDefinitions/getRouteDefinitions.ts
+var getRouteDefinitions = /* @__PURE__ */ __name(() => {
+  return [
+    bridgeFromRemoteStatus,
+    bridgeToRemote,
+    bridgeToRemoteEstimate,
+    bridgeToRemoteStatus
+  ];
+}, "getRouteDefinitions");
+
+// src/server/routes/bridge/addBridgeRoutes.ts
+var addBridgeRoutes = /* @__PURE__ */ __name((app) => {
+  const routeDefinitions = getRouteDefinitions();
+  for (const definition of routeDefinitions) {
+    app[definition.method](definition.path, definition.handlers);
+  }
+}, "addBridgeRoutes");
 
 // src/server/routes/addRoutes.ts
 var addRoutes = /* @__PURE__ */ __name((app) => {
-  addRpcRoutes(app);
-  addDataLakeRoutes(app);
-  addNodeRoutes(app);
+  addBridgeRoutes(app);
 }, "addRoutes");
 
 // src/server/app.ts
-var getApp = /* @__PURE__ */ __name((node) => {
+var getApp = /* @__PURE__ */ __name(() => {
   addInstrumentation();
-  const app = express2();
+  const app = express();
   app.set("etag", false);
   app.use(cors());
   app.use(compression());
@@ -303,443 +342,21 @@ var getApp = /* @__PURE__ */ __name((node) => {
   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 { assertEx } from "@xylabs/assert";
+import { isString } from "@xylabs/typeof";
 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 { logger } = context;
+  const { port } = context.config.bridge;
+  await Promise.resolve();
+  const app = getApp();
   const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`));
   server.setTimeout(2e4);
   return server;