@xyo-network/chain-bridge 1.17.2 → 1.17.3

package/dist/node/index.mjs

@@ -21,243 +21,573 @@ var addInstrumentation = /* @__PURE__ */ __name(() => {
   });
 }, "addInstrumentation");
 
-// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
+// src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts
 import { requestHandlerValidator } from "@xylabs/express";
-import { toAddress as toAddress2, toHex } from "@xylabs/sdk-js";
+import { BridgeSettingsZod } from "@xyo-network/xl1-protocol-sdk";
+
+// src/config/asChainId.ts
+import { asHex } from "@xylabs/sdk-js";
+var asChainId = /* @__PURE__ */ __name((value) => {
+  const chainId = asHex(value);
+  return chainId;
+}, "asChainId");
+
+// src/config/asToken.ts
+import { asAddress } from "@xylabs/sdk-js";
+var asToken = /* @__PURE__ */ __name((value) => {
+  const token = asAddress(value);
+  return token;
+}, "asToken");
+
+// src/config/getBridgeEscrowAddress.ts
+import { asAddress as asAddress2, assertEx } from "@xylabs/sdk-js";
+var tryGetBridgeEscrowAddress = /* @__PURE__ */ __name((config) => {
+  const address = asAddress2(config.bridge.escrowAddress);
+  return address;
+}, "tryGetBridgeEscrowAddress");
+
+// src/config/getBridgeFeesAddress.ts
+import { asAddress as asAddress3, assertEx as assertEx2 } from "@xylabs/sdk-js";
+var tryGetBridgeFeesAddress = /* @__PURE__ */ __name((config) => {
+  const address = asAddress3(config.bridge.feesAddress);
+  return address;
+}, "tryGetBridgeFeesAddress");
+
+// src/config/getFeeStructure.ts
+var getFeeStructure = /* @__PURE__ */ __name((config) => {
+  const { feeFixed, feeRateBasisPoints } = config.bridge;
+  return {
+    feeFixed,
+    feeRateBasisPoints
+  };
+}, "getFeeStructure");
+
+// src/config/getMaxBridgeAmount.ts
+var getMaxBridgeAmount = /* @__PURE__ */ __name((config) => {
+  const { maxBridgeAmount } = config.bridge;
+  return maxBridgeAmount;
+}, "getMaxBridgeAmount");
+
+// src/config/getMinBridgeAmount.ts
+var getMinBridgeAmount = /* @__PURE__ */ __name((config) => {
+  const { minBridgeAmount } = config.bridge;
+  return minBridgeAmount;
+}, "getMinBridgeAmount");
+
+// src/config/getRemoteChainId.ts
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+var getRemoteChainId = /* @__PURE__ */ __name((config) => {
+  const remoteChainId = assertEx3(asChainId(config.bridge.remoteChainId), () => "Invalid remote chain ID in config");
+  return remoteChainId;
+}, "getRemoteChainId");
+
+// src/config/getRemoteTokenAddress.ts
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+var getRemoteTokenAddress = /* @__PURE__ */ __name((config) => {
+  const token = asToken(config.bridge.remoteTokenAddress);
+  return assertEx4(token, () => "Remote token address is not defined in bridge configuration");
+}, "getRemoteTokenAddress");
+
+// src/config/getBridgeWalletAccount.ts
+import { isDefined, isUndefined } from "@xylabs/sdk-js";
+import { HDWallet } from "@xyo-network/wallet";
+import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-protocol-sdk";
+var accountServiceSingleton;
+var getBridgeWalletAccount = /* @__PURE__ */ __name(async (config) => {
+  if (accountServiceSingleton) return accountServiceSingleton;
+  let walletPhrase = config.bridge.mnemonic;
+  if (isUndefined(walletPhrase)) {
+    console.log("[Bridge] No wallet mnemonic specified!");
+    const randomMnemonic = HDWallet.generateMnemonic();
+    console.log(`[Bridge] Using randomly generated mnemonic:
+    
+${randomMnemonic}
+      
+    `);
+    walletPhrase = randomMnemonic;
+  }
+  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
+  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
+  accountServiceSingleton = account;
+  return accountServiceSingleton;
+}, "getBridgeWalletAccount");
+
+// src/config/getTransferAddresses.ts
+var getTransferAddresses = /* @__PURE__ */ __name(async (config) => {
+  const escrowAddress = tryGetBridgeEscrowAddress(config) ?? (await getBridgeWalletAccount(config)).address;
+  const feesAddress = tryGetBridgeFeesAddress(config) ?? (await getBridgeWalletAccount(config)).address;
+  return {
+    escrowAddress,
+    feesAddress
+  };
+}, "getTransferAddresses");
+
+// src/config/getXl1ChainId.ts
+import { assertEx as assertEx5, isDefined as isDefined2 } from "@xylabs/sdk-js";
+var getXl1ChainId = /* @__PURE__ */ __name((config) => {
+  const xl1ChainId = config.bridge.xl1ChainId;
+  if (isDefined2(xl1ChainId)) {
+    return assertEx5(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
+  }
+  return assertEx5(asChainId(config.chain.id), () => "Invalid chain.id in config");
+}, "getXl1ChainId");
+
+// src/config/getXl1TokenAddress.ts
+import { isDefined as isDefined3 } from "@xylabs/sdk-js";
+var getXl1TokenAddress = /* @__PURE__ */ __name((config) => {
+  const token = asToken(config.bridge.xl1TokenAddress);
+  if (isDefined3(token)) return token;
+  return getXl1ChainId(config);
+}, "getXl1TokenAddress");
+
+// src/config/getBridgeSettings.ts
+var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
+  const { feeFixed, feeRateBasisPoints } = getFeeStructure(config);
+  const { feesAddress, escrowAddress } = await getTransferAddresses(config);
+  const maxBridgeAmount = getMaxBridgeAmount(config);
+  const minBridgeAmount = getMinBridgeAmount(config);
+  const remoteChainId = getRemoteChainId(config);
+  const remoteTokenAddress = getRemoteTokenAddress(config);
+  const xl1TokenAddress = getXl1TokenAddress(config);
+  const xl1ChainId = getXl1ChainId(config);
+  return {
+    feeFixed,
+    feeRateBasisPoints,
+    feesAddress,
+    escrowAddress,
+    maxBridgeAmount,
+    minBridgeAmount,
+    remoteChainId,
+    remoteTokenAddress,
+    xl1TokenAddress,
+    xl1ChainId
+  };
+}, "getBridgeSettings");
+
+// src/config/getGateway.ts
+import { isDefined as isDefined4 } from "@xylabs/sdk-js";
+import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
+import { SimpleXyoGatewayRunner, SimpleXyoSigner } from "@xyo-network/xl1-protocol-sdk";
+import { HttpRpcXyoConnection } from "@xyo-network/xl1-rpc";
+var gatewayInstance;
+var getGateway = /* @__PURE__ */ __name(async (config) => {
+  if (isDefined4(gatewayInstance)) return gatewayInstance;
+  const { mnemonic, chainRpcApiUrl: endpoint } = config.bridge;
+  const walletPromise = isDefined4(mnemonic) ? HDWallet2.fromPhrase(mnemonic) : HDWallet2.random();
+  const account = await walletPromise;
+  const signer = new SimpleXyoSigner(account);
+  const connection = new HttpRpcXyoConnection({
+    endpoint
+  });
+  gatewayInstance = new SimpleXyoGatewayRunner(connection, signer);
+  return gatewayInstance;
+}, "getGateway");
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts
+var response = BridgeSettingsZod;
+var validateRequest = requestHandlerValidator({
+  response
+});
+var makeBridgeConfigRoute = /* @__PURE__ */ __name((config) => {
+  return {
+    method: "get",
+    path: "/bridge/chains/:chainId/config",
+    handlers: validateRequest(async (_, res) => {
+      const { escrowAddress, feeFixed, feeRateBasisPoints, feesAddress, maxBridgeAmount, minBridgeAmount, remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
+      const sanitizedConfig = {
+        escrowAddress,
+        feeFixed,
+        feeRateBasisPoints,
+        feesAddress,
+        maxBridgeAmount,
+        minBridgeAmount,
+        remoteChainId,
+        remoteTokenAddress,
+        xl1ChainId,
+        xl1TokenAddress
+      };
+      res.json(sanitizedConfig);
+    })
+  };
+}, "makeBridgeConfigRoute");
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
+import { requestHandlerValidator as requestHandlerValidator2 } from "@xylabs/express";
+import { toAddress, toHex } from "@xylabs/sdk-js";
 import { PayloadZodStrictOfSchema } from "@xyo-network/payload-model";
 import { BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema } from "@xyo-network/xl1-protocol";
 import { z } from "zod";
 
 // src/server/routes/bridge/routeDefinitions/pathParams/ChainIdPathParam.ts
-import { hexFromHexString, HexZod, isAddress, isUndefined, toAddress } from "@xylabs/sdk-js";
-var remoteChainId = toAddress("0x01");
-var ChainIdPathParam = HexZod.refine((val) => {
-  const chainIdHex = hexFromHexString(val, {
-    prefix: true
+import { asHex as asHex2, HexZod, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+var getRemoteChainIdZod = /* @__PURE__ */ __name((config) => {
+  const remoteChainId = getRemoteChainId(config);
+  return HexZod.superRefine((val, ctx) => {
+    const chainId = asHex2(val);
+    if (isUndefined2(chainId)) {
+      ctx.addIssue("Not a valid chain id");
+      return;
+    }
+    if (chainId !== remoteChainId) {
+      ctx.addIssue(`Only ${remoteChainId} is supported`);
+    }
   });
-  if (isAddress(chainIdHex)) return false;
-  const suppliedChainId = toAddress(chainIdHex);
-  if (isUndefined(suppliedChainId)) return false;
-  return suppliedChainId === remoteChainId;
-}, {
-  message: `Only ${remoteChainId} is supported`
-});
+}, "getRemoteChainIdZod");
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
-var params = z.object({
-  chainId: ChainIdPathParam,
-  nonce: z.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")
-    };
-    res.json(observation);
-  })
-};
+var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
+  const params = z.object({
+    chainId: getRemoteChainIdZod(config),
+    nonce: z.string().nonempty()
+  });
+  const response2 = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape);
+  const validateRequest2 = requestHandlerValidator2({
+    params,
+    response: response2
+  });
+  return {
+    method: "get",
+    path: "/bridge/chains/:chainId/bridgeFromRemote/status/:nonce",
+    handlers: validateRequest2(async (req, res) => {
+      const { remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
+      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: xl1ChainId,
+        destAddress: toAddress("0xabc"),
+        destAmount: toHex("0x100"),
+        destToken: xl1TokenAddress,
+        src: remoteChainId,
+        srcAddress: toAddress("0x123"),
+        srcAmount: toHex("0x200"),
+        srcToken: remoteTokenAddress,
+        destConfirmation: toHex("0x9999")
+      };
+      res.json(observation);
+    })
+  };
+}, "makeBridgeFromRemoteStatusRoute");
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
-import { requestHandlerValidator as requestHandlerValidator2 } from "@xylabs/express";
-import { asHash } from "@xylabs/sdk-js";
-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 { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/payload-model";
+import { asSentinelInstance } from "@xyo-network/sentinel-model";
+import { BridgeIntentFieldsZod, BridgeIntentSchema as BridgeIntentSchema2, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, SignedTransactionBoundWitnessZod, TransferZod } from "@xyo-network/xl1-protocol";
+import { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
 import { z as z2 } from "zod";
-var params2 = z2.object({
-  chainId: ChainIdPathParam
-});
-var body = z2.tuple([
-  // TODO: TransactionBoundWitness
-  PayloadZodStrictOfSchema2(BridgeIntentSchema).extend(BridgeIntentFieldsZod.shape),
-  PayloadZodLooseOfSchema(TransferSchema)
-]);
-var response2 = PayloadZodStrictOfSchema2(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape);
-var validateRequest2 = requestHandlerValidator2({
-  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] = body3;
-    const srcConfirmation = await Promise.resolve(asHash("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"));
-    const bridgeCommonFieldsZod = z2.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/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
-import { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
-import { hexToBigInt, toAddress as toAddress3, toHex as toHex2 } from "@xylabs/sdk-js";
+// src/util/calculateBridgeFees.ts
+import { hexToBigInt, toHex as toHex2 } from "@xylabs/sdk-js";
+var calculateBridgeFees = /* @__PURE__ */ __name((srcAmount, feeStructure) => {
+  const { feeFixed, feeRateBasisPoints } = feeStructure;
+  const srcAmountBigInt = hexToBigInt(srcAmount);
+  const feeFixedBigInt = hexToBigInt(feeFixed);
+  const feeVariableBigInt = srcAmountBigInt * BigInt(feeRateBasisPoints) / 10000n;
+  const feeVariable = toHex2(feeVariableBigInt);
+  const feeTotalBigInt = feeFixedBigInt + feeVariableBigInt;
+  const destAmountBigInt = srcAmountBigInt > feeTotalBigInt ? srcAmountBigInt - feeTotalBigInt : 0n;
+  const destAmount = toHex2(destAmountBigInt);
+  return {
+    destAmount,
+    feeFixed,
+    feeVariable
+  };
+}, "calculateBridgeFees");
+
+// src/util/generateBridgeEstimate.ts
+import { hexToBigInt as hexToBigInt2, toAddress as toAddress2 } from "@xylabs/sdk-js";
 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 { PayloadBuilder } from "@xyo-network/payload-builder";
+import { BridgeIntentSchema } from "@xyo-network/xl1-protocol";
 import { v4 } from "uuid";
+var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount, destAddress, config, nonceOverride) => {
+  const { escrowAddress, feeFixed, feeRateBasisPoints, feesAddress, remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
+  const sender = toAddress2(srcAddress);
+  const fees = calculateBridgeFees(srcAmount, {
+    feeFixed,
+    feeRateBasisPoints
+  });
+  const { destAmount, feeFixed: feeFixedAmount, feeVariable } = fees;
+  const nonce = nonceOverride ?? v4();
+  const bridgeIntentFields = {
+    // Source
+    src: xl1ChainId,
+    srcAddress: sender,
+    srcAmount,
+    srcToken: xl1TokenAddress,
+    // Destination
+    dest: remoteChainId,
+    destAddress,
+    destAmount,
+    destToken: remoteTokenAddress,
+    nonce
+  };
+  const bridgeIntent = new PayloadBuilder({
+    schema: BridgeIntentSchema
+  }).fields(bridgeIntentFields).build();
+  const context = {
+    destAmount,
+    feeFixed: feeFixedAmount,
+    feeVariable
+  };
+  const transfer = createTransferPayload(sender, {
+    [escrowAddress]: hexToBigInt2(destAmount),
+    [feesAddress]: hexToBigInt2(feeFixedAmount) + hexToBigInt2(feeVariable)
+  }, context);
+  return [
+    bridgeIntent,
+    transfer
+  ];
+}, "generateBridgeEstimate");
+
+// src/util/validateBridgeEstimateExact.ts
+import { isUndefined as isUndefined3 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+var validateBridgeEstimateExact = /* @__PURE__ */ __name(async (intent, transfer, config) => {
+  const { srcAddress, srcAmount, destAddress } = intent;
+  const [calculatedIntent, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
+  if (isUndefined3(calculatedIntent) || isUndefined3(calculatedTransfer)) return false;
+  const { nonce: expectedIntentNonce, ...expectedIntentStatic } = calculatedIntent;
+  const { nonce: actualIntentNonce, ...actualIntentStatic } = intent;
+  if (await PayloadBuilder2.dataHash(expectedIntentStatic) !== await PayloadBuilder2.dataHash(actualIntentStatic)) return false;
+  const { epoch: expectedTransferEpoch, ...expectedTransferStatic } = calculatedTransfer;
+  const { epoch: actualTransferEpoch, ...actualTransferStatic } = transfer;
+  if (await PayloadBuilder2.dataHash(expectedTransferStatic) !== await PayloadBuilder2.dataHash(actualTransferStatic)) return false;
+  return true;
+}, "validateBridgeEstimateExact");
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
+var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
+  const params = z2.object({
+    chainId: getRemoteChainIdZod(config)
+  });
+  const body = z2.tuple([
+    SignedTransactionBoundWitnessZod,
+    PayloadZodStrictOfSchema2(BridgeIntentSchema2).extend(BridgeIntentFieldsZod.shape),
+    TransferZod
+  ]);
+  const response2 = PayloadZodStrictOfSchema2(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape);
+  const validateRequest2 = requestHandlerValidator3({
+    params,
+    body,
+    response: response2
+  });
+  return {
+    method: "post",
+    path: "/bridge/chains/:chainId/bridgeToRemote",
+    handlers: validateRequest2(async (req, res) => {
+      const [signedTxBw, bridgeIntent, transfer] = req.body;
+      const { srcAddress } = bridgeIntent;
+      const { node } = req.app;
+      const estimateValid = await validateBridgeEstimateExact(bridgeIntent, transfer, config);
+      if (!estimateValid) {
+        res.status(400).send();
+        return;
+      }
+      const mod = await node.resolve("XL1BridgeIntentTransactionCompletionMonitorSentinel");
+      const sentinel = assertEx6(asSentinelInstance(mod), () => "Error resolving XL1BridgeIntentTransactionCompletionMonitorSentinel");
+      const singedHydratedTransaction = [
+        signedTxBw,
+        [
+          transfer,
+          bridgeIntent
+        ]
+      ];
+      const observation = await sentinel.report(flattenHydratedTransaction(singedHydratedTransaction));
+      if (observation.length === 0) {
+        console.error("Error submitting bridge intent transaction to sentinel");
+        res.status(500).send();
+        return;
+      }
+      const srcConfirmation = await PayloadBuilder3.hash(signedTxBw);
+      const bridgeCommonFieldsZod = z2.object({}).extend(BridgeSourceObservationFieldsZod.shape);
+      const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent);
+      const bridgeObservationFields = {
+        ...bridgeCommonFields,
+        srcConfirmation
+      };
+      const bridgeObservation = new PayloadBuilder3({
+        schema: BridgeSourceObservationSchema
+      }).fields(bridgeObservationFields).build();
+      res.json(bridgeObservation);
+    })
+  };
+}, "makeBridgeToRemoteRoute");
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
+import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
+import { assertEx as assertEx7, toAddress as toAddress3 } from "@xylabs/sdk-js";
+import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3 } from "@xyo-network/payload-model";
+import { BridgeIntentFieldsZod as BridgeIntentFieldsZod2, BridgeIntentSchema as BridgeIntentSchema3, toXL1BlockNumber, TransactionBoundWitnessZod, TransferSchema } from "@xyo-network/xl1-protocol";
+import { buildUnsignedTransaction } from "@xyo-network/xl1-protocol-sdk";
 import { z as z3 } from "zod";
-var TOKEN_ADDRESS = "0x5FbDB2315678afecb367f032d93F642f64180aa3";
-var bridgeableTokenContract = toHex2(TOKEN_ADDRESS);
-var xl1ChainId = toAddress3("0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9");
-var fixedFee = 1000000000000000n;
-var percentFee = 5n;
-var bridgeEscrowAddress = toAddress3("0x0a");
-var bridgeFeesAddress = toAddress3("0x0b");
-var remoteChainId2 = toHex2("0x01");
-var params3 = z3.object({
-  chainId: ChainIdPathParam
-});
-var body2 = BridgeIntentFieldsZod2.pick({
-  destAddress: true,
-  srcAddress: true,
-  srcAmount: true
-});
-var response3 = z3.tuple([
-  PayloadZodStrictOfSchema3(BridgeIntentSchema2).extend(BridgeIntentFieldsZod2.shape),
-  PayloadZodLooseOfSchema2(TransferSchema2)
-]);
-var validateRequest3 = requestHandlerValidator3({
-  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 = toAddress3(srcAddress);
-    const bridgeIntentFields = {
-      // Source
-      src: xl1ChainId,
-      srcAddress,
-      srcAmount,
-      srcToken: xl1ChainId,
-      // Destination
-      dest: remoteChainId2,
-      destAddress,
-      destAmount,
-      destToken: bridgeableTokenContract,
-      nonce
-    };
-    const bridgeIntent = new PayloadBuilder2({
-      schema: BridgeIntentSchema2
-    }).fields(bridgeIntentFields).build();
-    const transfer = createTransferPayload(sender, {
-      [bridgeEscrowAddress]: destAmountBigInt,
-      [bridgeFeesAddress]: feeAmount
-    });
-    res.json([
-      bridgeIntent,
-      transfer
-    ]);
-  })
-};
+var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config) => {
+  const params = z3.object({
+    chainId: getRemoteChainIdZod(config)
+  });
+  const body = BridgeIntentFieldsZod2.pick({
+    destAddress: true,
+    srcAddress: true,
+    srcAmount: true
+  });
+  const response2 = z3.tuple([
+    TransactionBoundWitnessZod,
+    PayloadZodStrictOfSchema3(BridgeIntentSchema3).extend(BridgeIntentFieldsZod2.shape),
+    PayloadZodLooseOfSchema(TransferSchema)
+  ]);
+  const validateRequest2 = requestHandlerValidator4({
+    params,
+    body,
+    response: response2
+  });
+  return {
+    method: "post",
+    path: "/bridge/chains/:chainId/bridgeToRemote/estimate",
+    handlers: validateRequest2(async (req, res) => {
+      const xl1ChainId = getXl1ChainId(config);
+      const { srcAddress, srcAmount, destAddress } = req.body;
+      const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
+      const sender = toAddress3(srcAddress);
+      const gateway = await getGateway(config);
+      const viewer = assertEx7(gateway.connectionInstance.viewer, () => new Error("Viewer not available on gateway connection"));
+      const currentBlockNumber = await viewer.currentBlockNumber();
+      const nbf = toXL1BlockNumber(currentBlockNumber, true);
+      const exp = toXL1BlockNumber(currentBlockNumber + 1e3, true);
+      const [txBw] = await buildUnsignedTransaction(xl1ChainId, [
+        transfer
+      ], [
+        bridgeIntent
+      ], nbf, exp, sender);
+      res.json([
+        txBw,
+        bridgeIntent,
+        transfer
+      ]);
+    })
+  };
+}, "makeBridgeToRemoteEstimateRoute");
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteStatus.ts
-import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
-import { toAddress as toAddress4, toHex as toHex3 } from "@xylabs/sdk-js";
+import { requestHandlerValidator as requestHandlerValidator5 } from "@xylabs/express";
+import { asAddress as asAddress4, asHex as asHex3, toHex as toHex3 } from "@xylabs/sdk-js";
 import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema4 } from "@xyo-network/payload-model";
-import { BridgeDestinationObservationFieldsZod as BridgeDestinationObservationFieldsZod2, BridgeDestinationObservationSchema as BridgeDestinationObservationSchema2 } from "@xyo-network/xl1-protocol";
+import { BridgeDestinationObservationFieldsZod as BridgeDestinationObservationFieldsZod2, BridgeDestinationObservationSchema as BridgeDestinationObservationSchema2, BridgeIntentFieldsZod as BridgeIntentFieldsZod3, BridgeIntentSchema as BridgeIntentSchema4, BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod2, BridgeSourceObservationSchema as BridgeSourceObservationSchema2 } from "@xyo-network/xl1-protocol";
 import { z as z4 } from "zod";
-var params4 = z4.object({
-  chainId: ChainIdPathParam,
-  nonce: z4.string()
-});
-var response4 = PayloadZodStrictOfSchema4(BridgeDestinationObservationSchema2).extend(BridgeDestinationObservationFieldsZod2.shape);
-var validateRequest4 = requestHandlerValidator4({
-  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: toAddress4("0xabc"),
-      destAmount: toHex3("0x100"),
-      destToken: toAddress4("0xdef"),
-      src: toAddress4("0x02"),
-      srcAddress: toAddress4("0x123"),
-      srcAmount: toHex3("0x200"),
-      srcToken: toHex3("0x456"),
-      destConfirmation: toHex3("0x9999")
-    };
-    res.json(observation);
-  })
-};
+var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
+  const params = z4.object({
+    chainId: getRemoteChainIdZod(config),
+    nonce: z4.string().nonempty()
+  });
+  const query = z4.object({
+    mockStatus: z4.coerce.number().default(0)
+  });
+  const response2 = z4.union([
+    z4.tuple([]),
+    z4.tuple([
+      PayloadZodStrictOfSchema4(BridgeIntentSchema4).extend(BridgeIntentFieldsZod3.shape)
+    ]),
+    z4.tuple([
+      PayloadZodStrictOfSchema4(BridgeIntentSchema4).extend(BridgeIntentFieldsZod3.shape),
+      PayloadZodStrictOfSchema4(BridgeSourceObservationSchema2).extend(BridgeSourceObservationFieldsZod2.shape)
+    ]),
+    z4.tuple([
+      PayloadZodStrictOfSchema4(BridgeIntentSchema4).extend(BridgeIntentFieldsZod3.shape),
+      PayloadZodStrictOfSchema4(BridgeSourceObservationSchema2).extend(BridgeSourceObservationFieldsZod2.shape),
+      PayloadZodStrictOfSchema4(BridgeDestinationObservationSchema2).extend(BridgeDestinationObservationFieldsZod2.shape)
+    ])
+  ]);
+  const validateRequest2 = requestHandlerValidator5({
+    params,
+    query,
+    response: response2
+  });
+  return {
+    method: "get",
+    path: "/bridge/chains/:chainId/bridgeToRemote/status/:nonce",
+    handlers: validateRequest2(async (req, res) => {
+      const { chainId } = req.params;
+      const { mockStatus = 0 } = req.query;
+      const result = [];
+      const { remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
+      const src = xl1ChainId;
+      const srcAddress = asAddress4("2222222222222222222222222222222222222222", true);
+      const srcAmount = asHex3("0x200", true);
+      const srcToken = xl1TokenAddress;
+      const dest = chainId;
+      const destAddress = asAddress4("3333333333333333333333333333333333333333", true);
+      const destAmount = asHex3("0x100", true);
+      const destToken = remoteTokenAddress;
+      if (mockStatus === 0) return res.sendStatus(404);
+      if (mockStatus > 0) {
+        const [observation] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config, req.params.nonce);
+        result[0] = observation;
+      }
+      if (mockStatus > 1) {
+        const observation = {
+          schema: BridgeSourceObservationSchema2,
+          dest,
+          destAddress,
+          destAmount,
+          destToken,
+          src,
+          srcAddress,
+          srcAmount,
+          srcToken
+        };
+        result[1] = observation;
+      }
+      if (mockStatus > 2) {
+        const observation = {
+          schema: BridgeDestinationObservationSchema2,
+          dest,
+          destAddress,
+          destAmount,
+          destToken,
+          src,
+          srcAddress,
+          srcAmount,
+          srcToken,
+          destConfirmation: toHex3("0x9999")
+        };
+        result[2] = observation;
+      }
+      res.json(result);
+    })
+  };
+}, "makeBridgeToRemoteStatusRoute");
 
 // src/server/routes/bridge/routeDefinitions/getRouteDefinitions.ts
-var getRouteDefinitions = /* @__PURE__ */ __name(() => {
+var getRouteDefinitions = /* @__PURE__ */ __name((config) => {
   return [
-    bridgeFromRemoteStatus,
-    bridgeToRemote,
-    bridgeToRemoteEstimate,
-    bridgeToRemoteStatus
+    makeBridgeConfigRoute(config),
+    makeBridgeToRemoteEstimateRoute(config),
+    makeBridgeToRemoteRoute(config),
+    makeBridgeToRemoteStatusRoute(config),
+    makeBridgeFromRemoteStatusRoute(config)
   ];
 }, "getRouteDefinitions");
 
 // src/server/routes/bridge/addBridgeRoutes.ts
-var addBridgeRoutes = /* @__PURE__ */ __name((app) => {
-  const routeDefinitions = getRouteDefinitions();
+var addBridgeRoutes = /* @__PURE__ */ __name((app, config) => {
+  const routeDefinitions = getRouteDefinitions(config);
   for (const definition of routeDefinitions) {
     app[definition.method](definition.path, definition.handlers);
   }
 }, "addBridgeRoutes");
 
 // src/server/routes/addRoutes.ts
-var addRoutes = /* @__PURE__ */ __name((app) => {
-  addBridgeRoutes(app);
+var addRoutes = /* @__PURE__ */ __name((app, config) => {
+  addBridgeRoutes(app, config);
 }, "addRoutes");
 
 // src/server/app.ts
-var getApp = /* @__PURE__ */ __name(() => {
+var getApp = /* @__PURE__ */ __name((node, config) => {
   addInstrumentation();
   const app = express();
   app.set("etag", false);
@@ -271,18 +601,615 @@ var getApp = /* @__PURE__ */ __name(() => {
   disableExpressDefaultPoweredByHeader(app);
   app.use(customPoweredByHeader);
   disableCaseSensitiveRouting(app);
-  addRoutes(app);
+  app.node = node;
+  addRoutes(app, config);
   app.use(standardErrors);
   return app;
 }, "getApp");
 
+// src/server/server.ts
+import { assertEx as assertEx11, isDefined as isDefined8, isString } from "@xylabs/sdk-js";
+import { boot } from "@xyo-network/bios";
+import { HDWallet as HDWallet4 } from "@xyo-network/wallet";
+
+// src/manifest/getLocator.ts
+import { BaseMongoSdk } from "@xylabs/mongo";
+import { assertEx as assertEx10, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { MemoryArchivist } from "@xyo-network/archivist-memory";
+import { MongoDBArchivistV2 } from "@xyo-network/archivist-mongodb";
+import { ViewArchivist } from "@xyo-network/archivist-view";
+import { mapToMapType, MongoMap } from "@xyo-network/chain-protocol";
+import { initEvmProvider } from "@xyo-network/chain-services";
+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 { HDWallet as HDWallet3 } from "@xyo-network/wallet";
+import { hasMongoConfig, SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2, SimpleXyoSigner as SimpleXyoSigner2 } from "@xyo-network/xl1-protocol-sdk";
+import { HttpRpcXyoConnection as HttpRpcXyoConnection2 } from "@xyo-network/xl1-rpc";
+
+// src/modules/EVMLiquidityBridgeTransactionCompletionMonitorSentinel/EVMLiquidityBridgeTransactionCompletionMonitorSentinel.ts
+import { asAddress as asAddress5, asHex as asHex4, assertEx as assertEx8, delay, hexFromBigInt, hexToBigInt as hexToBigInt3, isDefined as isDefined5, isUndefined as isUndefined4 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { AbstractSentinel } from "@xyo-network/sentinel-abstract";
+import { LiquidityPoolBridge__factory } from "@xyo-network/typechain";
+import { BridgeDestinationObservationSchema as BridgeDestinationObservationSchema3, isBridgeIntent } from "@xyo-network/xl1-protocol";
+import { flattenHydratedTransaction as flattenHydratedTransaction2, flattenHydratedTransactions, tryUnflattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex } from "async-mutex";
+import { getAddress } from "ethers/address";
+import { Wallet } from "ethers/wallet";
+var EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema = "network.xyo.sentinel.chain.evm.liquidity.bridge.transaction.completion.monitor.config";
+var defaultJobCheckIntervalMs = 15e3;
+var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends AbstractSentinel {
+  static {
+    __name(this, "EVMLiquidityBridgeTransactionCompletionMonitorSentinel");
+  }
+  static configSchemas = [
+    EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema
+  ];
+  static defaultConfigSchema = EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema;
+  _attemptsCounter;
+  _bridge;
+  _bridgeChainId;
+  _bridgeRemoteChainId;
+  _bridgeTokenAddress;
+  _checkCounter;
+  _errorCounter;
+  _reportMutex = new Mutex();
+  _successCounter;
+  _wallet;
+  get bridge() {
+    return assertEx8(this._bridge, () => new Error("Bridge contract not initialized"));
+  }
+  get completedTransactions() {
+    return assertEx8(this.params.completedTransactions, () => "Completed transactions map is not defined");
+  }
+  get jobCheckInterval() {
+    return isDefined5(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs;
+  }
+  get pendingTransactions() {
+    return assertEx8(this.params.pendingTransactions, () => "Pending transactions map is not defined");
+  }
+  get wallet() {
+    return assertEx8(this._wallet, () => "wallet is required");
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._attemptsCounter = this.meter?.createCounter("evm_liquidity_bridge_transaction_completion_monitor_sentinel_attempts_total", {
+      description: "Number of attempts"
+    });
+    this._checkCounter = this.meter?.createCounter("evm_liquidity_bridge_transaction_completion_monitor_sentinel_check_total", {
+      description: "Number of checks"
+    });
+    this._successCounter = this.meter?.createCounter("evm_liquidity_bridge_transaction_completion_monitor_sentinel_success_total", {
+      description: "Number of successes"
+    });
+    this._errorCounter = this.meter?.createCounter("evm_liquidity_bridge_transaction_completion_monitor_sentinel_errors_total", {
+      description: "Number of errors"
+    });
+    const { provider, bridgeAddress } = this.params;
+    const key = assertEx8(this.account?.private?.hex, () => new Error("Account private key is required"));
+    this._wallet = new Wallet(key, provider);
+    this._bridge = LiquidityPoolBridge__factory.connect(getAddress(bridgeAddress), this._wallet);
+    const network = await provider.getNetwork();
+    this._bridgeChainId = assertEx8(hexFromBigInt(network.chainId), () => new Error("Failed to parse bridgeChainId"));
+    const tokenAddress = await this.bridge.token();
+    this._bridgeTokenAddress = asAddress5(tokenAddress, true);
+    const bridgeRemoteChain = await this.bridge.remoteChain();
+    this._bridgeRemoteChainId = asHex4(bridgeRemoteChain);
+  }
+  async reportHandler(payloads) {
+    if (isDefined5(payloads) && payloads.length > 0) {
+      const signedHydratedTransaction = tryUnflattenHydratedTransaction(payloads);
+      if (isDefined5(signedHydratedTransaction)) {
+        const txHash = await PayloadBuilder4.hash(signedHydratedTransaction[0]);
+        this.logger?.info(`Adding transaction ${signedHydratedTransaction[0]} with hash ${txHash} to pending transactions for monitoring`);
+        await this.pendingTransactions.set(txHash, signedHydratedTransaction);
+        return flattenHydratedTransaction2(signedHydratedTransaction);
+      }
+      return [];
+    } else {
+      if (this._reportMutex.isLocked()) {
+        this.logger?.debug(`EVMLiquidityBridgeTransactionCompletionMonitorSentinel [${this.id}] is already running, skipping report [${Date.now()}]`);
+        return [];
+      }
+      return await this._reportMutex.runExclusive(async () => {
+        const response2 = [];
+        if (isUndefined4(payloads) || payloads.length === 0) {
+          await this.processAllTransactions();
+        }
+        return response2;
+      });
+    }
+  }
+  async processAllTransactions() {
+    const results = [];
+    for await (const [hash, signedHydratedTransaction] of this.pendingTransactions) {
+      const result = await this.processTransaction([
+        hash,
+        signedHydratedTransaction
+      ]);
+      if (isDefined5(result)) results.push(result[1]);
+      await delay(this.jobCheckInterval);
+    }
+    return flattenHydratedTransactions(results);
+  }
+  async processTransaction([hash, signedHydratedTransaction]) {
+    this.logger?.info(`Checking for transaction ${signedHydratedTransaction[0]} with hash ${hash}`);
+    try {
+      let ret = void 0;
+      this._checkCounter?.add(1);
+      const bridgeIntents = signedHydratedTransaction[1].filter(isBridgeIntent);
+      if (bridgeIntents.length !== 1) {
+        await this.pendingTransactions.delete(hash);
+        return ret;
+      }
+      const bridgeIntent = bridgeIntents[0];
+      this._attemptsCounter?.add(1);
+      const bridgeDestinationObservation = await this.relayBridgeIntentSync(bridgeIntent);
+      await this.completedTransactions.set(hash, bridgeDestinationObservation);
+      await this.pendingTransactions.delete(hash);
+      this._successCounter?.add(1);
+      return ret;
+    } catch (error) {
+      this._errorCounter?.add(1);
+      this.logger?.error(`Error checking for transaction ${signedHydratedTransaction[0]} with hash ${hash}:`, error);
+    }
+  }
+  /**
+  * Relays a given BridgeIntent.
+  * @param bridgeIntent The BridgeIntent to relay
+  * @returns Relays the intent in a blocking manner, returning the resulting BridgeDestinationObservation if successful
+  */
+  async relayBridgeIntentSync(bridgeIntent) {
+    const amount = hexToBigInt3(bridgeIntent.destAmount);
+    const nonce = await this.wallet.getNonce();
+    const srcAddress = getAddress(bridgeIntent.srcAddress);
+    const destAddress = getAddress(bridgeIntent.destAddress);
+    const tx = await this.bridge.bridgeFromRemote(srcAddress, destAddress, amount, {
+      nonce
+    });
+    const confirmation = await tx.wait();
+    const transactionResponse = await confirmation?.getTransaction();
+    const destConfirmation = asHex4(transactionResponse?.hash ?? "", true);
+    const { schema, ...rest } = bridgeIntent;
+    const result = new PayloadBuilder4({
+      schema: BridgeDestinationObservationSchema3
+    }).fields({
+      ...rest,
+      destConfirmation
+    }).build();
+    return result;
+  }
+};
+
+// src/modules/XL1TransactionCompletionMonitorSentinel/XL1TransactionCompletionMonitorSentinel.ts
+import { assertEx as assertEx9, delay as delay2, isDefined as isDefined6, isNull, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { AbstractSentinel as AbstractSentinel2 } from "@xyo-network/sentinel-abstract";
+import { flattenHydratedTransaction as flattenHydratedTransaction3, flattenHydratedTransactions as flattenHydratedTransactions2, tryUnflattenHydratedTransaction as tryUnflattenHydratedTransaction2 } from "@xyo-network/xl1-protocol-sdk";
+import { Mutex as Mutex2 } from "async-mutex";
+var XL1TransactionCompletionMonitorSentinelConfigSchema = "network.xyo.sentinel.chain.transaction.completion.monitor.config";
+var defaultJobCheckIntervalMs2 = 15e3;
+var XL1TransactionCompletionMonitorSentinel = class extends AbstractSentinel2 {
+  static {
+    __name(this, "XL1TransactionCompletionMonitorSentinel");
+  }
+  static configSchemas = [
+    XL1TransactionCompletionMonitorSentinelConfigSchema
+  ];
+  static defaultConfigSchema = XL1TransactionCompletionMonitorSentinelConfigSchema;
+  _attemptsCounter;
+  _checkCounter;
+  _errorCounter;
+  _reportMutex = new Mutex2();
+  _successCounter;
+  get completedTransactions() {
+    return assertEx9(this.params.completedTransactions, () => "Completed transactions map is not defined");
+  }
+  get jobCheckInterval() {
+    return isDefined6(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs2;
+  }
+  get pendingTransactions() {
+    return assertEx9(this.params.pendingTransactions, () => "Pending transactions map is not defined");
+  }
+  get viewer() {
+    return assertEx9(this.params.viewer, () => "Viewer is not defined in params");
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._attemptsCounter = this.meter?.createCounter("xl1_transaction_completion_monitor_sentinel_attempts_total", {
+      description: "Number of attempts"
+    });
+    this._checkCounter = this.meter?.createCounter("xl1_transaction_completion_monitor_sentinel_check_total", {
+      description: "Number of checks"
+    });
+    this._successCounter = this.meter?.createCounter("xl1_transaction_completion_monitor_sentinel_success_total", {
+      description: "Number of successes"
+    });
+    this._errorCounter = this.meter?.createCounter("xl1_transaction_completion_monitor_sentinel_errors_total", {
+      description: "Number of errors"
+    });
+  }
+  async reportHandler(payloads) {
+    if (isDefined6(payloads) && payloads.length > 0) {
+      const signedHydratedTransaction = tryUnflattenHydratedTransaction2(payloads);
+      if (isDefined6(signedHydratedTransaction)) {
+        const txHash = await PayloadBuilder5.hash(signedHydratedTransaction[0]);
+        this.logger?.info(`Adding transaction ${signedHydratedTransaction[0]} with hash ${txHash} to pending transactions for monitoring`);
+        await this.pendingTransactions.set(txHash, signedHydratedTransaction);
+        return flattenHydratedTransaction3(signedHydratedTransaction);
+      }
+      return [];
+    } else {
+      if (this._reportMutex.isLocked()) {
+        this.logger?.debug(`XL1TransactionCompletionMonitorSentinel [${this.id}] is already running, skipping report [${Date.now()}]`);
+        return [];
+      }
+      return await this._reportMutex.runExclusive(async () => {
+        const response2 = [];
+        if (isUndefined5(payloads) || payloads.length === 0) {
+          await this.processAllTransactions();
+        }
+        return response2;
+      });
+    }
+  }
+  async processAllTransactions() {
+    const results = [];
+    for await (const [hash, signedHydratedTransaction] of this.pendingTransactions) {
+      const result = await this.processTransaction([
+        hash,
+        signedHydratedTransaction
+      ]);
+      if (isDefined6(result)) results.push(result[1]);
+      await delay2(this.jobCheckInterval);
+    }
+    return flattenHydratedTransactions2(results);
+  }
+  async processTransaction([hash, signedHydratedTransaction]) {
+    this.logger?.info(`Checking for transaction ${signedHydratedTransaction[0]} with hash ${hash}`);
+    try {
+      let ret = void 0;
+      this._checkCounter?.add(1);
+      this._attemptsCounter?.add(1);
+      const tx = await this.viewer.transactionByHash(hash);
+      if (isDefined6(tx) && !isNull(tx)) {
+        await this.completedTransactions.set(hash, signedHydratedTransaction);
+        this.logger?.info(`Found transaction ${signedHydratedTransaction[0]} with hash ${hash}`);
+        this.logger?.info(`Removing completed transaction ${signedHydratedTransaction[0]} with hash ${hash}`);
+        await this.pendingTransactions.delete(hash);
+        ret = [
+          hash,
+          signedHydratedTransaction
+        ];
+      } else {
+        const currentBlockNumber = await this.viewer.currentBlockNumber();
+        if (signedHydratedTransaction[0].exp < currentBlockNumber) {
+          this.logger?.info(`Removing expired transaction ${signedHydratedTransaction[0]} with hash ${hash}`);
+          await this.pendingTransactions.delete(hash);
+        }
+      }
+      this._successCounter?.add(1);
+      return ret;
+    } catch (error) {
+      this._errorCounter?.add(1);
+      this.logger?.error(`Error checking for transaction ${signedHydratedTransaction[0]} with hash ${hash}:`, error);
+    }
+  }
+};
+
+// src/manifest/getLocator.ts
+var getLocator = /* @__PURE__ */ __name(async (context) => {
+  const { config, logger } = context;
+  const { otlpEndpoint } = config.telemetry?.otel ?? {};
+  const { path: endpoint = "/metrics", port = 9468 } = config.telemetry?.metrics?.scrape ?? {};
+  const { traceProvider, meterProvider } = await initTelemetry({
+    attributes: {
+      serviceName: "xl1-bridge",
+      serviceVersion: "1.0.0"
+    },
+    otlpEndpoint,
+    metricsConfig: {
+      endpoint,
+      port
+    }
+  });
+  if (isDefined7(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);
+  }
+  locator.register(MemoryArchivist.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  locator.register(MemorySentinel.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  locator.register(ViewArchivist.factory({
+    traceProvider,
+    meterProvider,
+    statusReporter
+  }));
+  const gateway = await getGateway2(config);
+  const viewer = assertEx10(gateway.connectionInstance.viewer, () => "Gateway viewer is not defined");
+  const pendingXl1ToEthXl1BridgeIntentTransactions = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_xl1_pending");
+  const completedXl1ToEthXl1BridgeIntentTransactions = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_xl1_completed");
+  const xl1TransactionCompletionMonitorSentinelParams = {
+    completedTransactions: completedXl1ToEthXl1BridgeIntentTransactions,
+    config: {
+      schema: XL1TransactionCompletionMonitorSentinelConfigSchema
+    },
+    meterProvider,
+    pendingTransactions: pendingXl1ToEthXl1BridgeIntentTransactions,
+    statusReporter,
+    traceProvider,
+    viewer
+  };
+  locator.register(XL1TransactionCompletionMonitorSentinel.factory(xl1TransactionCompletionMonitorSentinelParams));
+  const completedEthXl1BridgeTransactions = await getIterableMap(config, "liquidity_bridge_eth_xl1_bridge_completed");
+  const provider = await initEvmProvider({
+    config
+  });
+  const bridgeAddress = config.bridge.remoteBridgeContractAddress;
+  const evmLiquidityBridgeTransactionCompletionMonitorSentinelParams = {
+    bridgeAddress,
+    completedTransactions: completedEthXl1BridgeTransactions,
+    config: {
+      schema: EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema
+    },
+    meterProvider,
+    pendingTransactions: completedXl1ToEthXl1BridgeIntentTransactions,
+    provider,
+    statusReporter,
+    traceProvider
+  };
+  locator.register(EVMLiquidityBridgeTransactionCompletionMonitorSentinel.factory(evmLiquidityBridgeTransactionCompletionMonitorSentinelParams));
+  return locator;
+}, "getLocator");
+var getGateway2 = /* @__PURE__ */ __name(async (config) => {
+  const { mnemonic, chainRpcApiUrl: endpoint } = config.bridge;
+  const walletPromise = isDefined7(mnemonic) ? HDWallet3.fromPhrase(mnemonic) : HDWallet3.random();
+  const account = await walletPromise;
+  const signer = new SimpleXyoSigner2(account);
+  const connection = new HttpRpcXyoConnection2({
+    endpoint
+  });
+  const gateway = new SimpleXyoGatewayRunner2(connection, signer);
+  return gateway;
+}, "getGateway");
+var getIterableMap = /* @__PURE__ */ __name(async (config, collection) => {
+  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
+    });
+    const result = await MongoMap.create({
+      sdk: sdkBalanceSummaryMap,
+      getCache: {
+        enabled: true,
+        maxEntries: 5e3
+      }
+    });
+    return result;
+  } else {
+    return mapToMapType(/* @__PURE__ */ new Map());
+  }
+}, "getIterableMap");
+
+// 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: "XYOEthereumBridge",
+        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/XL1.json
+var XL1_default = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "2",
+        name: "XL1",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [
+          {
+            config: {
+              accountPath: "1/1'/1'",
+              automations: [
+                {
+                  frequency: 6e4,
+                  frequencyUnits: "millis",
+                  schema: "network.xyo.automation.interval",
+                  type: "interval"
+                }
+              ],
+              name: "XL1BridgeIntentTransactionCompletionMonitorSentinelIntervalSentinel",
+              schema: "network.xyo.sentinel.config",
+              synchronous: true,
+              tasks: [
+                {
+                  mod: "XL1BridgeIntentTransactionCompletionMonitorSentinel",
+                  endPoint: "report"
+                }
+              ]
+            }
+          }
+        ],
+        public: [
+          {
+            config: {
+              accountPath: "1/1/1",
+              name: "XL1BridgeIntentTransactionCompletionMonitorSentinel",
+              schema: "network.xyo.sentinel.chain.transaction.completion.monitor.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/manifest/public/Ethereum.json
+var Ethereum_default = {
+  $schema: "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
+  nodes: [
+    {
+      config: {
+        accountPath: "3",
+        name: "Ethereum",
+        schema: "network.xyo.node.config"
+      },
+      modules: {
+        private: [
+          {
+            config: {
+              accountPath: "1/1'/1'",
+              automations: [
+                {
+                  frequency: 6e4,
+                  frequencyUnits: "millis",
+                  schema: "network.xyo.automation.interval",
+                  type: "interval"
+                }
+              ],
+              name: "EVMLiquidityBridgeTransactionCompletionMonitorSentinelIntervalSentinel",
+              schema: "network.xyo.sentinel.config",
+              synchronous: true,
+              tasks: [
+                {
+                  mod: "EVMLiquidityBridgeTransactionCompletionMonitorSentinel",
+                  endPoint: "report"
+                }
+              ]
+            }
+          }
+        ],
+        public: [
+          {
+            config: {
+              accountPath: "1/1/1",
+              name: "EVMLiquidityBridgeTransactionCompletionMonitorSentinel",
+              schema: "network.xyo.sentinel.chain.evm.liquidity.bridge.transaction.completion.monitor.config"
+            }
+          }
+        ]
+      }
+    }
+  ],
+  schema: "network.xyo.manifest"
+};
+
+// src/manifest/public/index.ts
+var XL1NodeManifest = XL1_default;
+var EthereumNodeManifest = Ethereum_default;
+var PublicChildManifests = [
+  ...XL1NodeManifest.nodes,
+  ...EthereumNodeManifest.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 = HDWallet4.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 assertEx11(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+}, "getSeedPhrase");
 var getServer = /* @__PURE__ */ __name(async (context) => {
-  const { logger } = context;
-  const { port } = context.config.bridge;
-  await Promise.resolve();
-  const app = getApp();
+  const { logger, config } = context;
+  const { port, mnemonic } = config.bridge;
+  const bios = await boot();
+  const seedPhrase = isDefined8(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
+  const wallet = await HDWallet4.fromPhrase(seedPhrase);
+  const nodeContext = {
+    wallet,
+    logger,
+    config
+  };
+  const node = context.node ?? await getNode(nodeContext);
+  const app = getApp(node, config);
   const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`));
   server.setTimeout(2e4);
   return server;