@xyo-network/chain-bridge 1.19.14 → 1.19.16

package/dist/node/index.mjs

@@ -3,7 +3,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/BridgeActor.ts
 import { creatable } from "@xylabs/sdk-js";
-import { ActorV3, XyoGatewayRunnerMoniker as XyoGatewayRunnerMoniker2 } from "@xyo-network/xl1-sdk";
+import { asBridgeConfigContext } from "@xyo-network/chain-orchestration";
+import { ActorV3, XyoGatewayRunnerMoniker } from "@xyo-network/xl1-sdk";
 
 // src/server/app.ts
 import { customPoweredByHeader, disableCaseSensitiveRouting, disableExpressDefaultPoweredByHeader, getJsonBodyParser, getJsonBodyParserOptions, responseProfiler, standardErrors, standardResponses } from "@xylabs/express";
@@ -18,7 +19,7 @@ var connection;
 var maxRetriesPerRequest = null;
 var getConnection = /* @__PURE__ */ __name((config) => {
   if (isDefined(connection)) return connection;
-  const { redisHost: host, redisPort: port } = config.actors.bridge;
+  const { redisHost: host, redisPort: port } = config;
   connection = new Redis({
     host,
     port,
@@ -52,7 +53,7 @@ var createWorkers = /* @__PURE__ */ __name((connection2, services) => {
 
 // src/queue/workers/EthTransactionMonitor.ts
 import { assertEx } from "@xylabs/sdk-js";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { PayloadBuilder } from "@xyo-network/sdk-js";
 import { Worker } from "bullmq";
 var name = "Monitor Submitted ETH Transaction";
 var queueName = "eth-tx-monitor";
@@ -90,26 +91,88 @@ var EthTransactionMonitor = {
 };
 
 // src/queue/workers/EthTransactionPreparation.ts
-import { assertEx as assertEx2, hexToBigInt } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { isBridgeIntent } from "@xyo-network/xl1-sdk";
+import { assertEx as assertEx5, hexToBigInt as hexToBigInt4 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk-js";
+import { isBridgeIntent as isBridgeIntent4 } from "@xyo-network/xl1-sdk";
 import { Worker as Worker2 } from "bullmq";
 import { getAddress } from "ethers";
+
+// src/queue/workers/util/submitEthTransaction.ts
+import { assertEx as assertEx2, hexToBigInt, toEthAddress } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import { isBridgeIntent } from "@xyo-network/xl1-sdk";
+var submitEthTransaction = /* @__PURE__ */ __name(async (tx, bridgeableToken, bridge, wallet) => {
+  const xl1Transaction = assertEx2(tx[0], () => "No corresponding XL1 transaction found");
+  const bridgeIntent = assertEx2(tx[1].find(isBridgeIntent), () => "No bridge intent found");
+  const srcAddress = toEthAddress(bridgeIntent.srcAddress);
+  const destAddress = toEthAddress(bridgeIntent.destAddress);
+  const amount = hexToBigInt(bridgeIntent.destAmount);
+  const nonce = hexToBigInt(await PayloadBuilder2.hash(xl1Transaction));
+  const bridgeTx = await bridge.connect(wallet).bridgeFromRemote(srcAddress, destAddress, amount, nonce);
+  const receipt = await bridgeTx.wait(1);
+  return receipt?.hash;
+}, "submitEthTransaction");
+
+// src/queue/workers/util/submitXl1Transaction.ts
+import { isAllowedBlockPayload } from "@xyo-network/xl1-sdk";
+var submitXl1Transaction = /* @__PURE__ */ __name(async (preparedTx, gateway) => {
+  const offChainPayloads = preparedTx[1].filter((p) => !isAllowedBlockPayload(p));
+  const result = await gateway.addTransactionToChain(preparedTx, offChainPayloads);
+  return result;
+}, "submitXl1Transaction");
+
+// src/queue/workers/util/validateSufficientAllowance.ts
+import { assertEx as assertEx3, hexToBigInt as hexToBigInt2 } from "@xylabs/sdk-js";
+import { isBridgeIntent as isBridgeIntent2 } from "@xyo-network/xl1-sdk";
+var validateSufficientAllowance = /* @__PURE__ */ __name(async (tx, bridgeableToken, bridge, logger) => {
+  const bridgeIntent = assertEx3(tx[1].find(isBridgeIntent2), () => "No bridge intent found");
+  const amount = hexToBigInt2(bridgeIntent.destAmount);
+  const liquiditySourceAddress = await bridge.liquiditySource();
+  const bridgeAddress = await bridge.getAddress();
+  const remainingAllowance = await bridgeableToken.allowance(liquiditySourceAddress, bridgeAddress);
+  await logger?.log(`Remaining allowance: ${remainingAllowance.toString()}`);
+  return remainingAllowance >= amount;
+}, "validateSufficientAllowance");
+
+// src/queue/workers/util/validateSufficientBalance.ts
+import { assertEx as assertEx4, hexToBigInt as hexToBigInt3 } from "@xylabs/sdk-js";
+import { isBridgeIntent as isBridgeIntent3 } from "@xyo-network/xl1-sdk";
+var validateSufficientBalance = /* @__PURE__ */ __name(async (tx, bridgeableToken, bridge, logger) => {
+  const bridgeIntent = assertEx4(tx[1].find(isBridgeIntent3), () => "No bridge intent found");
+  const amount = hexToBigInt3(bridgeIntent.destAmount);
+  const liquiditySourceAddress = await bridge.liquiditySource();
+  const balance = await bridgeableToken.balanceOf(liquiditySourceAddress);
+  await logger?.log(`Remaining balance: ${balance.toString()}`);
+  return balance >= amount;
+}, "validateSufficientBalance");
+
+// src/queue/workers/EthTransactionPreparation.ts
 var name2 = "Prepare ETH Transaction";
 var queueName2 = "eth-tx-prepare";
 var createWorker2 = /* @__PURE__ */ __name((connection2, services) => {
-  const bridge = assertEx2(services?.bridge, () => "bridge service not provided");
-  const stateMap = assertEx2(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const bridge = assertEx5(services?.bridge, () => "bridge service not provided");
+  const bridgeableToken = assertEx5(services?.bridgeableToken, () => "bridgeableToken service not provided");
+  const stateMap = assertEx5(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
   const worker = new Worker2(queueName2, async (job) => {
     const { tx } = job.data;
-    const hash = await PayloadBuilder2.hash(tx[0]);
+    const hash = await PayloadBuilder3.hash(tx[0]);
     await job.log(`[${hash}] preparing ETH transaction`);
+    await job.log(`[${hash}] validating liquiditySource has sufficient allowance`);
+    if (!await validateSufficientAllowance(tx, bridgeableToken, bridge, job)) {
+      throw new Error("Liquidity source does not have sufficient allowance for the bridge to execute the transaction");
+    }
+    await job.log(`[${hash}] validated liquiditySource has sufficient allowance`);
+    await job.log(`[${hash}] validating liquiditySource has sufficient balance`);
+    if (!await validateSufficientBalance(tx, bridgeableToken, bridge, job)) {
+      throw new Error("Liquidity source does not have sufficient balance for the bridge to execute the transaction");
+    }
+    await job.log(`[${hash}] validated liquiditySource has sufficient balance`);
     await job.log(`[${hash}] building ETH transaction`);
-    const bridgeIntent = assertEx2(tx[1].find(isBridgeIntent), () => "No bridge intent found");
-    const amount = hexToBigInt(bridgeIntent.destAmount);
+    const bridgeIntent = assertEx5(tx[1].find(isBridgeIntent4), () => "No bridge intent found");
+    const amount = hexToBigInt4(bridgeIntent.destAmount);
     const srcAddress = getAddress(bridgeIntent.srcAddress);
     const destAddress = getAddress(bridgeIntent.destAddress);
-    const nonce = hexToBigInt(await PayloadBuilder2.hash(tx[0]));
+    const nonce = hexToBigInt4(await PayloadBuilder3.hash(tx[0]));
     const preparedTx = await bridge.getFunction("bridgeFromRemote").populateTransaction(srcAddress, destAddress, amount, nonce);
     await job.log(`[${hash}] built ETH transaction`);
     await job.log(`[${hash}] storing ETH preparedTx`);
@@ -136,47 +199,21 @@ var EthTransactionPreparation = {
 };
 
 // src/queue/workers/EthTransactionSubmission.ts
-import { assertEx as assertEx4, isDefined as isDefined3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx6, isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
 import { Worker as Worker3 } from "bullmq";
-
-// src/queue/workers/util/submitEthTransaction.ts
-import { assertEx as assertEx3, hexToBigInt as hexToBigInt2, toEthAddress } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
-import { isBridgeIntent as isBridgeIntent2 } from "@xyo-network/xl1-sdk";
-var submitEthTransaction = /* @__PURE__ */ __name(async (tx, bridgeableToken, bridge, wallet) => {
-  const xl1Transaction = assertEx3(tx[0], () => "No corresponding XL1 transaction found");
-  const bridgeIntent = assertEx3(tx[1].find(isBridgeIntent2), () => "No bridge intent found");
-  const srcAddress = toEthAddress(bridgeIntent.srcAddress);
-  const destAddress = toEthAddress(bridgeIntent.destAddress);
-  const amount = hexToBigInt2(bridgeIntent.destAmount);
-  const nonce = hexToBigInt2(await PayloadBuilder3.hash(xl1Transaction));
-  const bridgeTx = await bridge.connect(wallet).bridgeFromRemote(srcAddress, destAddress, amount, nonce);
-  const receipt = await bridgeTx.wait(1);
-  return receipt?.hash;
-}, "submitEthTransaction");
-
-// src/queue/workers/util/submitXl1Transaction.ts
-import { isAllowedBlockPayload } from "@xyo-network/xl1-sdk";
-var submitXl1Transaction = /* @__PURE__ */ __name(async (preparedTx, gateway) => {
-  const offChainPayloads = preparedTx[1].filter((p) => !isAllowedBlockPayload(p));
-  const result = await gateway.addTransactionToChain(preparedTx, offChainPayloads);
-  return result;
-}, "submitXl1Transaction");
-
-// src/queue/workers/EthTransactionSubmission.ts
 var name3 = "Submit ETH Transaction";
 var queueName3 = "eth-tx-submit";
 var createWorker3 = /* @__PURE__ */ __name((connection2, services) => {
-  const bridge = assertEx4(services?.bridge, () => "bridge service not provided");
-  const bridgeableToken = assertEx4(services?.bridgeableToken, () => "bridgeableToken service not provided");
-  const wallet = assertEx4(services?.wallet, () => "wallet service not provided");
-  const stateMap = assertEx4(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const bridge = assertEx6(services?.bridge, () => "bridge service not provided");
+  const bridgeableToken = assertEx6(services?.bridgeableToken, () => "bridgeableToken service not provided");
+  const wallet = assertEx6(services?.wallet, () => "wallet service not provided");
+  const stateMap = assertEx6(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
   const worker = new Worker3(queueName3, async (job) => {
     const { tx } = job.data;
     const hash = await PayloadBuilder4.hash(tx[0]);
-    const state = assertEx4(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const preparedTx = assertEx4(state?.preparedTx, () => `[${hash}] preparedTx not found`);
+    const state = assertEx6(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const preparedTx = assertEx6(state?.preparedTx, () => `[${hash}] preparedTx not found`);
     const { submissionHash: existingSubmissionHash } = state;
     if (isDefined3(existingSubmissionHash)) {
       await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
@@ -185,7 +222,7 @@ var createWorker3 = /* @__PURE__ */ __name((connection2, services) => {
       };
     }
     await job.log(`[${hash}] Submitting ETH tx`);
-    const submissionHash = assertEx4(await submitEthTransaction(tx, bridgeableToken, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`);
+    const submissionHash = assertEx6(await submitEthTransaction(tx, bridgeableToken, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`);
     await job.log(`[${hash}] Submitted ETH tx and received submission response hash ${submissionHash}`);
     await job.log(`[${hash}] Storing ETH submissionHash`);
     state.submissionHash = submissionHash;
@@ -239,20 +276,20 @@ var Xl1ToEthBridgeParent = {
 };
 
 // src/queue/workers/Xl1TransactionMonitor.ts
-import { assertEx as assertEx5, isDefined as isDefined4, isNull } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx7, isDefined as isDefined4, isNull } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
 import { UnrecoverableError, Worker as Worker5 } from "bullmq";
 var name5 = "Monitor Submitted XL1 Transaction";
 var queueName5 = "xl1-tx-monitor";
 var createWorker5 = /* @__PURE__ */ __name((connection2, services) => {
-  const gateway = assertEx5(services?.gateway, () => "gateway service not provided");
-  const stateMap = assertEx5(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const gateway = assertEx7(services?.gateway, () => "gateway service not provided");
+  const stateMap = assertEx7(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
   const worker = new Worker5(queueName5, async (job) => {
     const { tx } = job.data;
     const hash = await PayloadBuilder5.hash(tx[0]);
-    const viewer = assertEx5(gateway.connection.viewer, () => `[${hash}] viewer not defined on gateway`);
-    const state = assertEx5(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const submissionHash = assertEx5(state?.submissionHash, () => `[${hash}] submissionHash not found`);
+    const viewer = assertEx7(gateway.connection.viewer, () => `[${hash}] viewer not defined on gateway`);
+    const state = assertEx7(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const submissionHash = assertEx7(state?.submissionHash, () => `[${hash}] submissionHash not found`);
     await job.log(`[${hash}] Checking for XL1 transaction inclusion on chain`);
     const foundTx = await viewer.transactionByHash(submissionHash);
     if (isDefined4(foundTx) && !isNull(foundTx)) {
@@ -285,13 +322,13 @@ var Xl1TransactionMonitor = {
 };
 
 // src/queue/workers/Xl1TransactionPreparation.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/sdk-js";
 import { Worker as Worker6 } from "bullmq";
 var name6 = "Prepare XL1 Transaction";
 var queueName6 = "xl1-tx-prepare";
 var createWorker6 = /* @__PURE__ */ __name((connection2, services) => {
-  const stateMap = assertEx6(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const stateMap = assertEx8(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
   const worker = new Worker6(queueName6, async (job) => {
     const { tx } = job.data;
     const hash = await PayloadBuilder6.hash(tx[0]);
@@ -321,19 +358,19 @@ var Xl1TransactionPreparation = {
 };
 
 // src/queue/workers/Xl1TransactionSubmission.ts
-import { assertEx as assertEx7, isDefined as isDefined5 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx9, isDefined as isDefined5 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/sdk-js";
 import { Worker as Worker7 } from "bullmq";
 var name7 = "Submit XL1 Transaction";
 var queueName7 = "xl1-tx-submit";
 var createWorker7 = /* @__PURE__ */ __name((connection2, services) => {
-  const gateway = assertEx7(services?.gateway, () => "gateway service not provided");
-  const stateMap = assertEx7(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const gateway = assertEx9(services?.gateway, () => "gateway service not provided");
+  const stateMap = assertEx9(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
   const worker = new Worker7(queueName7, async (job) => {
     const { tx } = job.data;
     const hash = await PayloadBuilder7.hash(tx[0]);
-    const state = assertEx7(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const preparedTx = assertEx7(state?.preparedTx, () => `[${hash}] preparedTx not found`);
+    const state = assertEx9(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const preparedTx = assertEx9(state?.preparedTx, () => `[${hash}] preparedTx not found`);
     const { submissionHash: existingSubmissionHash } = state;
     if (isDefined5(existingSubmissionHash)) {
       await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
@@ -477,7 +514,7 @@ var addInstrumentation = /* @__PURE__ */ __name(() => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts
 import { requestHandlerValidator } from "@xylabs/express";
-import { BridgeSettingsZod } from "@xyo-network/xl1-sdk";
+import { BridgeSettingsZod } from "@xyo-network/chain-orchestration";
 
 // src/config/asChainId.ts
 import { asHex } from "@xylabs/sdk-js";
@@ -494,22 +531,22 @@ var asToken = /* @__PURE__ */ __name((value) => {
 }, "asToken");
 
 // src/config/getBridgeEscrowAddress.ts
-import { asAddress as asAddress2, assertEx as assertEx8 } from "@xylabs/sdk-js";
+import { asAddress as asAddress2, assertEx as assertEx10 } from "@xylabs/sdk-js";
 var tryGetBridgeEscrowAddress = /* @__PURE__ */ __name((config) => {
-  const address = asAddress2(config.actors.bridge.escrowAddress);
+  const address = asAddress2(config.escrowAddress);
   return address;
 }, "tryGetBridgeEscrowAddress");
 
 // src/config/getBridgeFeesAddress.ts
-import { asAddress as asAddress3, assertEx as assertEx9 } from "@xylabs/sdk-js";
+import { asAddress as asAddress3, assertEx as assertEx11 } from "@xylabs/sdk-js";
 var tryGetBridgeFeesAddress = /* @__PURE__ */ __name((config) => {
-  const address = asAddress3(config.actors.bridge.feesAddress);
+  const address = asAddress3(config.feesAddress);
   return address;
 }, "tryGetBridgeFeesAddress");
 
 // src/config/getFeeStructure.ts
 var getFeeStructure = /* @__PURE__ */ __name((config) => {
-  const { feeFixed, feeRateBasisPoints } = config.actors.bridge;
+  const { feeFixed, feeRateBasisPoints } = config;
   return {
     feeFixed,
     feeRateBasisPoints
@@ -518,28 +555,28 @@ var getFeeStructure = /* @__PURE__ */ __name((config) => {
 
 // src/config/getMaxBridgeAmount.ts
 var getMaxBridgeAmount = /* @__PURE__ */ __name((config) => {
-  const { maxBridgeAmount } = config.actors.bridge;
+  const { maxBridgeAmount } = config;
   return maxBridgeAmount;
 }, "getMaxBridgeAmount");
 
 // src/config/getMinBridgeAmount.ts
 var getMinBridgeAmount = /* @__PURE__ */ __name((config) => {
-  const { minBridgeAmount } = config.actors.bridge;
+  const { minBridgeAmount } = config;
   return minBridgeAmount;
 }, "getMinBridgeAmount");
 
 // src/config/getRemoteChainId.ts
-import { assertEx as assertEx10 } from "@xylabs/sdk-js";
+import { assertEx as assertEx12 } from "@xylabs/sdk-js";
 var getRemoteChainId = /* @__PURE__ */ __name((config) => {
-  const remoteChainId = assertEx10(asChainId(config.actors.bridge.remoteChainId), () => "Invalid remote chain ID in config");
+  const remoteChainId = assertEx12(asChainId(config.remoteChainId), () => "Invalid remote chain ID in config");
   return remoteChainId;
 }, "getRemoteChainId");
 
 // src/config/getRemoteTokenAddress.ts
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx13 } from "@xylabs/sdk-js";
 var getRemoteTokenAddress = /* @__PURE__ */ __name((config) => {
-  const token = asToken(config.actors.bridge.remoteTokenAddress);
-  return assertEx11(token, () => "Remote token address is not defined in bridge configuration");
+  const token = asToken(config.remoteTokenAddress);
+  return assertEx13(token, () => "Remote token address is not defined in bridge configuration");
 }, "getRemoteTokenAddress");
 
 // src/config/getBridgeWalletAccount.ts
@@ -549,7 +586,7 @@ import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1
 var accountServiceSingleton;
 var getBridgeWalletAccount = /* @__PURE__ */ __name(async (config) => {
   if (accountServiceSingleton) return accountServiceSingleton;
-  let walletPhrase = config.actors.bridge.mnemonic;
+  let walletPhrase = config.mnemonic;
   if (isUndefined(walletPhrase)) {
     console.log("[Bridge] No wallet mnemonic specified!");
     const randomMnemonic = HDWallet.generateMnemonic();
@@ -577,19 +614,19 @@ var getTransferAddresses = /* @__PURE__ */ __name(async (config) => {
 }, "getTransferAddresses");
 
 // src/config/getXl1ChainId.ts
-import { assertEx as assertEx12, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { assertEx as assertEx14, isDefined as isDefined7 } from "@xylabs/sdk-js";
 var getXl1ChainId = /* @__PURE__ */ __name((config) => {
-  const xl1ChainId = config.actors.bridge.xl1ChainId;
+  const xl1ChainId = config.xl1ChainId;
   if (isDefined7(xl1ChainId)) {
-    return assertEx12(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
+    return assertEx14(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
   }
-  return assertEx12(asChainId(config.chain.id), () => "Invalid chain.id in config");
+  return assertEx14(asChainId(config.chain.id), () => "Invalid chain.id in config");
 }, "getXl1ChainId");
 
 // src/config/getXl1TokenAddress.ts
 import { isDefined as isDefined8 } from "@xylabs/sdk-js";
 var getXl1TokenAddress = /* @__PURE__ */ __name((config) => {
-  const token = asToken(config.actors.bridge.xl1TokenAddress);
+  const token = asToken(config.xl1TokenAddress);
   if (isDefined8(token)) return token;
   return getXl1ChainId(config);
 }, "getXl1TokenAddress");
@@ -649,7 +686,7 @@ var makeBridgeConfigRoute = /* @__PURE__ */ __name((config) => {
 // 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 { PayloadZodStrictOfSchema } from "@xyo-network/sdk-js";
 import { BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema } from "@xyo-network/xl1-sdk";
 import { z } from "zod";
 
@@ -709,33 +746,49 @@ var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
 import { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
-import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/payload-builder";
-import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/payload-model";
+import { PayloadBuilder as PayloadBuilder11, PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/sdk-js";
 import { BridgeIntentFieldsZod, BridgeIntentSchema as BridgeIntentSchema2, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, SignedTransactionBoundWitnessZod, TransferZod } from "@xyo-network/xl1-sdk";
 import { z as z2 } from "zod";
 
 // src/util/calculateBridgeFees.ts
-import { hexToBigInt as hexToBigInt3, toHex as toHex2 } from "@xylabs/sdk-js";
+import { hexToBigInt as hexToBigInt5, toHex as toHex2 } from "@xylabs/sdk-js";
 var calculateBridgeFees = /* @__PURE__ */ __name((srcAmount, feeStructure) => {
   const { feeFixed, feeRateBasisPoints } = feeStructure;
-  const srcAmountBigInt = hexToBigInt3(srcAmount);
-  const feeFixedBigInt = hexToBigInt3(feeFixed);
+  const srcAmountBigInt = hexToBigInt5(srcAmount);
+  const feeFixedBigInt = hexToBigInt5(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
+    feeVariable,
+    srcAmount
   };
 }, "calculateBridgeFees");
 
+// src/util/createBridgeTransfer.ts
+import { hexToBigInt as hexToBigInt6 } from "@xylabs/sdk-js";
+import { createTransferPayload } from "@xyo-network/xl1-sdk";
+var createBridgeTransfer = /* @__PURE__ */ __name((sender, srcAmount, escrowAddress, feesAddress, context) => {
+  const { feeFixed, feeVariable } = context;
+  const escrowAmount = hexToBigInt6(srcAmount);
+  const feesAmount = hexToBigInt6(feeFixed) + hexToBigInt6(feeVariable);
+  const transfers = escrowAddress === feesAddress ? {
+    [feesAddress]: escrowAmount + feesAmount
+  } : {
+    [escrowAddress]: escrowAmount,
+    [feesAddress]: feesAmount
+  };
+  const transfer = createTransferPayload(sender, transfers, context);
+  return transfer;
+}, "createBridgeTransfer");
+
 // src/util/generateBridgeEstimate.ts
-import { hexToBigInt as hexToBigInt4, toAddress as toAddress2 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
-import { BridgeIntentSchema, createTransferPayload } from "@xyo-network/xl1-sdk";
+import { toAddress as toAddress2 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/sdk-js";
+import { BridgeIntentSchema } from "@xyo-network/xl1-sdk";
 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);
@@ -744,7 +797,6 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
     feeFixed,
     feeRateBasisPoints
   });
-  const { destAmount, feeFixed: feeFixedAmount, feeVariable } = fees;
   const nonce = nonceOverride ?? v4();
   const bridgeIntentFields = {
     // Source
@@ -755,22 +807,14 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
     // Destination
     dest: remoteChainId,
     destAddress,
-    destAmount,
+    destAmount: srcAmount,
     destToken: remoteTokenAddress,
     nonce
   };
   const bridgeIntent = new PayloadBuilder8({
     schema: BridgeIntentSchema
   }).fields(bridgeIntentFields).build();
-  const context = {
-    destAmount,
-    feeFixed: feeFixedAmount,
-    feeVariable
-  };
-  const transfer = createTransferPayload(sender, {
-    [escrowAddress]: hexToBigInt4(destAmount),
-    [feesAddress]: hexToBigInt4(feeFixedAmount) + hexToBigInt4(feeVariable)
-  }, context);
+  const transfer = createBridgeTransfer(sender, srcAmount, escrowAddress, feesAddress, fees);
   return [
     bridgeIntent,
     transfer
@@ -779,7 +823,7 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
 
 // src/util/validateBridgeEstimateExact.ts
 import { isUndefined as isUndefined3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/sdk-js";
 var validateBridgeEstimateExact = /* @__PURE__ */ __name(async (intent, transfer, config) => {
   const { srcAddress, srcAmount, destAddress } = intent;
   const [calculatedIntent, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
@@ -796,7 +840,7 @@ var validateBridgeEstimateExact = /* @__PURE__ */ __name(async (intent, transfer
 // src/util/validateBridgeTransaction.ts
 import { asAddress as asAddress4, isDefined as isDefined9 } from "@xylabs/sdk-js";
 import { addressesContains, BoundWitnessValidator, payloadHashesContainsAll } from "@xyo-network/boundwitness-validator";
-import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/sdk-js";
 var validateBridgeTransaction = /* @__PURE__ */ __name(async (signedTxBw, intent, transfer, config) => {
   const { srcAddress } = intent;
   const chainId = getXl1ChainId(config);
@@ -870,8 +914,8 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
 import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
-import { assertEx as assertEx13, toAddress as toAddress3 } from "@xylabs/sdk-js";
-import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3 } from "@xyo-network/payload-model";
+import { assertEx as assertEx15, toAddress as toAddress3 } from "@xylabs/sdk-js";
+import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3 } from "@xyo-network/sdk-js";
 import { BridgeIntentFieldsZod as BridgeIntentFieldsZod2, BridgeIntentSchema as BridgeIntentSchema3, buildUnsignedTransaction, toXL1BlockNumber, TransactionBoundWitnessZod, TransferZod as TransferZod2 } from "@xyo-network/xl1-sdk";
 import { z as z3 } from "zod";
 var BridgeToRemoteEstimateBodyZod = BridgeIntentFieldsZod2.pick({
@@ -901,7 +945,7 @@ var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) =
       const { srcAddress, srcAmount, destAddress } = req.body;
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
       const sender = toAddress3(srcAddress);
-      const viewer = assertEx13(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const viewer = assertEx15(gateway.connection.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);
@@ -922,7 +966,7 @@ var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) =
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteStatus.ts
 import { requestHandlerValidator as requestHandlerValidator5 } from "@xylabs/express";
 import { asAddress as asAddress5, asHex as asHex3, toHex as toHex3 } from "@xylabs/sdk-js";
-import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema4 } from "@xyo-network/payload-model";
+import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema4 } from "@xyo-network/sdk-js";
 import { BridgeDestinationObservationFieldsZod as BridgeDestinationObservationFieldsZod2, BridgeDestinationObservationSchema as BridgeDestinationObservationSchema2, BridgeIntentFieldsZod as BridgeIntentFieldsZod3, BridgeIntentSchema as BridgeIntentSchema4, BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod2, BridgeSourceObservationSchema as BridgeSourceObservationSchema2 } from "@xyo-network/xl1-sdk";
 import { z as z4 } from "zod";
 var BridgeToRemoteStatusResponseZod = z4.union([
@@ -1034,7 +1078,7 @@ var addRoutes = /* @__PURE__ */ __name((app, config, gateway) => {
 }, "addRoutes");
 
 // src/server/app.ts
-var getApp = /* @__PURE__ */ __name((node, config, gateway) => {
+var getApp = /* @__PURE__ */ __name((config, gateway) => {
   addInstrumentation();
   const app = express();
   app.set("etag", false);
@@ -1048,390 +1092,23 @@ var getApp = /* @__PURE__ */ __name((node, config, gateway) => {
   disableExpressDefaultPoweredByHeader(app);
   app.use(customPoweredByHeader);
   disableCaseSensitiveRouting(app);
-  app.node = node;
   addFlowProducer(app, config);
   addRoutes(app, config, gateway);
   app.use(standardErrors);
   return app;
 }, "getApp");
 
-// src/server/server.ts
-import { assertEx as assertEx19, isDefined as isDefined14, isString } from "@xylabs/sdk-js";
-import { boot } from "@xyo-network/bios";
-import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
+// src/services/getServices.ts
+import { assertEx as assertEx16, isDefined as isDefined10 } from "@xylabs/sdk-js";
+import { initEvmProvider } from "@xyo-network/chain-orchestration";
+import { BridgeableToken__factory, LiquidityPoolBridge__factory } from "@xyo-network/typechain";
+import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
+import { getAddress as getAddress2, Wallet } from "ethers";
 
-// src/manifest/getModuleLocator.ts
+// src/services/getIterableMap.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx16, isDefined as isDefined12 } 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 { initEvmProvider } from "@xyo-network/chain-orchestration";
 import { MongoMap } from "@xyo-network/chain-protocol";
-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, mapToMapType, XyoGatewayRunnerMoniker } from "@xyo-network/xl1-sdk";
-
-// src/modules/EVMLiquidityBridgeTransactionCompletionMonitorSentinel/EVMLiquidityBridgeTransactionCompletionMonitorSentinel.ts
-import { asAddress as asAddress6, asHex as asHex4, assertEx as assertEx14, delay, hexFromBigInt, hexToBigInt as hexToBigInt5, isDefined as isDefined10, isUndefined as isUndefined4 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/payload-builder";
-import { asSchema } from "@xyo-network/payload-model";
-import { AbstractSentinel } from "@xyo-network/sentinel-abstract";
-import { LiquidityPoolBridge__factory } from "@xyo-network/typechain";
-import { BridgeDestinationObservationSchema as BridgeDestinationObservationSchema3, flattenHydratedTransaction, flattenHydratedTransactions, isBridgeIntent as isBridgeIntent3, tryUnflattenHydratedTransaction } from "@xyo-network/xl1-sdk";
-import { Mutex } from "async-mutex";
-import { getAddress as getAddress2 } from "ethers/address";
-import { Wallet } from "ethers/wallet";
-var EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema = asSchema("network.xyo.sentinel.chain.evm.liquidity.bridge.transaction.completion.monitor.config", true);
-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 assertEx14(this._bridge, () => new Error("Bridge contract not initialized"));
-  }
-  get completedTransactions() {
-    return assertEx14(this.params.completedTransactions, () => "Completed transactions map is not defined");
-  }
-  get jobCheckInterval() {
-    return isDefined10(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs;
-  }
-  get pendingTransactions() {
-    return assertEx14(this.params.pendingTransactions, () => "Pending transactions map is not defined");
-  }
-  get wallet() {
-    return assertEx14(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 = assertEx14(this.account?.private?.hex, () => new Error("Account private key is required"));
-    this._wallet = new Wallet(key, provider);
-    this._bridge = LiquidityPoolBridge__factory.connect(getAddress2(bridgeAddress), this._wallet);
-    const network = await provider.getNetwork();
-    this._bridgeChainId = assertEx14(hexFromBigInt(network.chainId), () => new Error("Failed to parse bridgeChainId"));
-    const tokenAddress = await this.bridge.token();
-    this._bridgeTokenAddress = asAddress6(tokenAddress, true);
-    const bridgeRemoteChain = await this.bridge.remoteChain();
-    this._bridgeRemoteChainId = asHex4(bridgeRemoteChain);
-  }
-  async reportHandler(payloads) {
-    if (isDefined10(payloads) && payloads.length > 0) {
-      const signedHydratedTransaction = tryUnflattenHydratedTransaction(payloads);
-      if (isDefined10(signedHydratedTransaction)) {
-        const txHash = await PayloadBuilder12.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 flattenHydratedTransaction(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 response = [];
-        if (isUndefined4(payloads) || payloads.length === 0) {
-          await this.processAllTransactions();
-        }
-        return response;
-      });
-    }
-  }
-  async processAllTransactions() {
-    const results = [];
-    for await (const [hash, signedHydratedTransaction] of this.pendingTransactions) {
-      const result = await this.processTransaction([
-        hash,
-        signedHydratedTransaction
-      ]);
-      if (isDefined10(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(isBridgeIntent3);
-      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 = hexToBigInt5(bridgeIntent.destAmount);
-    const nonce = await this.wallet.getNonce();
-    const srcAddress = getAddress2(bridgeIntent.srcAddress);
-    const destAddress = getAddress2(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 PayloadBuilder12({
-      schema: BridgeDestinationObservationSchema3
-    }).fields({
-      ...rest,
-      destConfirmation
-    }).build();
-    return result;
-  }
-};
-
-// src/modules/XL1TransactionCompletionMonitorSentinel/XL1TransactionCompletionMonitorSentinel.ts
-import { assertEx as assertEx15, delay as delay2, isDefined as isDefined11, isNull as isNull2, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/payload-builder";
-import { asSchema as asSchema2 } from "@xyo-network/payload-model";
-import { AbstractSentinel as AbstractSentinel2 } from "@xyo-network/sentinel-abstract";
-import { flattenHydratedTransaction as flattenHydratedTransaction2, flattenHydratedTransactions as flattenHydratedTransactions2, tryUnflattenHydratedTransaction as tryUnflattenHydratedTransaction2 } from "@xyo-network/xl1-sdk";
-import { Mutex as Mutex2 } from "async-mutex";
-var XL1TransactionCompletionMonitorSentinelConfigSchema = asSchema2("network.xyo.sentinel.chain.transaction.completion.monitor.config", true);
-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 assertEx15(this.params.completedTransactions, () => "Completed transactions map is not defined");
-  }
-  get jobCheckInterval() {
-    return isDefined11(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs2;
-  }
-  get pendingTransactions() {
-    return assertEx15(this.params.pendingTransactions, () => "Pending transactions map is not defined");
-  }
-  get viewer() {
-    return assertEx15(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 (isDefined11(payloads) && payloads.length > 0) {
-      const signedHydratedTransaction = tryUnflattenHydratedTransaction2(payloads);
-      if (isDefined11(signedHydratedTransaction)) {
-        const txHash = await PayloadBuilder13.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(`XL1TransactionCompletionMonitorSentinel [${this.id}] is already running, skipping report [${Date.now()}]`);
-        return [];
-      }
-      return await this._reportMutex.runExclusive(async () => {
-        const response = [];
-        if (isUndefined5(payloads) || payloads.length === 0) {
-          await this.processAllTransactions();
-        }
-        return response;
-      });
-    }
-  }
-  async processAllTransactions() {
-    const results = [];
-    for await (const [hash, signedHydratedTransaction] of this.pendingTransactions) {
-      const result = await this.processTransaction([
-        hash,
-        signedHydratedTransaction
-      ]);
-      if (isDefined11(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 (isDefined11(tx) && !isNull2(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/getModuleLocator.ts
-var getModuleLocator = /* @__PURE__ */ __name(async (context) => {
-  const { config, locator, 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 (isDefined12(logger)) AbstractModule.defaultLogger = logger;
-  const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
-  const moduleLocator = 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
-    };
-    moduleLocator.register(MongoDBArchivistV2.factory(params), void 0, true);
-  }
-  moduleLocator.register(MemoryArchivist.factory({
-    traceProvider,
-    meterProvider,
-    statusReporter
-  }));
-  moduleLocator.register(MemorySentinel.factory({
-    traceProvider,
-    meterProvider,
-    statusReporter
-  }));
-  moduleLocator.register(ViewArchivist.factory({
-    traceProvider,
-    meterProvider,
-    statusReporter
-  }));
-  const gateway = await locator.getInstance(XyoGatewayRunnerMoniker);
-  const viewer = assertEx16(gateway.connection.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
-  };
-  moduleLocator.register(XL1TransactionCompletionMonitorSentinel.factory(xl1TransactionCompletionMonitorSentinelParams));
-  const completedEthXl1BridgeTransactions = await getIterableMap(config, "liquidity_bridge_eth_xl1_bridge_completed");
-  const provider = await initEvmProvider({
-    config
-  });
-  const bridgeAddress = config.actors.bridge.remoteBridgeContractAddress;
-  const evmLiquidityBridgeTransactionCompletionMonitorSentinelParams = {
-    bridgeAddress,
-    completedTransactions: completedEthXl1BridgeTransactions,
-    config: {
-      schema: EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema
-    },
-    meterProvider,
-    pendingTransactions: completedXl1ToEthXl1BridgeIntentTransactions,
-    provider,
-    statusReporter,
-    traceProvider
-  };
-  moduleLocator.register(EVMLiquidityBridgeTransactionCompletionMonitorSentinel.factory(evmLiquidityBridgeTransactionCompletionMonitorSentinelParams));
-  return moduleLocator;
-}, "getModuleLocator");
+import { hasMongoConfig, mapToMapType } from "@xyo-network/xl1-sdk";
 var getIterableMap = /* @__PURE__ */ __name(async (config, collection) => {
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig(mongoConfig)) {
@@ -1460,110 +1137,19 @@ var getIterableMap = /* @__PURE__ */ __name(async (config, collection) => {
   }
 }, "getIterableMap");
 
-// src/manifest/getNode.ts
-import { assertEx as assertEx17 } from "@xylabs/sdk-js";
-import { ManifestWrapper } from "@xyo-network/manifest-wrapper";
-import { buildJsonRpcProviderLocator, HttpRpcTransport } from "@xyo-network/xl1-sdk";
-
-// 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/getNode.ts
-var getNode = /* @__PURE__ */ __name(async (context) => {
-  const { config, wallet } = context;
-  const endpoint = assertEx17(config.actors.bridge.remote?.rpc?.url ?? config.remote?.rpc?.url, () => "RPC URL is required for Node");
-  const transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport(endpoint, schemas), "transportFactory");
-  const signerAccount = await getBridgeWalletAccount(config);
-  const locator = await buildJsonRpcProviderLocator({
-    signerAccount,
-    transportFactory
-  });
-  const moduleLocator = await getModuleLocator({
-    ...context,
-    locator
-  });
-  const wrapper = new ManifestWrapper(NodeManifest, wallet, moduleLocator, [], []);
-  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/manifest/getServices.ts
-import { assertEx as assertEx18, isDefined as isDefined13 } from "@xylabs/sdk-js";
-import { initEvmProvider as initEvmProvider2 } from "@xyo-network/chain-orchestration";
-import { BridgeableToken__factory, LiquidityPoolBridge__factory as LiquidityPoolBridge__factory2 } from "@xyo-network/typechain";
-import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
-import { getAddress as getAddress3, Wallet as Wallet2 } from "ethers";
-
-// src/manifest/getIterableMap.ts
-import { BaseMongoSdk as BaseMongoSdk2 } from "@xylabs/mongo";
-import { MongoMap as MongoMap2 } from "@xyo-network/chain-protocol";
-import { hasMongoConfig as hasMongoConfig2, mapToMapType as mapToMapType2 } from "@xyo-network/xl1-sdk";
-var getIterableMap2 = /* @__PURE__ */ __name(async (config, collection) => {
-  const mongoConfig = config.storage?.mongo;
-  if (hasMongoConfig2(mongoConfig)) {
-    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
-    const payloadSdkConfig = {
-      dbConnectionString,
-      dbDomain,
-      dbName,
-      dbPassword,
-      dbUserName
-    };
-    const sdkBalanceSummaryMap = new BaseMongoSdk2({
-      ...payloadSdkConfig,
-      collection
-    });
-    const result = await MongoMap2.create({
-      sdk: sdkBalanceSummaryMap,
-      getCache: {
-        enabled: true,
-        maxEntries: 5e3
-      }
-    });
-    return result;
-  } else {
-    return mapToMapType2(/* @__PURE__ */ new Map());
-  }
-}, "getIterableMap");
-
-// src/manifest/getServices.ts
+// src/services/getServices.ts
 var getServices = /* @__PURE__ */ __name(async (context, gateway) => {
   const { config } = context;
-  const ethTxStateMap = await getIterableMap2(config, "liquidity_bridge_xl1_to_eth_eth_tx_state");
-  const xl1TxStateMap = await getIterableMap2(config, "liquidity_bridge_xl1_to_eth_xl1_tx_state");
-  const provider = await initEvmProvider2({
-    config
-  });
-  const { remoteBridgeContractAddress, remoteChainWalletPrivateKey, remoteTokenAddress, mnemonic } = config.actors.bridge;
-  const account = isDefined13(mnemonic) ? await HDWallet2.fromPhrase(mnemonic) : await HDWallet2.random();
-  const wallet = new Wallet2(remoteChainWalletPrivateKey, provider);
-  const bridgeableToken = BridgeableToken__factory.connect(getAddress3(remoteTokenAddress), wallet);
-  const bridge = LiquidityPoolBridge__factory2.connect(getAddress3(remoteBridgeContractAddress), wallet);
+  const ethTxStateMap = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_eth_tx_state");
+  const xl1TxStateMap = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_xl1_tx_state");
+  const provider = await initEvmProvider(context);
+  const { remoteBridgeContractAddress, remoteChainWalletPrivateKey, remoteTokenAddress, mnemonic } = config;
+  const account = isDefined10(mnemonic) ? await HDWallet2.fromPhrase(mnemonic) : await HDWallet2.random();
+  const wallet = new Wallet(remoteChainWalletPrivateKey, provider);
+  const bridgeableToken = BridgeableToken__factory.connect(getAddress2(remoteTokenAddress), wallet);
+  const bridge = LiquidityPoolBridge__factory.connect(getAddress2(remoteBridgeContractAddress), wallet);
   const bridgeOwner = await bridge.owner();
-  assertEx18(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
+  assertEx16(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
   return {
     account,
     bridge,
@@ -1584,43 +1170,11 @@ var addWorkers = /* @__PURE__ */ __name((config, services) => {
 
 // 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.actors.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 = HDWallet3.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 assertEx19(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
-}, "getSeedPhrase");
 var getServer = /* @__PURE__ */ __name(async (context, gateway) => {
   const { logger, config } = context;
-  const { port, mnemonic } = config.actors.bridge;
-  const bios = await boot();
-  const seedPhrase = isDefined14(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
-  const wallet = await HDWallet3.fromPhrase(seedPhrase);
-  const nodeContext = {
-    wallet,
-    logger,
-    config
-  };
-  const node = context.node ?? await getNode(nodeContext);
-  const app = getApp(node, config, gateway);
-  const services = await getServices({
-    config,
-    logger
-  }, gateway);
+  const { port } = config;
+  const app = getApp(config, gateway);
+  const services = await getServices(context, gateway);
   addWorkers(config, services);
   const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`));
   server.setTimeout(2e4);
@@ -1646,7 +1200,7 @@ var BridgeActor = class extends ActorV3 {
   }
   async createHandler() {
     await super.createHandler();
-    this._gatewayRunner = await this.locator.getInstance(XyoGatewayRunnerMoniker2);
+    this._gatewayRunner = await this.locator.getInstance(XyoGatewayRunnerMoniker);
   }
   async startHandler() {
     await super.startHandler();
@@ -1658,7 +1212,7 @@ var BridgeActor = class extends ActorV3 {
     this.stopServer();
   }
   async startServer() {
-    this.server = await getServer(this.context, this._gatewayRunner);
+    this.server = await getServer(asBridgeConfigContext(this.context, true), this._gatewayRunner);
   }
   stopServer() {
     this.server?.close();