@xyo-network/chain-bridge 1.19.6 → 1.19.8

package/dist/node/index.mjs

@@ -14,7 +14,7 @@ var connection;
 var maxRetriesPerRequest = null;
 var getConnection = /* @__PURE__ */ __name((config) => {
   if (isDefined(connection)) return connection;
-  const { redisHost: host, redisPort: port } = config.bridge;
+  const { redisHost: host, redisPort: port } = config.actors.bridge;
   connection = new Redis({
     host,
     port,
@@ -35,15 +35,28 @@ var getFlowProducer = /* @__PURE__ */ __name((connection2) => {
   return flowProducer;
 }, "getFlowProducer");
 
-// src/queue/workers/ethTransactionMonitor.ts
+// src/queue/workers/createWorkers.ts
+var createWorkers = /* @__PURE__ */ __name((connection2, services) => {
+  Xl1ToEthBridgeParent.createWorker(connection2);
+  Xl1TransactionPreparation.createWorker(connection2, services);
+  Xl1TransactionSubmission.createWorker(connection2, services);
+  Xl1TransactionMonitor.createWorker(connection2, services);
+  EthTransactionPreparation.createWorker(connection2, services);
+  EthTransactionSubmission.createWorker(connection2, services);
+  EthTransactionMonitor.createWorker(connection2, services);
+}, "createWorkers");
+
+// src/queue/workers/EthTransactionMonitor.ts
 import { assertEx } from "@xylabs/sdk-js";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { Worker } from "bullmq";
 var name = "Monitor Submitted ETH Transaction";
 var queueName = "eth-tx-monitor";
-var createWorker = /* @__PURE__ */ __name((connection2) => {
-  new Worker(queueName, async (job) => {
-    const { provider, ethTxStateMap: stateMap, tx } = job.data;
+var createWorker = /* @__PURE__ */ __name((connection2, services) => {
+  const provider = assertEx(services?.provider, () => "provider service not provided");
+  const stateMap = assertEx(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const worker = new Worker(queueName, async (job) => {
+    const { tx } = job.data;
     const hash = await PayloadBuilder.hash(tx[0]);
     const state = assertEx(await stateMap.get(hash), () => "State not found");
     const submissionHash = assertEx(state?.submissionHash, () => "submissionHash not found");
@@ -59,14 +72,20 @@ var createWorker = /* @__PURE__ */ __name((connection2) => {
   }, {
     connection: connection2
   });
+  worker.on("failed", (job, err) => {
+    console.error(`[${name}] Job ${job?.id} failed:`, err.message);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name}] Worker error:`, err);
+  });
 }, "createWorker");
-var ethTransactionMonitor = {
+var EthTransactionMonitor = {
   createWorker,
   name,
   queueName
 };
 
-// src/queue/workers/ethTransactionPreparation.ts
+// 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";
@@ -74,9 +93,11 @@ import { Worker as Worker2 } from "bullmq";
 import { getAddress } from "ethers";
 var name2 = "Prepare ETH Transaction";
 var queueName2 = "eth-tx-prepare";
-var createWorker2 = /* @__PURE__ */ __name((connection2) => {
-  new Worker2(queueName2, async (job) => {
-    const { bridge, ethTxStateMap: stateMap, tx } = job.data;
+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 worker = new Worker2(queueName2, async (job) => {
+    const { tx } = job.data;
     const hash = await PayloadBuilder2.hash(tx[0]);
     await job.log(`[${hash}] preparing ETH transaction`);
     await job.log(`[${hash}] building ETH transaction`);
@@ -84,7 +105,8 @@ var createWorker2 = /* @__PURE__ */ __name((connection2) => {
     const amount = hexToBigInt(bridgeIntent.destAmount);
     const srcAddress = getAddress(bridgeIntent.srcAddress);
     const destAddress = getAddress(bridgeIntent.destAddress);
-    const preparedTx = await bridge.getFunction("bridgeFromRemote").populateTransaction(srcAddress, destAddress, amount, 0n);
+    const nonce = hexToBigInt(await PayloadBuilder2.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`);
     await stateMap.set(hash, {
@@ -96,25 +118,62 @@ var createWorker2 = /* @__PURE__ */ __name((connection2) => {
   }, {
     connection: connection2
   });
+  worker.on("failed", (job, err) => {
+    console.error(`[${name2}] Job ${job?.id} failed:`, err.message);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name2}] Worker error:`, err);
+  });
 }, "createWorker");
-var ethTransactionPreparation = {
+var EthTransactionPreparation = {
   createWorker: createWorker2,
   name: name2,
   queueName: queueName2
 };
 
-// src/queue/workers/ethTransactionSubmission.ts
-import { assertEx as assertEx3, isDefined as isDefined3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+// 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 { 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 onChain = preparedTx[1].filter(isAllowedBlockPayload);
+  const offChainPayloads = preparedTx[1].filter((p) => !isAllowedBlockPayload(p));
+  const result = await gateway.addPayloadsToChain(onChain, offChainPayloads);
+  return result;
+}, "submitXl1Transaction");
+
+// src/queue/workers/EthTransactionSubmission.ts
 var name3 = "Submit ETH Transaction";
 var queueName3 = "eth-tx-submit";
-var createWorker3 = /* @__PURE__ */ __name((connection2) => {
-  new Worker3(queueName3, async (job) => {
-    const { ethTxStateMap: stateMap, tx, wallet } = job.data;
-    const hash = await PayloadBuilder3.hash(tx[0]);
-    const state = assertEx3(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const preparedTx = assertEx3(state?.preparedTx, () => `[${hash}] preparedTx not found`);
+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 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 { submissionHash: existingSubmissionHash } = state;
     if (isDefined3(existingSubmissionHash)) {
       await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
@@ -123,8 +182,7 @@ var createWorker3 = /* @__PURE__ */ __name((connection2) => {
       };
     }
     await job.log(`[${hash}] Submitting ETH tx`);
-    const submissionResponse = await wallet.sendTransaction(preparedTx);
-    const submissionHash = submissionResponse.hash;
+    const submissionHash = assertEx4(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;
@@ -137,19 +195,25 @@ var createWorker3 = /* @__PURE__ */ __name((connection2) => {
     connection: connection2,
     concurrency: 1
   });
+  worker.on("failed", (job, err) => {
+    console.error(`[${name3}] Job ${job?.id} failed:`, err.message);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name3}] Worker error:`, err);
+  });
 }, "createWorker");
-var ethTransactionSubmission = {
+var EthTransactionSubmission = {
   createWorker: createWorker3,
   name: name3,
   queueName: queueName3
 };
 
-// src/queue/workers/xl1ToEthBridgeParent.ts
+// src/queue/workers/Xl1ToEthBridgeParent.ts
 import { Worker as Worker4 } from "bullmq";
 var name4 = "Bridge XL1 to Ethereum";
 var queueName4 = "xl1-to-eth-bridge";
 var createWorker4 = /* @__PURE__ */ __name((connection2) => {
-  new Worker4(queueName4, async (job) => {
+  const worker = new Worker4(queueName4, async (job) => {
     await job.log(`[${job.name}] start`);
     await job.log(`[${job.name}] done`);
     return {
@@ -158,30 +222,39 @@ var createWorker4 = /* @__PURE__ */ __name((connection2) => {
   }, {
     connection: connection2
   });
+  worker.on("failed", (job, err) => {
+    console.error(`[${name4}] Job ${job?.id} failed:`, err.message);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name4}] Worker error:`, err);
+  });
 }, "createWorker");
-var xl1ToEthBridgeParent = {
+var Xl1ToEthBridgeParent = {
   createWorker: createWorker4,
   name: name4,
   queueName: queueName4
 };
 
-// src/queue/workers/xl1TransactionMonitor.ts
-import { assertEx as assertEx4, isDefined as isDefined4, isNull } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+// 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 { UnrecoverableError, Worker as Worker5 } from "bullmq";
 var name5 = "Monitor Submitted XL1 Transaction";
 var queueName5 = "xl1-tx-monitor";
-var createWorker5 = /* @__PURE__ */ __name((connection2) => {
-  new Worker5(queueName5, async (job) => {
-    const { gateway, tx, xl1TxStateMap: stateMap } = job.data;
-    const hash = await PayloadBuilder4.hash(tx[0]);
-    const viewer = assertEx4(gateway.connection.viewer, () => `[${hash}] viewer not defined on gateway`);
-    const state = assertEx4(await stateMap.get(hash), () => `[${hash}] state not found`);
+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 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`);
     await job.log(`[${hash}] Checking for XL1 transaction inclusion on chain`);
-    const foundTx = await viewer.transactionByHash(hash);
+    const foundTx = await viewer.transactionByHash(submissionHash);
     if (isDefined4(foundTx) && !isNull(foundTx)) {
       await job.log(`[${hash}] Found transaction on chain`);
-      state.confirmationHash = hash;
+      state.confirmationHash = await PayloadBuilder5.hash(foundTx[0]);
       await stateMap.set(hash, state);
       return {};
     }
@@ -195,22 +268,30 @@ var createWorker5 = /* @__PURE__ */ __name((connection2) => {
   }, {
     connection: connection2
   });
+  worker.on("failed", (job, err) => {
+    console.error(`[${name5}] Job ${job?.id} failed:`, err.message);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name5}] Worker error:`, err);
+  });
 }, "createWorker");
-var xl1TransactionMonitor = {
+var Xl1TransactionMonitor = {
   createWorker: createWorker5,
   name: name5,
   queueName: queueName5
 };
 
-// src/queue/workers/xl1TransactionPreparation.ts
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+// src/queue/workers/Xl1TransactionPreparation.ts
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
 import { Worker as Worker6 } from "bullmq";
 var name6 = "Prepare XL1 Transaction";
 var queueName6 = "xl1-tx-prepare";
-var createWorker6 = /* @__PURE__ */ __name((connection2) => {
-  new Worker6(queueName6, async (job) => {
-    const { tx, xl1TxStateMap: stateMap } = job.data;
-    const hash = await PayloadBuilder5.hash(tx[0]);
+var createWorker6 = /* @__PURE__ */ __name((connection2, services) => {
+  const stateMap = assertEx6(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const worker = new Worker6(queueName6, async (job) => {
+    const { tx } = job.data;
+    const hash = await PayloadBuilder6.hash(tx[0]);
     await job.log(`[${hash}] preparing XL1 transaction`);
     const preparedTx = tx;
     await job.log(`[${hash}] storing XL1 preparedTx`);
@@ -223,25 +304,33 @@ var createWorker6 = /* @__PURE__ */ __name((connection2) => {
   }, {
     connection: connection2
   });
+  worker.on("failed", (job, err) => {
+    console.error(`[${name6}] Job ${job?.id} failed:`, err.message);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name6}] Worker error:`, err);
+  });
 }, "createWorker");
-var xl1TransactionPreparation = {
+var Xl1TransactionPreparation = {
   createWorker: createWorker6,
   name: name6,
   queueName: queueName6
 };
 
-// src/queue/workers/xl1TransactionSubmission.ts
-import { assertEx as assertEx5, isDefined as isDefined5 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+// 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 { Worker as Worker7 } from "bullmq";
 var name7 = "Submit XL1 Transaction";
 var queueName7 = "xl1-tx-submit";
-var createWorker7 = /* @__PURE__ */ __name((connection2) => {
-  new Worker7(queueName7, async (job) => {
-    const { gateway, tx, xl1TxStateMap: stateMap } = job.data;
-    const hash = await PayloadBuilder6.hash(tx[0]);
-    const state = assertEx5(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const preparedTx = assertEx5(state?.preparedTx, () => `[${hash}] preparedTx not found`);
+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 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 { submissionHash: existingSubmissionHash } = state;
     if (isDefined5(existingSubmissionHash)) {
       await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
@@ -250,8 +339,7 @@ var createWorker7 = /* @__PURE__ */ __name((connection2) => {
       };
     }
     await job.log(`[${hash}] Submitting XL1 tx`);
-    const [submissionHash] = await gateway.addTransactionToChain(preparedTx);
-    assertEx5(submissionHash === hash, () => `[${hash}] Submitted transaction hash ${submissionHash} does not match expected hash`);
+    const [submissionHash] = await submitXl1Transaction(preparedTx, gateway);
     await job.log(`[${hash}] Submitted XL1 tx`);
     await job.log(`[${hash}] Storing XL1 submissionHash`);
     state.submissionHash = submissionHash;
@@ -263,8 +351,14 @@ var createWorker7 = /* @__PURE__ */ __name((connection2) => {
   }, {
     connection: connection2
   });
+  worker.on("failed", (job, err) => {
+    console.error(`[${name7}] Job ${job?.id} failed:`, err.message);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name7}] Worker error:`, err);
+  });
 }, "createWorker");
-var xl1TransactionSubmission = {
+var Xl1TransactionSubmission = {
   createWorker: createWorker7,
   name: name7,
   queueName: queueName7
@@ -273,66 +367,72 @@ var xl1TransactionSubmission = {
 // src/queue/flows/createXl1ToEthBridgeJob.ts
 var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) => {
   const flow = await flowProducer2.add({
-    name: xl1ToEthBridgeParent.name,
-    queueName: xl1ToEthBridgeParent.queueName,
+    name: Xl1ToEthBridgeParent.name,
+    queueName: Xl1ToEthBridgeParent.queueName,
     data: {
       tx
     },
     children: [
       {
-        name: xl1TransactionPreparation.name,
-        queueName: xl1TransactionPreparation.queueName,
+        // Step 6 (runs after child completes)
+        name: EthTransactionMonitor.name,
+        queueName: EthTransactionMonitor.queueName,
         data: {
           tx
         },
+        opts: {
+          attempts: 60,
+          backoff: {
+            type: "fixed",
+            delay: 5e3
+          }
+        },
         children: [
           {
-            name: xl1TransactionSubmission.name,
-            queueName: xl1TransactionSubmission.queueName,
+            // Step 5
+            name: EthTransactionSubmission.name,
+            queueName: EthTransactionSubmission.queueName,
             data: {
               tx
             },
             children: [
               {
-                name: xl1TransactionMonitor.name,
-                queueName: xl1TransactionMonitor.queueName,
+                // Step 4
+                name: EthTransactionPreparation.name,
+                queueName: EthTransactionPreparation.queueName,
                 data: {
                   tx
                 },
-                opts: {
-                  attempts: 60,
-                  backoff: {
-                    type: "fixed",
-                    delay: 5e3
-                  }
-                },
                 children: [
                   {
-                    name: ethTransactionPreparation.name,
-                    queueName: ethTransactionPreparation.queueName,
+                    // Step 3
+                    name: Xl1TransactionMonitor.name,
+                    queueName: Xl1TransactionMonitor.queueName,
                     data: {
                       tx
                     },
+                    opts: {
+                      attempts: 60,
+                      backoff: {
+                        type: "fixed",
+                        delay: 5e3
+                      }
+                    },
                     children: [
                       {
-                        name: ethTransactionSubmission.name,
-                        queueName: ethTransactionSubmission.queueName,
+                        // Step 2
+                        name: Xl1TransactionSubmission.name,
+                        queueName: Xl1TransactionSubmission.queueName,
                         data: {
                           tx
                         },
                         children: [
                           {
-                            name: ethTransactionMonitor.name,
-                            queueName: ethTransactionMonitor.queueName,
+                            // Step 1 (runs first as deepest child)
+                            name: Xl1TransactionPreparation.name,
+                            queueName: Xl1TransactionPreparation.queueName,
                             data: {
                               tx
-                            },
-                            opts: {
-                              attempts: 60,
-                              backoff: {
-                                type: "fixed",
-                                delay: 5e3
-                              }
                             }
                           }
                         ]
@@ -350,7 +450,7 @@ var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) =
   return flow;
 }, "createXl1ToEthBridgeJob");
 
-// src/server/flowProducer.ts
+// src/server/addFlowProducer.ts
 var addFlowProducer = /* @__PURE__ */ __name((app, config) => {
   const connection2 = getConnection(config);
   const flowProducer2 = getFlowProducer(connection2);
@@ -391,22 +491,22 @@ var asToken = /* @__PURE__ */ __name((value) => {
 }, "asToken");
 
 // src/config/getBridgeEscrowAddress.ts
-import { asAddress as asAddress2, assertEx as assertEx6 } from "@xylabs/sdk-js";
+import { asAddress as asAddress2, assertEx as assertEx8 } from "@xylabs/sdk-js";
 var tryGetBridgeEscrowAddress = /* @__PURE__ */ __name((config) => {
-  const address = asAddress2(config.bridge.escrowAddress);
+  const address = asAddress2(config.actors.bridge.escrowAddress);
   return address;
 }, "tryGetBridgeEscrowAddress");
 
 // src/config/getBridgeFeesAddress.ts
-import { asAddress as asAddress3, assertEx as assertEx7 } from "@xylabs/sdk-js";
+import { asAddress as asAddress3, assertEx as assertEx9 } from "@xylabs/sdk-js";
 var tryGetBridgeFeesAddress = /* @__PURE__ */ __name((config) => {
-  const address = asAddress3(config.bridge.feesAddress);
+  const address = asAddress3(config.actors.bridge.feesAddress);
   return address;
 }, "tryGetBridgeFeesAddress");
 
 // src/config/getFeeStructure.ts
 var getFeeStructure = /* @__PURE__ */ __name((config) => {
-  const { feeFixed, feeRateBasisPoints } = config.bridge;
+  const { feeFixed, feeRateBasisPoints } = config.actors.bridge;
   return {
     feeFixed,
     feeRateBasisPoints
@@ -415,28 +515,28 @@ var getFeeStructure = /* @__PURE__ */ __name((config) => {
 
 // src/config/getMaxBridgeAmount.ts
 var getMaxBridgeAmount = /* @__PURE__ */ __name((config) => {
-  const { maxBridgeAmount } = config.bridge;
+  const { maxBridgeAmount } = config.actors.bridge;
   return maxBridgeAmount;
 }, "getMaxBridgeAmount");
 
 // src/config/getMinBridgeAmount.ts
 var getMinBridgeAmount = /* @__PURE__ */ __name((config) => {
-  const { minBridgeAmount } = config.bridge;
+  const { minBridgeAmount } = config.actors.bridge;
   return minBridgeAmount;
 }, "getMinBridgeAmount");
 
 // src/config/getRemoteChainId.ts
-import { assertEx as assertEx8 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10 } from "@xylabs/sdk-js";
 var getRemoteChainId = /* @__PURE__ */ __name((config) => {
-  const remoteChainId = assertEx8(asChainId(config.bridge.remoteChainId), () => "Invalid remote chain ID in config");
+  const remoteChainId = assertEx10(asChainId(config.actors.bridge.remoteChainId), () => "Invalid remote chain ID in config");
   return remoteChainId;
 }, "getRemoteChainId");
 
 // src/config/getRemoteTokenAddress.ts
-import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11 } from "@xylabs/sdk-js";
 var getRemoteTokenAddress = /* @__PURE__ */ __name((config) => {
-  const token = asToken(config.bridge.remoteTokenAddress);
-  return assertEx9(token, () => "Remote token address is not defined in bridge configuration");
+  const token = asToken(config.actors.bridge.remoteTokenAddress);
+  return assertEx11(token, () => "Remote token address is not defined in bridge configuration");
 }, "getRemoteTokenAddress");
 
 // src/config/getBridgeWalletAccount.ts
@@ -446,7 +546,7 @@ import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1
 var accountServiceSingleton;
 var getBridgeWalletAccount = /* @__PURE__ */ __name(async (config) => {
   if (accountServiceSingleton) return accountServiceSingleton;
-  let walletPhrase = config.bridge.mnemonic;
+  let walletPhrase = config.actors.bridge.mnemonic;
   if (isUndefined(walletPhrase)) {
     console.log("[Bridge] No wallet mnemonic specified!");
     const randomMnemonic = HDWallet.generateMnemonic();
@@ -474,19 +574,19 @@ var getTransferAddresses = /* @__PURE__ */ __name(async (config) => {
 }, "getTransferAddresses");
 
 // src/config/getXl1ChainId.ts
-import { assertEx as assertEx10, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { assertEx as assertEx12, isDefined as isDefined7 } from "@xylabs/sdk-js";
 var getXl1ChainId = /* @__PURE__ */ __name((config) => {
-  const xl1ChainId = config.bridge.xl1ChainId;
+  const xl1ChainId = config.actors.bridge.xl1ChainId;
   if (isDefined7(xl1ChainId)) {
-    return assertEx10(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
+    return assertEx12(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
   }
-  return assertEx10(asChainId(config.chain.id), () => "Invalid chain.id in config");
+  return assertEx12(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.bridge.xl1TokenAddress);
+  const token = asToken(config.actors.bridge.xl1TokenAddress);
   if (isDefined8(token)) return token;
   return getXl1ChainId(config);
 }, "getXl1TokenAddress");
@@ -518,28 +618,26 @@ var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
 // src/config/getGateway.ts
 import { isDefined as isDefined9 } from "@xylabs/sdk-js";
 import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
-import { buildJsonRpcProviderLocator, HttpRpcTransport, SimpleXyoGatewayRunner, SimpleXyoSigner, XyoGatewayRunnerMoniker } from "@xyo-network/xl1-sdk";
+import { ADDRESS_INDEX as ADDRESS_INDEX2, buildJsonRpcProviderLocator, generateXyoBaseWalletFromPhrase as generateXyoBaseWalletFromPhrase2, HttpRpcTransport, XyoGatewayRunnerMoniker } from "@xyo-network/xl1-sdk";
 var gatewayInstance;
 var getGateway = /* @__PURE__ */ __name(async (config) => {
   if (isDefined9(gatewayInstance)) return gatewayInstance;
-  const { mnemonic, chainRpcApiUrl: endpoint } = config.bridge;
-  const walletPromise = isDefined9(mnemonic) ? HDWallet2.fromPhrase(mnemonic) : HDWallet2.random();
-  const account = await walletPromise;
+  const { mnemonic, chainRpcApiUrl: endpoint } = config.actors.bridge;
+  const walletPhrase = isDefined9(mnemonic) ? mnemonic : HDWallet2.generateMnemonic();
+  const wallet = await generateXyoBaseWalletFromPhrase2(walletPhrase);
+  const signerAccount = await wallet.derivePath(ADDRESS_INDEX2.XYO);
   const transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport(endpoint, schemas), "transportFactory");
   const locator = await buildJsonRpcProviderLocator({
-    transportFactory
+    transportFactory,
+    signerAccount
   });
-  locator.register(SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, {
-    account
-  }));
-  locator.register(SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies));
   return await locator.getInstance(XyoGatewayRunnerMoniker);
 }, "getGateway");
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts
-var response = BridgeSettingsZod;
+var BridgeConfigResponseZod = BridgeSettingsZod;
 var validateRequest = requestHandlerValidator({
-  response
+  response: BridgeConfigResponseZod
 });
 var makeBridgeConfigRoute = /* @__PURE__ */ __name((config) => {
   return {
@@ -593,10 +691,10 @@ var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
     chainId: getRemoteChainIdZod(config),
     nonce: z.string().nonempty()
   });
-  const response2 = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape);
+  const response = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape);
   const validateRequest2 = requestHandlerValidator2({
     params,
-    response: response2
+    response
   });
   return {
     method: "get",
@@ -627,17 +725,17 @@ var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
 import { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
-import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
-import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/payload-model";
+import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/payload-builder";
+import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/payload-model";
 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 hexToBigInt2, toHex as toHex2 } from "@xylabs/sdk-js";
+import { hexToBigInt as hexToBigInt3, toHex as toHex2 } from "@xylabs/sdk-js";
 var calculateBridgeFees = /* @__PURE__ */ __name((srcAmount, feeStructure) => {
   const { feeFixed, feeRateBasisPoints } = feeStructure;
-  const srcAmountBigInt = hexToBigInt2(srcAmount);
-  const feeFixedBigInt = hexToBigInt2(feeFixed);
+  const srcAmountBigInt = hexToBigInt3(srcAmount);
+  const feeFixedBigInt = hexToBigInt3(feeFixed);
   const feeVariableBigInt = srcAmountBigInt * BigInt(feeRateBasisPoints) / 10000n;
   const feeVariable = toHex2(feeVariableBigInt);
   const feeTotalBigInt = feeFixedBigInt + feeVariableBigInt;
@@ -651,8 +749,8 @@ var calculateBridgeFees = /* @__PURE__ */ __name((srcAmount, feeStructure) => {
 }, "calculateBridgeFees");
 
 // src/util/generateBridgeEstimate.ts
-import { hexToBigInt as hexToBigInt3, toAddress as toAddress2 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
+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 { v4 } from "uuid";
 var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount, destAddress, config, nonceOverride) => {
@@ -677,7 +775,7 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
     destToken: remoteTokenAddress,
     nonce
   };
-  const bridgeIntent = new PayloadBuilder7({
+  const bridgeIntent = new PayloadBuilder8({
     schema: BridgeIntentSchema
   }).fields(bridgeIntentFields).build();
   const context = {
@@ -686,8 +784,8 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
     feeVariable
   };
   const transfer = createTransferPayload(sender, {
-    [escrowAddress]: hexToBigInt3(destAmount),
-    [feesAddress]: hexToBigInt3(feeFixedAmount) + hexToBigInt3(feeVariable)
+    [escrowAddress]: hexToBigInt4(destAmount),
+    [feesAddress]: hexToBigInt4(feeFixedAmount) + hexToBigInt4(feeVariable)
   }, context);
   return [
     bridgeIntent,
@@ -697,24 +795,24 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
 
 // src/util/validateBridgeEstimateExact.ts
 import { isUndefined as isUndefined3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder9 } 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 PayloadBuilder8.dataHash(expectedIntentStatic) !== await PayloadBuilder8.dataHash(actualIntentStatic)) return false;
+  if (await PayloadBuilder9.dataHash(expectedIntentStatic) !== await PayloadBuilder9.dataHash(actualIntentStatic)) return false;
   const { epoch: expectedTransferEpoch, ...expectedTransferStatic } = calculatedTransfer;
   const { epoch: actualTransferEpoch, ...actualTransferStatic } = transfer;
-  if (await PayloadBuilder8.dataHash(expectedTransferStatic) !== await PayloadBuilder8.dataHash(actualTransferStatic)) return false;
+  if (await PayloadBuilder9.dataHash(expectedTransferStatic) !== await PayloadBuilder9.dataHash(actualTransferStatic)) return false;
   return true;
 }, "validateBridgeEstimateExact");
 
 // src/util/validateBridgeTransaction.ts
 import { asAddress as asAddress4, isDefined as isDefined10 } from "@xylabs/sdk-js";
 import { addressesContains, BoundWitnessValidator, payloadHashesContainsAll } from "@xyo-network/boundwitness-validator";
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
 var validateBridgeTransaction = /* @__PURE__ */ __name(async (signedTxBw, intent, transfer, config) => {
   const { srcAddress } = intent;
   const chainId = getXl1ChainId(config);
@@ -723,7 +821,7 @@ var validateBridgeTransaction = /* @__PURE__ */ __name(async (signedTxBw, intent
   if (isDefined10(errors) && errors.length > 0) return false;
   const sender = asAddress4(srcAddress, true);
   if (!addressesContains(signedTxBw, sender)) return false;
-  const hashes = await PayloadBuilder9.hashes([
+  const hashes = await PayloadBuilder10.hashes([
     intent,
     transfer
   ]);
@@ -732,20 +830,20 @@ var validateBridgeTransaction = /* @__PURE__ */ __name(async (signedTxBw, intent
 }, "validateBridgeTransaction");
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
+var BridgeToRemoteBodyZod = z2.tuple([
+  SignedTransactionBoundWitnessZod,
+  PayloadZodLooseOfSchema(BridgeIntentSchema2).extend(BridgeIntentFieldsZod.shape),
+  TransferZod
+]);
+var BridgeToRemoteResponseZod = PayloadZodStrictOfSchema2(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape);
 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
+    body: BridgeToRemoteBodyZod,
+    response: BridgeToRemoteResponseZod
   });
   return {
     method: "post",
@@ -771,14 +869,14 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
         ]
       ];
       await createXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction);
-      const srcConfirmation = await PayloadBuilder10.hash(signedTxBw);
+      const srcConfirmation = await PayloadBuilder11.hash(signedTxBw);
       const bridgeCommonFieldsZod = z2.object({}).extend(BridgeSourceObservationFieldsZod.shape);
       const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent);
       const bridgeObservationFields = {
         ...bridgeCommonFields,
         srcConfirmation
       };
-      const bridgeObservation = new PayloadBuilder10({
+      const bridgeObservation = new PayloadBuilder11({
         schema: BridgeSourceObservationSchema
       }).fields(bridgeObservationFields).build();
       res.json(bridgeObservation);
@@ -788,29 +886,29 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
 import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
-import { assertEx as assertEx11, toAddress as toAddress3 } from "@xylabs/sdk-js";
-import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3 } from "@xyo-network/payload-model";
-import { buildUnsignedTransaction } from "@xyo-network/xl1-sdk";
-import { BridgeIntentFieldsZod as BridgeIntentFieldsZod2, BridgeIntentSchema as BridgeIntentSchema3, toXL1BlockNumber, TransactionBoundWitnessZod, TransferSchema } from "@xyo-network/xl1-sdk";
+import { assertEx as assertEx13, toAddress as toAddress3 } from "@xylabs/sdk-js";
+import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3 } from "@xyo-network/payload-model";
+import { buildUnsignedTransaction, TransferZod as TransferZod2 } from "@xyo-network/xl1-sdk";
+import { BridgeIntentFieldsZod as BridgeIntentFieldsZod2, BridgeIntentSchema as BridgeIntentSchema3, toXL1BlockNumber, TransactionBoundWitnessZod } from "@xyo-network/xl1-sdk";
 import { z as z3 } from "zod";
+var BridgeToRemoteEstimateBodyZod = BridgeIntentFieldsZod2.pick({
+  destAddress: true,
+  srcAddress: true,
+  srcAmount: true
+});
+var BridgeToRemoteEstimateResponseZod = z3.tuple([
+  TransactionBoundWitnessZod,
+  PayloadZodStrictOfSchema3(BridgeIntentSchema3).extend(BridgeIntentFieldsZod2.shape),
+  TransferZod2
+]);
 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
+    body: BridgeToRemoteEstimateBodyZod,
+    response: BridgeToRemoteEstimateResponseZod
   });
   return {
     method: "post",
@@ -821,7 +919,7 @@ var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config) => {
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
       const sender = toAddress3(srcAddress);
       const gateway = await getGateway(config);
-      const viewer = assertEx11(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const viewer = assertEx13(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);
@@ -845,6 +943,21 @@ import { asAddress as asAddress5, asHex as asHex3, toHex as toHex3 } from "@xyla
 import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema4 } from "@xyo-network/payload-model";
 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([
+  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)
+  ])
+]);
 var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
   const params = z4.object({
     chainId: getRemoteChainIdZod(config),
@@ -853,25 +966,10 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
   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
+    response: BridgeToRemoteStatusResponseZod
   });
   return {
     method: "get",
@@ -976,18 +1074,18 @@ var getApp = /* @__PURE__ */ __name((node, config) => {
 }, "getApp");
 
 // src/server/server.ts
-import { assertEx as assertEx16, isDefined as isDefined15, isString } from "@xylabs/sdk-js";
+import { assertEx as assertEx18, isDefined as isDefined15, isString } from "@xylabs/sdk-js";
 import { boot } from "@xyo-network/bios";
 import { HDWallet as HDWallet4 } from "@xyo-network/wallet";
 
 // src/manifest/getModuleLocator.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx14, isDefined as isDefined13 } from "@xylabs/sdk-js";
+import { assertEx as assertEx16, isDefined as isDefined13 } 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 { 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";
@@ -995,12 +1093,12 @@ import { MemorySentinel } from "@xyo-network/sentinel-memory";
 import { hasMongoConfig, mapToMapType, XyoGatewayRunnerMoniker as XyoGatewayRunnerMoniker2 } from "@xyo-network/xl1-sdk";
 
 // src/modules/EVMLiquidityBridgeTransactionCompletionMonitorSentinel/EVMLiquidityBridgeTransactionCompletionMonitorSentinel.ts
-import { asAddress as asAddress6, asHex as asHex4, assertEx as assertEx12, delay, hexFromBigInt, hexToBigInt as hexToBigInt4, isDefined as isDefined11, isUndefined as isUndefined4 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/payload-builder";
+import { asAddress as asAddress6, asHex as asHex4, assertEx as assertEx14, delay, hexFromBigInt, hexToBigInt as hexToBigInt5, isDefined as isDefined11, 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 isBridgeIntent2, tryUnflattenHydratedTransaction } from "@xyo-network/xl1-sdk";
+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";
@@ -1025,19 +1123,19 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
   _successCounter;
   _wallet;
   get bridge() {
-    return assertEx12(this._bridge, () => new Error("Bridge contract not initialized"));
+    return assertEx14(this._bridge, () => new Error("Bridge contract not initialized"));
   }
   get completedTransactions() {
-    return assertEx12(this.params.completedTransactions, () => "Completed transactions map is not defined");
+    return assertEx14(this.params.completedTransactions, () => "Completed transactions map is not defined");
   }
   get jobCheckInterval() {
     return isDefined11(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs;
   }
   get pendingTransactions() {
-    return assertEx12(this.params.pendingTransactions, () => "Pending transactions map is not defined");
+    return assertEx14(this.params.pendingTransactions, () => "Pending transactions map is not defined");
   }
   get wallet() {
-    return assertEx12(this._wallet, () => "wallet is required");
+    return assertEx14(this._wallet, () => "wallet is required");
   }
   async createHandler() {
     await super.createHandler();
@@ -1054,11 +1152,11 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
       description: "Number of errors"
     });
     const { provider, bridgeAddress } = this.params;
-    const key = assertEx12(this.account?.private?.hex, () => new Error("Account private key is required"));
+    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 = assertEx12(hexFromBigInt(network.chainId), () => new Error("Failed to parse bridgeChainId"));
+    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();
@@ -1068,7 +1166,7 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
     if (isDefined11(payloads) && payloads.length > 0) {
       const signedHydratedTransaction = tryUnflattenHydratedTransaction(payloads);
       if (isDefined11(signedHydratedTransaction)) {
-        const txHash = await PayloadBuilder11.hash(signedHydratedTransaction[0]);
+        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);
@@ -1080,11 +1178,11 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
         return [];
       }
       return await this._reportMutex.runExclusive(async () => {
-        const response2 = [];
+        const response = [];
         if (isUndefined4(payloads) || payloads.length === 0) {
           await this.processAllTransactions();
         }
-        return response2;
+        return response;
       });
     }
   }
@@ -1105,7 +1203,7 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
     try {
       let ret = void 0;
       this._checkCounter?.add(1);
-      const bridgeIntents = signedHydratedTransaction[1].filter(isBridgeIntent2);
+      const bridgeIntents = signedHydratedTransaction[1].filter(isBridgeIntent3);
       if (bridgeIntents.length !== 1) {
         await this.pendingTransactions.delete(hash);
         return ret;
@@ -1128,7 +1226,7 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
   * @returns Relays the intent in a blocking manner, returning the resulting BridgeDestinationObservation if successful
   */
   async relayBridgeIntentSync(bridgeIntent) {
-    const amount = hexToBigInt4(bridgeIntent.destAmount);
+    const amount = hexToBigInt5(bridgeIntent.destAmount);
     const nonce = await this.wallet.getNonce();
     const srcAddress = getAddress2(bridgeIntent.srcAddress);
     const destAddress = getAddress2(bridgeIntent.destAddress);
@@ -1137,7 +1235,7 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
     const transactionResponse = await confirmation?.getTransaction();
     const destConfirmation = asHex4(transactionResponse?.hash ?? "", true);
     const { schema, ...rest } = bridgeIntent;
-    const result = new PayloadBuilder11({
+    const result = new PayloadBuilder12({
       schema: BridgeDestinationObservationSchema3
     }).fields({
       ...rest,
@@ -1148,8 +1246,8 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
 };
 
 // src/modules/XL1TransactionCompletionMonitorSentinel/XL1TransactionCompletionMonitorSentinel.ts
-import { assertEx as assertEx13, delay as delay2, isDefined as isDefined12, isNull as isNull2, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/payload-builder";
+import { assertEx as assertEx15, delay as delay2, isDefined as isDefined12, 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";
@@ -1170,16 +1268,16 @@ var XL1TransactionCompletionMonitorSentinel = class extends AbstractSentinel2 {
   _reportMutex = new Mutex2();
   _successCounter;
   get completedTransactions() {
-    return assertEx13(this.params.completedTransactions, () => "Completed transactions map is not defined");
+    return assertEx15(this.params.completedTransactions, () => "Completed transactions map is not defined");
   }
   get jobCheckInterval() {
     return isDefined12(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs2;
   }
   get pendingTransactions() {
-    return assertEx13(this.params.pendingTransactions, () => "Pending transactions map is not defined");
+    return assertEx15(this.params.pendingTransactions, () => "Pending transactions map is not defined");
   }
   get viewer() {
-    return assertEx13(this.params.viewer, () => "Viewer is not defined in params");
+    return assertEx15(this.params.viewer, () => "Viewer is not defined in params");
   }
   async createHandler() {
     await super.createHandler();
@@ -1200,7 +1298,7 @@ var XL1TransactionCompletionMonitorSentinel = class extends AbstractSentinel2 {
     if (isDefined12(payloads) && payloads.length > 0) {
       const signedHydratedTransaction = tryUnflattenHydratedTransaction2(payloads);
       if (isDefined12(signedHydratedTransaction)) {
-        const txHash = await PayloadBuilder12.hash(signedHydratedTransaction[0]);
+        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);
@@ -1212,11 +1310,11 @@ var XL1TransactionCompletionMonitorSentinel = class extends AbstractSentinel2 {
         return [];
       }
       return await this._reportMutex.runExclusive(async () => {
-        const response2 = [];
+        const response = [];
         if (isUndefined5(payloads) || payloads.length === 0) {
           await this.processAllTransactions();
         }
-        return response2;
+        return response;
       });
     }
   }
@@ -1317,7 +1415,7 @@ var getModuleLocator = /* @__PURE__ */ __name(async (context) => {
     statusReporter
   }));
   const gateway = await locator.getInstance(XyoGatewayRunnerMoniker2);
-  const viewer = assertEx14(gateway.connection.viewer, () => "Gateway viewer is not defined");
+  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 = {
@@ -1336,7 +1434,7 @@ var getModuleLocator = /* @__PURE__ */ __name(async (context) => {
   const provider = await initEvmProvider({
     config
   });
-  const bridgeAddress = config.bridge.remoteBridgeContractAddress;
+  const bridgeAddress = config.actors.bridge.remoteBridgeContractAddress;
   const evmLiquidityBridgeTransactionCompletionMonitorSentinelParams = {
     bridgeAddress,
     completedTransactions: completedEthXl1BridgeTransactions,
@@ -1406,130 +1504,21 @@ var node_default = {
 // 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 { chainRpcApiUrl: endpoint } = context.config.bridge;
+  const { config, wallet } = context;
+  const { chainRpcApiUrl: endpoint } = config.actors.bridge;
   const transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport2(endpoint, schemas), "transportFactory");
+  const signerAccount = await getBridgeWalletAccount(config);
   const locator = await buildJsonRpcProviderLocator2({
+    signerAccount,
     transportFactory
   });
   const moduleLocator = await getModuleLocator({
     ...context,
     locator
   });
-  const wrapper = new ManifestWrapper(NodeManifest, wallet, moduleLocator, PublicChildManifests, PrivateChildManifests);
+  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)));
@@ -1539,38 +1528,16 @@ var getNode = /* @__PURE__ */ __name(async (context) => {
 }, "getNode");
 
 // src/manifest/getServices.ts
+import { assertEx as assertEx17, isDefined as isDefined14 } 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 HDWallet3 } 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 { assertEx as assertEx15, isDefined as isDefined14 } from "@xylabs/sdk-js";
 import { MongoMap as MongoMap2 } from "@xyo-network/chain-protocol";
-import { initEvmProvider as initEvmProvider2 } from "@xyo-network/chain-services";
-import { LiquidityPoolBridge__factory as LiquidityPoolBridge__factory2 } from "@xyo-network/typechain";
-import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
 import { hasMongoConfig as hasMongoConfig2, mapToMapType as mapToMapType2 } from "@xyo-network/xl1-sdk";
-import { getAddress as getAddress3, Wallet as Wallet2 } from "ethers";
-var getServices = /* @__PURE__ */ __name(async (context) => {
-  const { config } = context;
-  const gateway = await getGateway(config);
-  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, mnemonic } = config.bridge;
-  const account = isDefined14(mnemonic) ? await HDWallet3.fromPhrase(mnemonic) : await HDWallet3.random();
-  const wallet = new Wallet2(remoteChainWalletPrivateKey, provider);
-  const bridge = LiquidityPoolBridge__factory2.connect(getAddress3(remoteBridgeContractAddress), wallet);
-  const bridgeOwner = await bridge.owner();
-  assertEx15(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
-  return {
-    account,
-    bridge,
-    ethTxStateMap,
-    gateway,
-    provider,
-    wallet,
-    xl1TxStateMap
-  };
-}, "getServices");
 var getIterableMap2 = /* @__PURE__ */ __name(async (config, collection) => {
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig2(mongoConfig)) {
@@ -1599,12 +1566,46 @@ var getIterableMap2 = /* @__PURE__ */ __name(async (config, collection) => {
   }
 }, "getIterableMap");
 
+// src/manifest/getServices.ts
+var getServices = /* @__PURE__ */ __name(async (context) => {
+  const { config } = context;
+  const gateway = await getGateway(config);
+  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 = isDefined14(mnemonic) ? await HDWallet3.fromPhrase(mnemonic) : await HDWallet3.random();
+  const wallet = new Wallet2(remoteChainWalletPrivateKey, provider);
+  const bridgeableToken = BridgeableToken__factory.connect(getAddress3(remoteTokenAddress), wallet);
+  const bridge = LiquidityPoolBridge__factory2.connect(getAddress3(remoteBridgeContractAddress), wallet);
+  const bridgeOwner = await bridge.owner();
+  assertEx17(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
+  return {
+    account,
+    bridge,
+    bridgeableToken,
+    ethTxStateMap,
+    gateway,
+    provider,
+    wallet,
+    xl1TxStateMap
+  };
+}, "getServices");
+
+// src/server/addWorkers.ts
+var addWorkers = /* @__PURE__ */ __name((config, services) => {
+  const connection2 = getConnection(config);
+  createWorkers(connection2, services);
+}, "addWorkers");
+
 // 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;
+  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);
@@ -1619,11 +1620,11 @@ var getSeedPhrase = /* @__PURE__ */ __name(async (bios, config, logger) => {
     }
     await bios.seedPhraseStore.set("os", seedPhrase);
   }
-  return assertEx16(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+  return assertEx18(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
 }, "getSeedPhrase");
 var getServer = /* @__PURE__ */ __name(async (context) => {
   const { logger, config } = context;
-  const { port, mnemonic } = config.bridge;
+  const { port, mnemonic } = config.actors.bridge;
   const bios = await boot();
   const seedPhrase = isDefined15(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
   const wallet = await HDWallet4.fromPhrase(seedPhrase);
@@ -1634,10 +1635,11 @@ var getServer = /* @__PURE__ */ __name(async (context) => {
   };
   const node = context.node ?? await getNode(nodeContext);
   const app = getApp(node, config);
-  app.services = await getServices({
+  const services = await getServices({
     config,
     logger
   });
+  addWorkers(config, services);
   const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`));
   server.setTimeout(2e4);
   return server;