@xyo-network/chain-bridge 1.17.7 → 1.18.0

package/dist/node/index.mjs

@@ -7,6 +7,357 @@ import compression from "compression";
 import cors from "cors";
 import express from "express";
 
+// src/queue/connection.ts
+import { isDefined } from "@xylabs/sdk-js";
+import { Redis } from "ioredis";
+var connection;
+var maxRetriesPerRequest = null;
+var getConnection = /* @__PURE__ */ __name((config) => {
+  if (isDefined(connection)) return connection;
+  const { redisHost: host, redisPort: port } = config.bridge;
+  connection = new Redis({
+    host,
+    port,
+    maxRetriesPerRequest
+  });
+  return connection;
+}, "getConnection");
+
+// src/queue/flowProducer.ts
+import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { FlowProducer } from "bullmq";
+var flowProducer;
+var getFlowProducer = /* @__PURE__ */ __name((connection2) => {
+  if (isDefined2(flowProducer)) return flowProducer;
+  flowProducer = new FlowProducer({
+    connection: connection2
+  });
+  return flowProducer;
+}, "getFlowProducer");
+
+// 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;
+    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");
+    const receipt = assertEx(await provider.getTransactionReceipt(submissionHash), () => "Transaction receipt not found");
+    await job.log(`[${hash}] confirmed ETH tx ${submissionHash} in block ${receipt.blockNumber}`);
+    const { blockHash, blockNumber } = receipt;
+    state.confirmationHash = blockHash;
+    await stateMap.set(hash, state);
+    return {
+      blockHash,
+      blockNumber
+    };
+  }, {
+    connection: connection2
+  });
+}, "createWorker");
+var ethTransactionMonitor = {
+  createWorker,
+  name,
+  queueName
+};
+
+// 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-protocol";
+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;
+    const hash = await PayloadBuilder2.hash(tx[0]);
+    await job.log(`[${hash}] preparing ETH transaction`);
+    await job.log(`[${hash}] building ETH transaction`);
+    const bridgeIntent = assertEx2(tx[1].find(isBridgeIntent), () => "No bridge intent found");
+    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);
+    await job.log(`[${hash}] built ETH transaction`);
+    await job.log(`[${hash}] storing ETH preparedTx`);
+    await stateMap.set(hash, {
+      preparedTx
+    });
+    await job.log(`[${hash}] stored ETH preparedTx`);
+    await job.log(`[${hash}] prepared ETH transaction`);
+    return {};
+  }, {
+    connection: connection2
+  });
+}, "createWorker");
+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";
+import { Worker as Worker3 } from "bullmq";
+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`);
+    const { submissionHash: existingSubmissionHash } = state;
+    if (isDefined3(existingSubmissionHash)) {
+      await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
+      return {
+        submissionHash: existingSubmissionHash
+      };
+    }
+    await job.log(`[${hash}] Submitting ETH tx`);
+    const submissionResponse = await wallet.sendTransaction(preparedTx);
+    const submissionHash = submissionResponse.hash;
+    await job.log(`[${hash}] Submitted ETH tx and received submission response hash ${submissionHash}`);
+    await job.log(`[${hash}] Storing ETH submissionHash`);
+    state.submissionHash = submissionHash;
+    await stateMap.set(hash, state);
+    await job.log(`[${hash}] Stored ETH submissionHash`);
+    return {
+      submissionHash
+    };
+  }, {
+    connection: connection2,
+    concurrency: 1
+  });
+}, "createWorker");
+var ethTransactionSubmission = {
+  createWorker: createWorker3,
+  name: name3,
+  queueName: queueName3
+};
+
+// 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) => {
+    await job.log(`[${job.name}] start`);
+    await job.log(`[${job.name}] done`);
+    return {
+      ok: true
+    };
+  }, {
+    connection: connection2
+  });
+}, "createWorker");
+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";
+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.connectionInstance.viewer, () => `[${hash}] viewer not defined on gateway`);
+    const state = assertEx4(await stateMap.get(hash), () => `[${hash}] state not found`);
+    await job.log(`[${hash}] Checking for XL1 transaction inclusion on chain`);
+    const foundTx = await viewer.transactionByHash(hash);
+    if (isDefined4(foundTx) && !isNull(foundTx)) {
+      await job.log(`[${hash}] Found transaction on chain`);
+      state.confirmationHash = hash;
+      await stateMap.set(hash, state);
+      return {};
+    }
+    const currentBlockNumber = await viewer.currentBlockNumber();
+    if (tx[0].exp < currentBlockNumber) {
+      await job.log(`[${hash}] Transaction expired at block ${tx[0].exp}, current block ${currentBlockNumber}`);
+      throw new UnrecoverableError(`[${hash}] Transaction expired and will never be included`);
+    }
+    await job.log(`[${hash}] Transaction not yet included, retrying later`);
+    throw new Error(`[${hash}] Transaction not yet included`);
+  }, {
+    connection: connection2
+  });
+}, "createWorker");
+var xl1TransactionMonitor = {
+  createWorker: createWorker5,
+  name: name5,
+  queueName: queueName5
+};
+
+// src/queue/workers/xl1TransactionPreparation.ts
+import { PayloadBuilder as PayloadBuilder5 } 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]);
+    await job.log(`[${hash}] preparing XL1 transaction`);
+    const preparedTx = tx;
+    await job.log(`[${hash}] storing XL1 preparedTx`);
+    await stateMap.set(hash, {
+      preparedTx
+    });
+    await job.log(`[${hash}] stored XL1 preparedTx`);
+    await job.log(`[${hash}] prepared XL1 transaction`);
+    return {};
+  }, {
+    connection: connection2
+  });
+}, "createWorker");
+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";
+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`);
+    const { submissionHash: existingSubmissionHash } = state;
+    if (isDefined5(existingSubmissionHash)) {
+      await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
+      return {
+        submissionHash: existingSubmissionHash
+      };
+    }
+    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`);
+    await job.log(`[${hash}] Submitted XL1 tx`);
+    await job.log(`[${hash}] Storing XL1 submissionHash`);
+    state.submissionHash = submissionHash;
+    await stateMap.set(hash, state);
+    await job.log(`[${hash}] Stored XL1 submissionHash`);
+    return {
+      submissionHash
+    };
+  }, {
+    connection: connection2
+  });
+}, "createWorker");
+var xl1TransactionSubmission = {
+  createWorker: createWorker7,
+  name: name7,
+  queueName: queueName7
+};
+
+// src/queue/flows/createXl1ToEthBridgeJob.ts
+var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) => {
+  const flow = await flowProducer2.add({
+    name: xl1ToEthBridgeParent.name,
+    queueName: xl1ToEthBridgeParent.queueName,
+    data: {
+      tx
+    },
+    children: [
+      {
+        name: xl1TransactionPreparation.name,
+        queueName: xl1TransactionPreparation.queueName,
+        data: {
+          tx
+        },
+        children: [
+          {
+            name: xl1TransactionSubmission.name,
+            queueName: xl1TransactionSubmission.queueName,
+            data: {
+              tx
+            },
+            children: [
+              {
+                name: xl1TransactionMonitor.name,
+                queueName: xl1TransactionMonitor.queueName,
+                data: {
+                  tx
+                },
+                opts: {
+                  attempts: 60,
+                  backoff: {
+                    type: "fixed",
+                    delay: 5e3
+                  }
+                },
+                children: [
+                  {
+                    name: ethTransactionPreparation.name,
+                    queueName: ethTransactionPreparation.queueName,
+                    data: {
+                      tx
+                    },
+                    children: [
+                      {
+                        name: ethTransactionSubmission.name,
+                        queueName: ethTransactionSubmission.queueName,
+                        data: {
+                          tx
+                        },
+                        children: [
+                          {
+                            name: ethTransactionMonitor.name,
+                            queueName: ethTransactionMonitor.queueName,
+                            data: {
+                              tx
+                            },
+                            opts: {
+                              attempts: 60,
+                              backoff: {
+                                type: "fixed",
+                                delay: 5e3
+                              }
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  });
+  return flow;
+}, "createXl1ToEthBridgeJob");
+
+// src/server/flowProducer.ts
+var addFlowProducer = /* @__PURE__ */ __name((app, config) => {
+  const connection2 = getConnection(config);
+  const flowProducer2 = getFlowProducer(connection2);
+  app.flowProducer = flowProducer2;
+  return app;
+}, "addFlowProducer");
+
 // src/server/instrumentation.ts
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
 import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
@@ -40,14 +391,14 @@ var asToken = /* @__PURE__ */ __name((value) => {
 }, "asToken");
 
 // src/config/getBridgeEscrowAddress.ts
-import { asAddress as asAddress2, assertEx } from "@xylabs/sdk-js";
+import { asAddress as asAddress2, assertEx as assertEx6 } from "@xylabs/sdk-js";
 var tryGetBridgeEscrowAddress = /* @__PURE__ */ __name((config) => {
   const address = asAddress2(config.bridge.escrowAddress);
   return address;
 }, "tryGetBridgeEscrowAddress");
 
 // src/config/getBridgeFeesAddress.ts
-import { asAddress as asAddress3, assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { asAddress as asAddress3, assertEx as assertEx7 } from "@xylabs/sdk-js";
 var tryGetBridgeFeesAddress = /* @__PURE__ */ __name((config) => {
   const address = asAddress3(config.bridge.feesAddress);
   return address;
@@ -75,21 +426,21 @@ var getMinBridgeAmount = /* @__PURE__ */ __name((config) => {
 }, "getMinBridgeAmount");
 
 // src/config/getRemoteChainId.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
 var getRemoteChainId = /* @__PURE__ */ __name((config) => {
-  const remoteChainId = assertEx3(asChainId(config.bridge.remoteChainId), () => "Invalid remote chain ID in config");
+  const remoteChainId = assertEx8(asChainId(config.bridge.remoteChainId), () => "Invalid remote chain ID in config");
   return remoteChainId;
 }, "getRemoteChainId");
 
 // src/config/getRemoteTokenAddress.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx9 } from "@xylabs/sdk-js";
 var getRemoteTokenAddress = /* @__PURE__ */ __name((config) => {
   const token = asToken(config.bridge.remoteTokenAddress);
-  return assertEx4(token, () => "Remote token address is not defined in bridge configuration");
+  return assertEx9(token, () => "Remote token address is not defined in bridge configuration");
 }, "getRemoteTokenAddress");
 
 // src/config/getBridgeWalletAccount.ts
-import { isDefined, isUndefined } from "@xylabs/sdk-js";
+import { isDefined as isDefined6, isUndefined } from "@xylabs/sdk-js";
 import { HDWallet } from "@xyo-network/wallet";
 import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-protocol-sdk";
 var accountServiceSingleton;
@@ -123,20 +474,20 @@ var getTransferAddresses = /* @__PURE__ */ __name(async (config) => {
 }, "getTransferAddresses");
 
 // src/config/getXl1ChainId.ts
-import { assertEx as assertEx5, isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, isDefined as isDefined7 } from "@xylabs/sdk-js";
 var getXl1ChainId = /* @__PURE__ */ __name((config) => {
   const xl1ChainId = config.bridge.xl1ChainId;
-  if (isDefined2(xl1ChainId)) {
-    return assertEx5(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
+  if (isDefined7(xl1ChainId)) {
+    return assertEx10(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
   }
-  return assertEx5(asChainId(config.chain.id), () => "Invalid chain.id in config");
+  return assertEx10(asChainId(config.chain.id), () => "Invalid chain.id in config");
 }, "getXl1ChainId");
 
 // src/config/getXl1TokenAddress.ts
-import { isDefined as isDefined3 } from "@xylabs/sdk-js";
+import { isDefined as isDefined8 } from "@xylabs/sdk-js";
 var getXl1TokenAddress = /* @__PURE__ */ __name((config) => {
   const token = asToken(config.bridge.xl1TokenAddress);
-  if (isDefined3(token)) return token;
+  if (isDefined8(token)) return token;
   return getXl1ChainId(config);
 }, "getXl1TokenAddress");
 
@@ -165,21 +516,24 @@ var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
 }, "getBridgeSettings");
 
 // src/config/getGateway.ts
-import { isDefined as isDefined4 } from "@xylabs/sdk-js";
+import { isDefined as isDefined9 } from "@xylabs/sdk-js";
 import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
-import { SimpleXyoGatewayRunner, SimpleXyoSigner } from "@xyo-network/xl1-protocol-sdk";
-import { HttpRpcXyoConnection } from "@xyo-network/xl1-rpc";
+import { SimpleXyoGatewayRunner, SimpleXyoSigner, XyoConnectionMoniker } from "@xyo-network/xl1-protocol-sdk";
+import { buildJsonRpcProviderLocator } from "@xyo-network/xl1-providers";
+import { HttpRpcTransport } from "@xyo-network/xl1-rpc";
 var gatewayInstance;
 var getGateway = /* @__PURE__ */ __name(async (config) => {
-  if (isDefined4(gatewayInstance)) return gatewayInstance;
+  if (isDefined9(gatewayInstance)) return gatewayInstance;
   const { mnemonic, chainRpcApiUrl: endpoint } = config.bridge;
-  const walletPromise = isDefined4(mnemonic) ? HDWallet2.fromPhrase(mnemonic) : HDWallet2.random();
+  const walletPromise = isDefined9(mnemonic) ? HDWallet2.fromPhrase(mnemonic) : HDWallet2.random();
   const account = await walletPromise;
   const signer = new SimpleXyoSigner(account);
-  const connection = new HttpRpcXyoConnection({
-    endpoint
+  const transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport(endpoint, schemas), "transportFactory");
+  const locator = await buildJsonRpcProviderLocator({
+    transportFactory
   });
-  gatewayInstance = new SimpleXyoGatewayRunner(connection, signer);
+  const connection2 = await locator.getInstance(XyoConnectionMoniker);
+  gatewayInstance = new SimpleXyoGatewayRunner(connection2, signer);
   return gatewayInstance;
 }, "getGateway");
 
@@ -274,20 +628,17 @@ var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
 import { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/payload-builder";
 import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/payload-model";
-import { asSentinelInstance } from "@xyo-network/sentinel-model";
 import { BridgeIntentFieldsZod, BridgeIntentSchema as BridgeIntentSchema2, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, SignedTransactionBoundWitnessZod, TransferZod } from "@xyo-network/xl1-protocol";
-import { flattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
 import { z as z2 } from "zod";
 
 // src/util/calculateBridgeFees.ts
-import { hexToBigInt, toHex as toHex2 } from "@xylabs/sdk-js";
+import { hexToBigInt as hexToBigInt2, toHex as toHex2 } from "@xylabs/sdk-js";
 var calculateBridgeFees = /* @__PURE__ */ __name((srcAmount, feeStructure) => {
   const { feeFixed, feeRateBasisPoints } = feeStructure;
-  const srcAmountBigInt = hexToBigInt(srcAmount);
-  const feeFixedBigInt = hexToBigInt(feeFixed);
+  const srcAmountBigInt = hexToBigInt2(srcAmount);
+  const feeFixedBigInt = hexToBigInt2(feeFixed);
   const feeVariableBigInt = srcAmountBigInt * BigInt(feeRateBasisPoints) / 10000n;
   const feeVariable = toHex2(feeVariableBigInt);
   const feeTotalBigInt = feeFixedBigInt + feeVariableBigInt;
@@ -301,10 +652,10 @@ var calculateBridgeFees = /* @__PURE__ */ __name((srcAmount, feeStructure) => {
 }, "calculateBridgeFees");
 
 // src/util/generateBridgeEstimate.ts
-import { hexToBigInt as hexToBigInt2, toAddress as toAddress2 } from "@xylabs/sdk-js";
-import { createTransferPayload } from "@xyo-network/chain-protocol";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { hexToBigInt as hexToBigInt3, toAddress as toAddress2 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 import { BridgeIntentSchema } from "@xyo-network/xl1-protocol";
+import { createTransferPayload } from "@xyo-network/xl1-protocol-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);
@@ -328,7 +679,7 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
     destToken: remoteTokenAddress,
     nonce
   };
-  const bridgeIntent = new PayloadBuilder({
+  const bridgeIntent = new PayloadBuilder7({
     schema: BridgeIntentSchema
   }).fields(bridgeIntentFields).build();
   const context = {
@@ -337,8 +688,8 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
     feeVariable
   };
   const transfer = createTransferPayload(sender, {
-    [escrowAddress]: hexToBigInt2(destAmount),
-    [feesAddress]: hexToBigInt2(feeFixedAmount) + hexToBigInt2(feeVariable)
+    [escrowAddress]: hexToBigInt3(destAmount),
+    [feesAddress]: hexToBigInt3(feeFixedAmount) + hexToBigInt3(feeVariable)
   }, context);
   return [
     bridgeIntent,
@@ -348,31 +699,33 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
 
 // src/util/validateBridgeEstimateExact.ts
 import { isUndefined as isUndefined3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/payload-builder";
 var validateBridgeEstimateExact = /* @__PURE__ */ __name(async (intent, transfer, config) => {
   const { srcAddress, srcAmount, destAddress } = intent;
   const [calculatedIntent, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
   if (isUndefined3(calculatedIntent) || isUndefined3(calculatedTransfer)) return false;
   const { nonce: expectedIntentNonce, ...expectedIntentStatic } = calculatedIntent;
   const { nonce: actualIntentNonce, ...actualIntentStatic } = intent;
-  if (await PayloadBuilder2.dataHash(expectedIntentStatic) !== await PayloadBuilder2.dataHash(actualIntentStatic)) return false;
+  if (await PayloadBuilder8.dataHash(expectedIntentStatic) !== await PayloadBuilder8.dataHash(actualIntentStatic)) return false;
   const { epoch: expectedTransferEpoch, ...expectedTransferStatic } = calculatedTransfer;
   const { epoch: actualTransferEpoch, ...actualTransferStatic } = transfer;
-  if (await PayloadBuilder2.dataHash(expectedTransferStatic) !== await PayloadBuilder2.dataHash(actualTransferStatic)) return false;
+  if (await PayloadBuilder8.dataHash(expectedTransferStatic) !== await PayloadBuilder8.dataHash(actualTransferStatic)) return false;
   return true;
 }, "validateBridgeEstimateExact");
 
 // src/util/validateBridgeTransaction.ts
-import { asAddress as asAddress4, isDefined as isDefined5 } from "@xylabs/sdk-js";
+import { asAddress as asAddress4, isDefined as isDefined10 } from "@xylabs/sdk-js";
 import { addressesContains, BoundWitnessValidator, payloadHashesContainsAll } from "@xyo-network/boundwitness-validator";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/payload-builder";
 var validateBridgeTransaction = /* @__PURE__ */ __name(async (signedTxBw, intent, transfer, config) => {
   const { srcAddress } = intent;
+  const chainId = getXl1ChainId(config);
+  if (signedTxBw.chain !== chainId) return false;
   const errors = await new BoundWitnessValidator(signedTxBw).validate();
-  if (isDefined5(errors) && errors.length > 0) return false;
+  if (isDefined10(errors) && errors.length > 0) return false;
   const sender = asAddress4(srcAddress, true);
   if (!addressesContains(signedTxBw, sender)) return false;
-  const hashes = await PayloadBuilder3.hashes([
+  const hashes = await PayloadBuilder9.hashes([
     intent,
     transfer
   ]);
@@ -401,7 +754,7 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
     path: "/bridge/chains/:chainId/bridgeToRemote",
     handlers: validateRequest2(async (req, res) => {
       const [signedTxBw, bridgeIntent, transfer] = req.body;
-      const { node } = req.app;
+      const { flowProducer: flowProducer2 } = req.app;
       const transactionValid = await validateBridgeTransaction(signedTxBw, bridgeIntent, transfer, config);
       if (!transactionValid) {
         res.status(400).send();
@@ -412,8 +765,6 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
         res.status(400).send();
         return;
       }
-      const mod = await node.resolve("XL1BridgeIntentTransactionCompletionMonitorSentinel");
-      const sentinel = assertEx6(asSentinelInstance(mod), () => "Error resolving XL1BridgeIntentTransactionCompletionMonitorSentinel");
       const singedHydratedTransaction = [
         signedTxBw,
         [
@@ -421,20 +772,15 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
           bridgeIntent
         ]
       ];
-      const observation = await sentinel.report(flattenHydratedTransaction(singedHydratedTransaction));
-      if (observation.length === 0) {
-        console.error("Error submitting bridge intent transaction to sentinel");
-        res.status(500).send();
-        return;
-      }
-      const srcConfirmation = await PayloadBuilder4.hash(signedTxBw);
+      await createXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction);
+      const srcConfirmation = await PayloadBuilder10.hash(signedTxBw);
       const bridgeCommonFieldsZod = z2.object({}).extend(BridgeSourceObservationFieldsZod.shape);
       const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent);
       const bridgeObservationFields = {
         ...bridgeCommonFields,
         srcConfirmation
       };
-      const bridgeObservation = new PayloadBuilder4({
+      const bridgeObservation = new PayloadBuilder10({
         schema: BridgeSourceObservationSchema
       }).fields(bridgeObservationFields).build();
       res.json(bridgeObservation);
@@ -444,7 +790,7 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
 import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
-import { assertEx as assertEx7, toAddress as toAddress3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11, toAddress as toAddress3 } from "@xylabs/sdk-js";
 import { PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3 } from "@xyo-network/payload-model";
 import { BridgeIntentFieldsZod as BridgeIntentFieldsZod2, BridgeIntentSchema as BridgeIntentSchema3, toXL1BlockNumber, TransactionBoundWitnessZod, TransferSchema } from "@xyo-network/xl1-protocol";
 import { buildUnsignedTransaction } from "@xyo-network/xl1-protocol-sdk";
@@ -477,7 +823,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 = assertEx7(gateway.connectionInstance.viewer, () => new Error("Viewer not available on gateway connection"));
+      const viewer = assertEx11(gateway.connectionInstance.viewer, () => new Error("Viewer not available on gateway connection"));
       const currentBlockNumber = await viewer.currentBlockNumber();
       const nbf = toXL1BlockNumber(currentBlockNumber, true);
       const exp = toXL1BlockNumber(currentBlockNumber + 1e3, true);
@@ -560,7 +906,8 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
           src,
           srcAddress,
           srcAmount,
-          srcToken
+          srcToken,
+          srcConfirmation: toHex3("0x8888")
         };
         result[1] = observation;
       }
@@ -624,41 +971,42 @@ var getApp = /* @__PURE__ */ __name((node, config) => {
   app.use(customPoweredByHeader);
   disableCaseSensitiveRouting(app);
   app.node = node;
+  addFlowProducer(app, config);
   addRoutes(app, config);
   app.use(standardErrors);
   return app;
 }, "getApp");
 
 // src/server/server.ts
-import { assertEx as assertEx11, isDefined as isDefined9, isString } from "@xylabs/sdk-js";
+import { assertEx as assertEx16, isDefined as isDefined15, isString } from "@xylabs/sdk-js";
 import { boot } from "@xyo-network/bios";
-import { HDWallet as HDWallet4 } from "@xyo-network/wallet";
+import { HDWallet as HDWallet5 } from "@xyo-network/wallet";
 
 // src/manifest/getLocator.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
-import { assertEx as assertEx10, isDefined as isDefined8 } from "@xylabs/sdk-js";
+import { assertEx as assertEx14, 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 { mapToMapType, MongoMap } from "@xyo-network/chain-protocol";
+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";
 import { MemorySentinel } from "@xyo-network/sentinel-memory";
 import { HDWallet as HDWallet3 } from "@xyo-network/wallet";
-import { hasMongoConfig, SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2, SimpleXyoSigner as SimpleXyoSigner2 } from "@xyo-network/xl1-protocol-sdk";
-import { HttpRpcXyoConnection as HttpRpcXyoConnection2 } from "@xyo-network/xl1-rpc";
+import { hasMongoConfig, mapToMapType, SimpleXyoGatewayRunner as SimpleXyoGatewayRunner2, SimpleXyoSigner as SimpleXyoSigner2 } from "@xyo-network/xl1-protocol-sdk";
+import { SimpleXyoConnection } from "@xyo-network/xl1-providers";
 
 // src/modules/EVMLiquidityBridgeTransactionCompletionMonitorSentinel/EVMLiquidityBridgeTransactionCompletionMonitorSentinel.ts
-import { asAddress as asAddress6, asHex as asHex4, assertEx as assertEx8, delay, hexFromBigInt, hexToBigInt as hexToBigInt3, isDefined as isDefined6, isUndefined as isUndefined4 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/payload-builder";
+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 { AbstractSentinel } from "@xyo-network/sentinel-abstract";
 import { LiquidityPoolBridge__factory } from "@xyo-network/typechain";
-import { BridgeDestinationObservationSchema as BridgeDestinationObservationSchema3, isBridgeIntent } from "@xyo-network/xl1-protocol";
-import { flattenHydratedTransaction as flattenHydratedTransaction2, flattenHydratedTransactions, tryUnflattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
+import { BridgeDestinationObservationSchema as BridgeDestinationObservationSchema3, isBridgeIntent as isBridgeIntent2 } from "@xyo-network/xl1-protocol";
+import { flattenHydratedTransaction, flattenHydratedTransactions, tryUnflattenHydratedTransaction } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex } from "async-mutex";
-import { getAddress } from "ethers/address";
+import { getAddress as getAddress2 } from "ethers/address";
 import { Wallet } from "ethers/wallet";
 var EVMLiquidityBridgeTransactionCompletionMonitorSentinelConfigSchema = "network.xyo.sentinel.chain.evm.liquidity.bridge.transaction.completion.monitor.config";
 var defaultJobCheckIntervalMs = 15e3;
@@ -681,19 +1029,19 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
   _successCounter;
   _wallet;
   get bridge() {
-    return assertEx8(this._bridge, () => new Error("Bridge contract not initialized"));
+    return assertEx12(this._bridge, () => new Error("Bridge contract not initialized"));
   }
   get completedTransactions() {
-    return assertEx8(this.params.completedTransactions, () => "Completed transactions map is not defined");
+    return assertEx12(this.params.completedTransactions, () => "Completed transactions map is not defined");
   }
   get jobCheckInterval() {
-    return isDefined6(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs;
+    return isDefined11(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs;
   }
   get pendingTransactions() {
-    return assertEx8(this.params.pendingTransactions, () => "Pending transactions map is not defined");
+    return assertEx12(this.params.pendingTransactions, () => "Pending transactions map is not defined");
   }
   get wallet() {
-    return assertEx8(this._wallet, () => "wallet is required");
+    return assertEx12(this._wallet, () => "wallet is required");
   }
   async createHandler() {
     await super.createHandler();
@@ -710,24 +1058,24 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
       description: "Number of errors"
     });
     const { provider, bridgeAddress } = this.params;
-    const key = assertEx8(this.account?.private?.hex, () => new Error("Account private key is required"));
+    const key = assertEx12(this.account?.private?.hex, () => new Error("Account private key is required"));
     this._wallet = new Wallet(key, provider);
-    this._bridge = LiquidityPoolBridge__factory.connect(getAddress(bridgeAddress), this._wallet);
+    this._bridge = LiquidityPoolBridge__factory.connect(getAddress2(bridgeAddress), this._wallet);
     const network = await provider.getNetwork();
-    this._bridgeChainId = assertEx8(hexFromBigInt(network.chainId), () => new Error("Failed to parse bridgeChainId"));
+    this._bridgeChainId = assertEx12(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 (isDefined6(payloads) && payloads.length > 0) {
+    if (isDefined11(payloads) && payloads.length > 0) {
       const signedHydratedTransaction = tryUnflattenHydratedTransaction(payloads);
-      if (isDefined6(signedHydratedTransaction)) {
-        const txHash = await PayloadBuilder5.hash(signedHydratedTransaction[0]);
+      if (isDefined11(signedHydratedTransaction)) {
+        const txHash = await PayloadBuilder11.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 flattenHydratedTransaction(signedHydratedTransaction);
       }
       return [];
     } else {
@@ -751,7 +1099,7 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
         hash,
         signedHydratedTransaction
       ]);
-      if (isDefined6(result)) results.push(result[1]);
+      if (isDefined11(result)) results.push(result[1]);
       await delay(this.jobCheckInterval);
     }
     return flattenHydratedTransactions(results);
@@ -761,7 +1109,7 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
     try {
       let ret = void 0;
       this._checkCounter?.add(1);
-      const bridgeIntents = signedHydratedTransaction[1].filter(isBridgeIntent);
+      const bridgeIntents = signedHydratedTransaction[1].filter(isBridgeIntent2);
       if (bridgeIntents.length !== 1) {
         await this.pendingTransactions.delete(hash);
         return ret;
@@ -784,10 +1132,10 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
   * @returns Relays the intent in a blocking manner, returning the resulting BridgeDestinationObservation if successful
   */
   async relayBridgeIntentSync(bridgeIntent) {
-    const amount = hexToBigInt3(bridgeIntent.destAmount);
+    const amount = hexToBigInt4(bridgeIntent.destAmount);
     const nonce = await this.wallet.getNonce();
-    const srcAddress = getAddress(bridgeIntent.srcAddress);
-    const destAddress = getAddress(bridgeIntent.destAddress);
+    const srcAddress = getAddress2(bridgeIntent.srcAddress);
+    const destAddress = getAddress2(bridgeIntent.destAddress);
     const tx = await this.bridge.bridgeFromRemote(srcAddress, destAddress, amount, {
       nonce
     });
@@ -795,7 +1143,7 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
     const transactionResponse = await confirmation?.getTransaction();
     const destConfirmation = asHex4(transactionResponse?.hash ?? "", true);
     const { schema, ...rest } = bridgeIntent;
-    const result = new PayloadBuilder5({
+    const result = new PayloadBuilder11({
       schema: BridgeDestinationObservationSchema3
     }).fields({
       ...rest,
@@ -806,10 +1154,10 @@ var EVMLiquidityBridgeTransactionCompletionMonitorSentinel = class extends Abstr
 };
 
 // src/modules/XL1TransactionCompletionMonitorSentinel/XL1TransactionCompletionMonitorSentinel.ts
-import { assertEx as assertEx9, delay as delay2, isDefined as isDefined7, isNull, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/payload-builder";
+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 { AbstractSentinel as AbstractSentinel2 } from "@xyo-network/sentinel-abstract";
-import { flattenHydratedTransaction as flattenHydratedTransaction3, flattenHydratedTransactions as flattenHydratedTransactions2, tryUnflattenHydratedTransaction as tryUnflattenHydratedTransaction2 } from "@xyo-network/xl1-protocol-sdk";
+import { flattenHydratedTransaction as flattenHydratedTransaction2, flattenHydratedTransactions as flattenHydratedTransactions2, tryUnflattenHydratedTransaction as tryUnflattenHydratedTransaction2 } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex2 } from "async-mutex";
 var XL1TransactionCompletionMonitorSentinelConfigSchema = "network.xyo.sentinel.chain.transaction.completion.monitor.config";
 var defaultJobCheckIntervalMs2 = 15e3;
@@ -827,16 +1175,16 @@ var XL1TransactionCompletionMonitorSentinel = class extends AbstractSentinel2 {
   _reportMutex = new Mutex2();
   _successCounter;
   get completedTransactions() {
-    return assertEx9(this.params.completedTransactions, () => "Completed transactions map is not defined");
+    return assertEx13(this.params.completedTransactions, () => "Completed transactions map is not defined");
   }
   get jobCheckInterval() {
-    return isDefined7(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs2;
+    return isDefined12(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs2;
   }
   get pendingTransactions() {
-    return assertEx9(this.params.pendingTransactions, () => "Pending transactions map is not defined");
+    return assertEx13(this.params.pendingTransactions, () => "Pending transactions map is not defined");
   }
   get viewer() {
-    return assertEx9(this.params.viewer, () => "Viewer is not defined in params");
+    return assertEx13(this.params.viewer, () => "Viewer is not defined in params");
   }
   async createHandler() {
     await super.createHandler();
@@ -854,13 +1202,13 @@ var XL1TransactionCompletionMonitorSentinel = class extends AbstractSentinel2 {
     });
   }
   async reportHandler(payloads) {
-    if (isDefined7(payloads) && payloads.length > 0) {
+    if (isDefined12(payloads) && payloads.length > 0) {
       const signedHydratedTransaction = tryUnflattenHydratedTransaction2(payloads);
-      if (isDefined7(signedHydratedTransaction)) {
-        const txHash = await PayloadBuilder6.hash(signedHydratedTransaction[0]);
+      if (isDefined12(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 flattenHydratedTransaction3(signedHydratedTransaction);
+        return flattenHydratedTransaction2(signedHydratedTransaction);
       }
       return [];
     } else {
@@ -884,7 +1232,7 @@ var XL1TransactionCompletionMonitorSentinel = class extends AbstractSentinel2 {
         hash,
         signedHydratedTransaction
       ]);
-      if (isDefined7(result)) results.push(result[1]);
+      if (isDefined12(result)) results.push(result[1]);
       await delay2(this.jobCheckInterval);
     }
     return flattenHydratedTransactions2(results);
@@ -896,7 +1244,7 @@ var XL1TransactionCompletionMonitorSentinel = class extends AbstractSentinel2 {
       this._checkCounter?.add(1);
       this._attemptsCounter?.add(1);
       const tx = await this.viewer.transactionByHash(hash);
-      if (isDefined7(tx) && !isNull(tx)) {
+      if (isDefined12(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}`);
@@ -937,7 +1285,7 @@ var getLocator = /* @__PURE__ */ __name(async (context) => {
       port
     }
   });
-  if (isDefined8(logger)) AbstractModule.defaultLogger = logger;
+  if (isDefined13(logger)) AbstractModule.defaultLogger = logger;
   const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
   const locator = new ModuleFactoryLocator();
   const mongoConfig = config.storage?.mongo;
@@ -974,7 +1322,7 @@ var getLocator = /* @__PURE__ */ __name(async (context) => {
     statusReporter
   }));
   const gateway = await getGateway2(config);
-  const viewer = assertEx10(gateway.connectionInstance.viewer, () => "Gateway viewer is not defined");
+  const viewer = assertEx14(gateway.connectionInstance.viewer, () => "Gateway viewer is not defined");
   const pendingXl1ToEthXl1BridgeIntentTransactions = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_xl1_pending");
   const completedXl1ToEthXl1BridgeIntentTransactions = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_xl1_completed");
   const xl1TransactionCompletionMonitorSentinelParams = {
@@ -1011,13 +1359,11 @@ var getLocator = /* @__PURE__ */ __name(async (context) => {
 }, "getLocator");
 var getGateway2 = /* @__PURE__ */ __name(async (config) => {
   const { mnemonic, chainRpcApiUrl: endpoint } = config.bridge;
-  const walletPromise = isDefined8(mnemonic) ? HDWallet3.fromPhrase(mnemonic) : HDWallet3.random();
+  const walletPromise = isDefined13(mnemonic) ? HDWallet3.fromPhrase(mnemonic) : HDWallet3.random();
   const account = await walletPromise;
   const signer = new SimpleXyoSigner2(account);
-  const connection = new HttpRpcXyoConnection2({
-    endpoint
-  });
-  const gateway = new SimpleXyoGatewayRunner2(connection, signer);
+  const connection2 = await SimpleXyoConnection.create();
+  const gateway = new SimpleXyoGatewayRunner2(connection2, signer);
   return gateway;
 }, "getGateway");
 var getIterableMap = /* @__PURE__ */ __name(async (config, collection) => {
@@ -1197,6 +1543,82 @@ var getNode = /* @__PURE__ */ __name(async (context) => {
   return node;
 }, "getNode");
 
+// src/manifest/getServices.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 HDWallet4 } from "@xyo-network/wallet";
+import { hasMongoConfig as hasMongoConfig2, mapToMapType as mapToMapType2, SimpleXyoGatewayRunner as SimpleXyoGatewayRunner3, SimpleXyoSigner as SimpleXyoSigner3, XyoConnectionMoniker as XyoConnectionMoniker2 } from "@xyo-network/xl1-protocol-sdk";
+import { buildJsonRpcProviderLocator as buildJsonRpcProviderLocator2 } from "@xyo-network/xl1-providers";
+import { HttpRpcTransport as HttpRpcTransport2 } from "@xyo-network/xl1-rpc";
+import { getAddress as getAddress3, Wallet as Wallet2 } from "ethers";
+var getServices = /* @__PURE__ */ __name(async (context) => {
+  const { config } = context;
+  const gateway = await getGateway3(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 HDWallet4.fromPhrase(mnemonic) : await HDWallet4.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 getGateway3 = /* @__PURE__ */ __name(async (config) => {
+  const { mnemonic, chainRpcApiUrl: endpoint } = config.bridge;
+  const walletPromise = isDefined14(mnemonic) ? HDWallet4.fromPhrase(mnemonic) : HDWallet4.random();
+  const account = await walletPromise;
+  const signer = new SimpleXyoSigner3(account);
+  const transportFactory = /* @__PURE__ */ __name((schemas) => new HttpRpcTransport2(endpoint, schemas), "transportFactory");
+  const locator = await buildJsonRpcProviderLocator2({
+    transportFactory
+  });
+  const connection2 = await locator.getInstance(XyoConnectionMoniker2);
+  const gateway = new SimpleXyoGatewayRunner3(connection2, signer);
+  return gateway;
+}, "getGateway");
+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/server/server.ts
 var hostname = "::";
 var getSeedPhrase = /* @__PURE__ */ __name(async (bios, config, logger) => {
@@ -1211,20 +1633,20 @@ var getSeedPhrase = /* @__PURE__ */ __name(async (bios, config, logger) => {
     if (isString(mnemonic)) {
       seedPhrase = mnemonic;
     } else {
-      seedPhrase = HDWallet4.generateMnemonic();
+      seedPhrase = HDWallet5.generateMnemonic();
       logger?.log("[Bridge] No mnemonic provided, using random mnemonic. This is not recommended for production use.");
       logger?.log(`[Bridge] Mnemonic: ${seedPhrase}`);
     }
     await bios.seedPhraseStore.set("os", seedPhrase);
   }
-  return assertEx11(await bios.seedPhraseStore.get("os"), () => "Unable to acquire mnemonic from bios");
+  return assertEx16(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 bios = await boot();
-  const seedPhrase = isDefined9(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
-  const wallet = await HDWallet4.fromPhrase(seedPhrase);
+  const seedPhrase = isDefined15(mnemonic) ? mnemonic : await getSeedPhrase(bios, config, logger);
+  const wallet = await HDWallet5.fromPhrase(seedPhrase);
   const nodeContext = {
     wallet,
     logger,
@@ -1232,6 +1654,10 @@ var getServer = /* @__PURE__ */ __name(async (context) => {
   };
   const node = context.node ?? await getNode(nodeContext);
   const app = getApp(node, config);
+  app.services = await getServices({
+    config,
+    logger
+  });
   const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`));
   server.setTimeout(2e4);
   return server;