@xyo-network/chain-bridge 1.19.17 → 1.20.0

package/dist/node/index.mjs

@@ -31,27 +31,33 @@ var getConnection = /* @__PURE__ */ __name((config) => {
 // src/queue/flowProducer.ts
 import { isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { FlowProducer } from "bullmq";
+
+// src/queue/prefix.ts
+var prefix = "xl1-bridge";
+
+// src/queue/flowProducer.ts
 var flowProducer;
-var getFlowProducer = /* @__PURE__ */ __name((connection2) => {
+var getFlowProducer = /* @__PURE__ */ __name((connection2, telemetry2) => {
   if (isDefined2(flowProducer)) return flowProducer;
   flowProducer = new FlowProducer({
-    connection: connection2
+    connection: connection2,
+    telemetry: telemetry2,
+    prefix
   });
   return flowProducer;
 }, "getFlowProducer");
 
-// src/queue/flows/createXl1ToEthBridgeJob.ts
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/sdk-js";
-
 // 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);
+var createWorkers = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  EthTransactionMonitor.createWorker(connection2, telemetry2, services);
+  EthTransactionPreparation.createWorker(connection2, telemetry2, services);
+  EthTransactionSubmission.createWorker(connection2, telemetry2, services);
+  EthTransactionSubmissionStorage.createWorker(connection2, telemetry2, services);
+  Xl1ToEthBridgeParent.createWorker(connection2, telemetry2);
+  Xl1TransactionMonitor.createWorker(connection2, telemetry2, services);
+  Xl1TransactionPreparation.createWorker(connection2, telemetry2, services);
+  Xl1TransactionSubmission.createWorker(connection2, telemetry2, services);
+  Xl1TransactionSubmissionStorage.createWorker(connection2, telemetry2, services);
 }, "createWorkers");
 
 // src/queue/workers/EthTransactionMonitor.ts
@@ -60,7 +66,7 @@ import { PayloadBuilder } from "@xyo-network/sdk-js";
 import { Worker } from "bullmq";
 var name = "Monitor Submitted ETH Transaction";
 var queueName = "eth-tx-monitor";
-var createWorker = /* @__PURE__ */ __name((connection2, services) => {
+var createWorker = /* @__PURE__ */ __name((connection2, telemetry2, 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) => {
@@ -75,10 +81,13 @@ var createWorker = /* @__PURE__ */ __name((connection2, services) => {
     await stateMap.set(hash, state);
     return {
       blockHash,
-      blockNumber
+      blockNumber,
+      submissionHash
     };
   }, {
-    connection: connection2
+    connection: connection2,
+    telemetry: telemetry2,
+    prefix
   });
   worker.on("failed", (job, err) => {
     console.error(`[${name}] Job ${job?.id} failed:`, err.message);
@@ -94,90 +103,359 @@ var EthTransactionMonitor = {
 };
 
 // src/queue/workers/EthTransactionPreparation.ts
-import { assertEx as assertEx5, hexToBigInt as hexToBigInt4 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk-js";
-import { isBridgeIntent as isBridgeIntent4 } from "@xyo-network/xl1-sdk";
+import { assertEx as assertEx11, hexToBigInt as hexToBigInt6 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
+import { isBridgeIntent as isBridgeIntent3 } from "@xyo-network/xl1-sdk";
 import { Worker as Worker2 } from "bullmq";
 import { getAddress } from "ethers";
 
-// src/queue/workers/util/submitEthTransaction.ts
-import { assertEx as assertEx2, hexToBigInt, toEthAddress } from "@xylabs/sdk-js";
+// src/validation/validateBridgeEstimateExact.ts
+import { isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk-js";
+
+// src/util/calculateBridgeFees.ts
+import { hexToBigInt, toHex } from "@xylabs/sdk-js";
+var calculateBridgeFees = /* @__PURE__ */ __name((srcAmount, feeStructure) => {
+  const { feeFixed, feeRateBasisPoints } = feeStructure;
+  const srcAmountBigInt = hexToBigInt(srcAmount);
+  const feeFixedBigInt = hexToBigInt(feeFixed);
+  const feeVariableBigInt = srcAmountBigInt * BigInt(feeRateBasisPoints) / 10000n;
+  const feeVariable = toHex(feeVariableBigInt);
+  const feeTotalBigInt = feeFixedBigInt + feeVariableBigInt;
+  const destAmountBigInt = srcAmountBigInt > feeTotalBigInt ? srcAmountBigInt - feeTotalBigInt : 0n;
+  const destAmount = toHex(destAmountBigInt);
+  return {
+    feeFixed,
+    feeVariable,
+    srcAmount
+  };
+}, "calculateBridgeFees");
+
+// src/util/createBridgeTransfer.ts
+import { hexToBigInt as hexToBigInt2 } from "@xylabs/sdk-js";
+import { createTransferPayload } from "@xyo-network/xl1-sdk";
+var createBridgeTransfer = /* @__PURE__ */ __name((sender, srcAmount, escrowAddress, feesAddress, context) => {
+  const { feeFixed, feeVariable } = context;
+  const escrowAmount = hexToBigInt2(srcAmount);
+  const feesAmount = hexToBigInt2(feeFixed) + hexToBigInt2(feeVariable);
+  const transfers = escrowAddress === feesAddress ? {
+    [feesAddress]: escrowAmount + feesAmount
+  } : {
+    [escrowAddress]: escrowAmount,
+    [feesAddress]: feesAmount
+  };
+  const transfer = createTransferPayload(sender, transfers, context);
+  return transfer;
+}, "createBridgeTransfer");
+
+// src/util/generateBridgeEstimate.ts
+import { toAddress } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
-import { isBridgeIntent } from "@xyo-network/xl1-sdk";
-var submitEthTransaction = /* @__PURE__ */ __name(async (tx, bridgeableToken, bridge, wallet) => {
-  const xl1Transaction = assertEx2(tx[0], () => "No corresponding XL1 transaction found");
-  const bridgeIntent = assertEx2(tx[1].find(isBridgeIntent), () => "No bridge intent found");
-  const srcAddress = toEthAddress(bridgeIntent.srcAddress);
-  const destAddress = toEthAddress(bridgeIntent.destAddress);
-  const amount = hexToBigInt(bridgeIntent.destAmount);
-  const nonce = hexToBigInt(await PayloadBuilder2.hash(xl1Transaction));
-  const bridgeTx = await bridge.connect(wallet).bridgeFromRemote(srcAddress, destAddress, amount, nonce);
-  const receipt = await bridgeTx.wait(1);
-  return receipt?.hash;
-}, "submitEthTransaction");
+import { BridgeIntentSchema } from "@xyo-network/xl1-sdk";
+import { v4 } from "uuid";
 
-// src/queue/workers/util/submitXl1Transaction.ts
-import { isAllowedBlockPayload } from "@xyo-network/xl1-sdk";
-var submitXl1Transaction = /* @__PURE__ */ __name(async (preparedTx, gateway) => {
-  const offChainPayloads = preparedTx[1].filter((p) => !isAllowedBlockPayload(p));
-  const result = await gateway.addTransactionToChain(preparedTx, offChainPayloads);
-  return result;
-}, "submitXl1Transaction");
+// src/config/asChainId.ts
+import { asHex } from "@xylabs/sdk-js";
+var asChainId = /* @__PURE__ */ __name((value) => {
+  const chainId = asHex(value);
+  return chainId;
+}, "asChainId");
 
-// src/queue/workers/util/validateSufficientAllowance.ts
-import { assertEx as assertEx3, hexToBigInt as hexToBigInt2 } from "@xylabs/sdk-js";
-import { isBridgeIntent as isBridgeIntent2 } from "@xyo-network/xl1-sdk";
-var validateSufficientAllowance = /* @__PURE__ */ __name(async (tx, bridgeableToken, bridge, logger) => {
-  const bridgeIntent = assertEx3(tx[1].find(isBridgeIntent2), () => "No bridge intent found");
-  const amount = hexToBigInt2(bridgeIntent.destAmount);
+// src/config/asToken.ts
+import { asAddress } from "@xylabs/sdk-js";
+var asToken = /* @__PURE__ */ __name((value) => {
+  const token = asAddress(value);
+  return token;
+}, "asToken");
+
+// src/config/getBridgeEscrowAddress.ts
+import { asAddress as asAddress2, assertEx as assertEx2 } from "@xylabs/sdk-js";
+var tryGetBridgeEscrowAddress = /* @__PURE__ */ __name((config) => {
+  const address = asAddress2(config.escrowAddress);
+  return address;
+}, "tryGetBridgeEscrowAddress");
+
+// src/config/getBridgeFeesAddress.ts
+import { asAddress as asAddress3, assertEx as assertEx3 } from "@xylabs/sdk-js";
+var tryGetBridgeFeesAddress = /* @__PURE__ */ __name((config) => {
+  const address = asAddress3(config.feesAddress);
+  return address;
+}, "tryGetBridgeFeesAddress");
+
+// src/config/getFeeStructure.ts
+var getFeeStructure = /* @__PURE__ */ __name((config) => {
+  const { feeFixed, feeRateBasisPoints } = config;
+  return {
+    feeFixed,
+    feeRateBasisPoints
+  };
+}, "getFeeStructure");
+
+// src/config/getMaxBridgeAmount.ts
+var getMaxBridgeAmount = /* @__PURE__ */ __name((config) => {
+  const { maxBridgeAmount } = config;
+  return maxBridgeAmount;
+}, "getMaxBridgeAmount");
+
+// src/config/getMinBridgeAmount.ts
+var getMinBridgeAmount = /* @__PURE__ */ __name((config) => {
+  const { minBridgeAmount } = config;
+  return minBridgeAmount;
+}, "getMinBridgeAmount");
+
+// src/config/getRemoteChainId.ts
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+var getRemoteChainId = /* @__PURE__ */ __name((config) => {
+  const remoteChainId = assertEx4(asChainId(config.remoteChainId), () => "Invalid remote chain ID in config");
+  return remoteChainId;
+}, "getRemoteChainId");
+
+// src/config/getRemoteTokenAddress.ts
+import { assertEx as assertEx5 } from "@xylabs/sdk-js";
+var getRemoteTokenAddress = /* @__PURE__ */ __name((config) => {
+  const token = asToken(config.remoteTokenAddress);
+  return assertEx5(token, () => "Remote token address is not defined in bridge configuration");
+}, "getRemoteTokenAddress");
+
+// src/config/getBridgeWalletAccount.ts
+import { isDefined as isDefined3, isUndefined } from "@xylabs/sdk-js";
+import { HDWallet } from "@xyo-network/sdk-js";
+import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-sdk";
+var accountServiceSingleton;
+var getBridgeWalletAccount = /* @__PURE__ */ __name(async (config) => {
+  if (accountServiceSingleton) return accountServiceSingleton;
+  let walletPhrase = config.mnemonic;
+  if (isUndefined(walletPhrase)) {
+    console.log("[Bridge] No wallet mnemonic specified!");
+    const randomMnemonic = HDWallet.generateMnemonic();
+    console.log(`[Bridge] Using randomly generated mnemonic:
+    
+${randomMnemonic}
+      
+    `);
+    walletPhrase = randomMnemonic;
+  }
+  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
+  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
+  accountServiceSingleton = account;
+  return accountServiceSingleton;
+}, "getBridgeWalletAccount");
+
+// src/config/getTransferAddresses.ts
+var getTransferAddresses = /* @__PURE__ */ __name(async (config) => {
+  const escrowAddress = tryGetBridgeEscrowAddress(config) ?? (await getBridgeWalletAccount(config)).address;
+  const feesAddress = tryGetBridgeFeesAddress(config) ?? (await getBridgeWalletAccount(config)).address;
+  return {
+    escrowAddress,
+    feesAddress
+  };
+}, "getTransferAddresses");
+
+// src/config/getXl1ChainId.ts
+import { assertEx as assertEx6, isDefined as isDefined4 } from "@xylabs/sdk-js";
+var getXl1ChainId = /* @__PURE__ */ __name((config) => {
+  const xl1ChainId = config.xl1ChainId;
+  if (isDefined4(xl1ChainId)) {
+    return assertEx6(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
+  }
+  return assertEx6(asChainId(config.chain.id), () => "Invalid chain.id in config");
+}, "getXl1ChainId");
+
+// src/config/getXl1TokenAddress.ts
+import { isDefined as isDefined5 } from "@xylabs/sdk-js";
+var getXl1TokenAddress = /* @__PURE__ */ __name((config) => {
+  const token = asToken(config.xl1TokenAddress);
+  if (isDefined5(token)) return token;
+  return getXl1ChainId(config);
+}, "getXl1TokenAddress");
+
+// src/config/getBridgeSettings.ts
+var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
+  const { feeFixed, feeRateBasisPoints } = getFeeStructure(config);
+  const { feesAddress, escrowAddress } = await getTransferAddresses(config);
+  const maxBridgeAmount = getMaxBridgeAmount(config);
+  const minBridgeAmount = getMinBridgeAmount(config);
+  const remoteChainId = getRemoteChainId(config);
+  const remoteTokenAddress = getRemoteTokenAddress(config);
+  const xl1TokenAddress = getXl1TokenAddress(config);
+  const xl1ChainId = getXl1ChainId(config);
+  return {
+    feeFixed,
+    feeRateBasisPoints,
+    feesAddress,
+    escrowAddress,
+    maxBridgeAmount,
+    minBridgeAmount,
+    remoteChainId,
+    remoteTokenAddress,
+    xl1TokenAddress,
+    xl1ChainId
+  };
+}, "getBridgeSettings");
+
+// src/util/generateBridgeEstimate.ts
+var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount, destAddress, config, nonceOverride) => {
+  const { escrowAddress, feeFixed, feeRateBasisPoints, feesAddress, remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
+  const sender = toAddress(srcAddress);
+  const fees = calculateBridgeFees(srcAmount, {
+    feeFixed,
+    feeRateBasisPoints
+  });
+  const nonce = nonceOverride ?? v4();
+  const bridgeIntentFields = {
+    // Source
+    src: xl1ChainId,
+    srcAddress: sender,
+    srcAmount,
+    srcToken: xl1TokenAddress,
+    // Destination
+    dest: remoteChainId,
+    destAddress,
+    destAmount: srcAmount,
+    destToken: remoteTokenAddress,
+    nonce
+  };
+  const bridgeIntent = new PayloadBuilder2({
+    schema: BridgeIntentSchema
+  }).fields(bridgeIntentFields).build();
+  const transfer = createBridgeTransfer(sender, srcAmount, escrowAddress, feesAddress, fees);
+  return [
+    bridgeIntent,
+    transfer
+  ];
+}, "generateBridgeEstimate");
+
+// src/validation/validateBridgeEstimateExact.ts
+var validateBridgeEstimateExact = /* @__PURE__ */ __name(async (intent, transfer, config) => {
+  const { srcAddress, srcAmount, destAddress } = intent;
+  const [calculatedIntent, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
+  if (isUndefined2(calculatedIntent) || isUndefined2(calculatedTransfer)) return false;
+  const { nonce: expectedIntentNonce, ...expectedIntentStatic } = calculatedIntent;
+  const { nonce: actualIntentNonce, ...actualIntentStatic } = intent;
+  if (await PayloadBuilder3.dataHash(expectedIntentStatic) !== await PayloadBuilder3.dataHash(actualIntentStatic)) return false;
+  const { epoch: expectedTransferEpoch, ...expectedTransferStatic } = calculatedTransfer;
+  const { epoch: actualTransferEpoch, ...actualTransferStatic } = transfer;
+  if (await PayloadBuilder3.dataHash(expectedTransferStatic) !== await PayloadBuilder3.dataHash(actualTransferStatic)) return false;
+  return true;
+}, "validateBridgeEstimateExact");
+
+// src/validation/validateBridgeTransaction.ts
+import { asAddress as asAddress4, isDefined as isDefined6 } from "@xylabs/sdk-js";
+import { addressesContains, BoundWitnessValidator, payloadHashesContainsAll } from "@xyo-network/boundwitness-validator";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
+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 (isDefined6(errors) && errors.length > 0) return false;
+  const sender = asAddress4(srcAddress, true);
+  if (!addressesContains(signedTxBw, sender)) return false;
+  const hashes = await PayloadBuilder4.hashes([
+    intent,
+    transfer
+  ]);
+  if (!payloadHashesContainsAll(signedTxBw, hashes)) return false;
+  return true;
+}, "validateBridgeTransaction");
+
+// src/validation/validateSufficientLiquiditySourceAllowance.ts
+import { assertEx as assertEx7, hexToBigInt as hexToBigInt3 } from "@xylabs/sdk-js";
+import { isBridgeIntent } from "@xyo-network/xl1-sdk";
+var validateSufficientLiquiditySourceAllowance = /* @__PURE__ */ __name(async (tx, bridgeableToken, bridge, logger) => {
+  const bridgeIntent = assertEx7(tx[1].find(isBridgeIntent), () => "No bridge intent found");
+  const amount = hexToBigInt3(bridgeIntent.destAmount);
   const liquiditySourceAddress = await bridge.liquiditySource();
   const bridgeAddress = await bridge.getAddress();
   const remainingAllowance = await bridgeableToken.allowance(liquiditySourceAddress, bridgeAddress);
   await logger?.log(`Remaining allowance: ${remainingAllowance.toString()}`);
   return remainingAllowance >= amount;
-}, "validateSufficientAllowance");
+}, "validateSufficientLiquiditySourceAllowance");
 
-// src/queue/workers/util/validateSufficientBalance.ts
-import { assertEx as assertEx4, hexToBigInt as hexToBigInt3 } from "@xylabs/sdk-js";
-import { isBridgeIntent as isBridgeIntent3 } from "@xyo-network/xl1-sdk";
-var validateSufficientBalance = /* @__PURE__ */ __name(async (tx, bridgeableToken, bridge, logger) => {
-  const bridgeIntent = assertEx4(tx[1].find(isBridgeIntent3), () => "No bridge intent found");
-  const amount = hexToBigInt3(bridgeIntent.destAmount);
+// src/validation/validateSufficientLiquiditySourceBalance.ts
+import { assertEx as assertEx8, hexToBigInt as hexToBigInt4 } from "@xylabs/sdk-js";
+import { isBridgeIntent as isBridgeIntent2 } from "@xyo-network/xl1-sdk";
+var validateSufficientLiquiditySourceBalance = /* @__PURE__ */ __name(async (tx, bridgeableToken, bridge, logger) => {
+  const bridgeIntent = assertEx8(tx[1].find(isBridgeIntent2), () => "No bridge intent found");
+  const amount = hexToBigInt4(bridgeIntent.destAmount);
   const liquiditySourceAddress = await bridge.liquiditySource();
   const balance = await bridgeableToken.balanceOf(liquiditySourceAddress);
   await logger?.log(`Remaining balance: ${balance.toString()}`);
   return balance >= amount;
-}, "validateSufficientBalance");
+}, "validateSufficientLiquiditySourceBalance");
+
+// src/validation/validateSufficientRunnerEthBalanceForGas.ts
+import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+var DEFAULT_GAS_BUFFER_BPS = 2000n;
+var validateSufficientRunnerEthBalanceForGas = /* @__PURE__ */ __name(async (preparedTx, wallet, logger, bufferBps = DEFAULT_GAS_BUFFER_BPS) => {
+  const provider = assertEx9(wallet.provider, () => "Wallet provider is not defined");
+  const feeData = await provider.getFeeData();
+  const perGas = feeData.maxFeePerGas ?? feeData.gasPrice;
+  if (perGas == null) {
+    await logger?.log("[gas] unable to resolve gas price / maxFeePerGas from provider");
+    return true;
+  }
+  const transactionRequest = {
+    ...preparedTx,
+    from: await wallet.getAddress()
+  };
+  const estGas = await provider.estimateGas(transactionRequest);
+  const txValue = preparedTx?.value ?? 0n;
+  const baseRequired = estGas * perGas + txValue;
+  const required = baseRequired * (10000n + bufferBps) / 10000n;
+  const balance = await provider.getBalance(await wallet.getAddress());
+  await logger?.log(`[gas] runner=${await wallet.getAddress()} balance=${balance.toString()} estGas=${estGas.toString()} perGas=${perGas.toString()} value=${txValue.toString()} requiredWithBuffer=${required.toString()} bufferBps=${bufferBps.toString()}`);
+  return balance >= required;
+}, "validateSufficientRunnerEthBalanceForGas");
+
+// src/validation/validateSufficientXL1SourceAddressBalance.ts
+import { asAddress as asAddress5, assertEx as assertEx10, hexToBigInt as hexToBigInt5 } from "@xylabs/sdk-js";
+var validateSufficientXL1SourceAddressBalance = /* @__PURE__ */ __name(async (bridgeIntent, gateway, config, logger) => {
+  const viewer = assertEx10(gateway.connection.viewer, () => "Gateway connection does not have a viewer");
+  const { srcAddress, srcAmount, destAddress } = bridgeIntent;
+  const srcAddressBranded = asAddress5(srcAddress, () => `Invalid source address in bridge intent: ${srcAddress}`);
+  const [_, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
+  const totalAmount = Object.values(calculatedTransfer.transfers).reduce((acc, transfer) => acc + hexToBigInt5(transfer), 0n);
+  const accountBalance = await viewer.account.balance.accountBalance(srcAddressBranded);
+  await logger?.log(`Account balance for ${srcAddressBranded}: ${accountBalance.toString()}`);
+  return accountBalance >= totalAmount;
+}, "validateSufficientXL1SourceAddressBalance");
 
 // src/queue/workers/EthTransactionPreparation.ts
 var name2 = "Prepare ETH Transaction";
 var queueName2 = "eth-tx-prepare";
-var createWorker2 = /* @__PURE__ */ __name((connection2, services) => {
-  const bridge = assertEx5(services?.bridge, () => "bridge service not provided");
-  const bridgeableToken = assertEx5(services?.bridgeableToken, () => "bridgeableToken service not provided");
-  const stateMap = assertEx5(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+var createWorker2 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const bridge = assertEx11(services?.bridge, () => "bridge service not provided");
+  const bridgeableToken = assertEx11(services?.bridgeableToken, () => "bridgeableToken service not provided");
+  const stateMap = assertEx11(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const wallet = assertEx11(services?.wallet, () => "wallet service not provided");
   const worker = new Worker2(queueName2, async (job) => {
     const { tx } = job.data;
-    const hash = await PayloadBuilder3.hash(tx[0]);
+    const hash = await PayloadBuilder5.hash(tx[0]);
     await job.log(`[${hash}] preparing ETH transaction`);
     await job.log(`[${hash}] validating liquiditySource has sufficient allowance`);
-    if (!await validateSufficientAllowance(tx, bridgeableToken, bridge, job)) {
+    if (!await validateSufficientLiquiditySourceAllowance(tx, bridgeableToken, bridge, job)) {
       throw new Error("Liquidity source does not have sufficient allowance for the bridge to execute the transaction");
     }
     await job.log(`[${hash}] validated liquiditySource has sufficient allowance`);
     await job.log(`[${hash}] validating liquiditySource has sufficient balance`);
-    if (!await validateSufficientBalance(tx, bridgeableToken, bridge, job)) {
+    if (!await validateSufficientLiquiditySourceBalance(tx, bridgeableToken, bridge, job)) {
       throw new Error("Liquidity source does not have sufficient balance for the bridge to execute the transaction");
     }
     await job.log(`[${hash}] validated liquiditySource has sufficient balance`);
     await job.log(`[${hash}] building ETH transaction`);
-    const bridgeIntent = assertEx5(tx[1].find(isBridgeIntent4), () => "No bridge intent found");
-    const amount = hexToBigInt4(bridgeIntent.destAmount);
+    const bridgeIntent = assertEx11(tx[1].find(isBridgeIntent3), () => "No bridge intent found");
+    const amount = hexToBigInt6(bridgeIntent.destAmount);
     const srcAddress = getAddress(bridgeIntent.srcAddress);
     const destAddress = getAddress(bridgeIntent.destAddress);
-    const nonce = hexToBigInt4(await PayloadBuilder3.hash(tx[0]));
+    const nonce = hexToBigInt6(await PayloadBuilder5.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}] validating tx runner has sufficient ETH for gas`);
+    if (!await validateSufficientRunnerEthBalanceForGas(preparedTx, wallet, job)) {
+      throw new Error("Transaction runner does not have sufficient ETH to cover estimated gas (with buffer)");
+    }
+    await job.log(`[${hash}] validated tx runner has sufficient ETH for gas`);
     await job.log(`[${hash}] storing ETH preparedTx`);
     await stateMap.set(hash, {
       preparedTx
@@ -186,7 +464,9 @@ var createWorker2 = /* @__PURE__ */ __name((connection2, services) => {
     await job.log(`[${hash}] prepared ETH transaction`);
     return {};
   }, {
-    connection: connection2
+    connection: connection2,
+    telemetry: telemetry2,
+    prefix
   });
   worker.on("failed", (job, err) => {
     console.error(`[${name2}] Job ${job?.id} failed:`, err.message);
@@ -202,41 +482,64 @@ var EthTransactionPreparation = {
 };
 
 // src/queue/workers/EthTransactionSubmission.ts
-import { assertEx as assertEx6, isDefined as isDefined3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
+import { assertEx as assertEx13, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/sdk-js";
 import { Worker as Worker3 } from "bullmq";
+
+// src/queue/workers/util/submitEthTransaction.ts
+import { assertEx as assertEx12, hexToBigInt as hexToBigInt7, toEthAddress } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/sdk-js";
+import { isBridgeIntent as isBridgeIntent4 } from "@xyo-network/xl1-sdk";
+var submitEthTransaction = /* @__PURE__ */ __name(async (tx, bridgeableToken, bridge, wallet) => {
+  const xl1Transaction = assertEx12(tx[0], () => "No corresponding XL1 transaction found");
+  const bridgeIntent = assertEx12(tx[1].find(isBridgeIntent4), () => "No bridge intent found");
+  const srcAddress = toEthAddress(bridgeIntent.srcAddress);
+  const destAddress = toEthAddress(bridgeIntent.destAddress);
+  const amount = hexToBigInt7(bridgeIntent.destAmount);
+  const nonce = hexToBigInt7(await PayloadBuilder6.hash(xl1Transaction));
+  const bridgeTx = await bridge.connect(wallet).bridgeFromRemote(srcAddress, destAddress, amount, nonce);
+  const receipt = await bridgeTx.wait(1);
+  return receipt?.hash;
+}, "submitEthTransaction");
+
+// src/queue/workers/util/submitXl1Transaction.ts
+import { isAllowedBlockPayload } from "@xyo-network/xl1-sdk";
+var submitXl1Transaction = /* @__PURE__ */ __name(async (preparedTx, gateway) => {
+  const offChainPayloads = preparedTx[1].filter((p) => !isAllowedBlockPayload(p));
+  const result = await gateway.addTransactionToChain(preparedTx, offChainPayloads);
+  return result;
+}, "submitXl1Transaction");
+
+// src/queue/workers/EthTransactionSubmission.ts
 var name3 = "Submit ETH Transaction";
 var queueName3 = "eth-tx-submit";
-var createWorker3 = /* @__PURE__ */ __name((connection2, services) => {
-  const bridge = assertEx6(services?.bridge, () => "bridge service not provided");
-  const bridgeableToken = assertEx6(services?.bridgeableToken, () => "bridgeableToken service not provided");
-  const wallet = assertEx6(services?.wallet, () => "wallet service not provided");
-  const stateMap = assertEx6(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+var createWorker3 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const bridge = assertEx13(services?.bridge, () => "bridge service not provided");
+  const bridgeableToken = assertEx13(services?.bridgeableToken, () => "bridgeableToken service not provided");
+  const wallet = assertEx13(services?.wallet, () => "wallet service not provided");
+  const stateMap = assertEx13(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 = assertEx6(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const preparedTx = assertEx6(state?.preparedTx, () => `[${hash}] preparedTx not found`);
+    const hash = await PayloadBuilder7.hash(tx[0]);
+    const state = assertEx13(await stateMap.get(hash), () => `[${hash}] state not found`);
     const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined3(existingSubmissionHash)) {
+    if (isDefined7(existingSubmissionHash)) {
       await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
       return {
         submissionHash: existingSubmissionHash
       };
     }
     await job.log(`[${hash}] Submitting ETH tx`);
-    const submissionHash = assertEx6(await submitEthTransaction(tx, bridgeableToken, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`);
+    const submissionHash = assertEx13(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;
-    await stateMap.set(hash, state);
-    await job.log(`[${hash}] Stored ETH submissionHash`);
     return {
       submissionHash
     };
   }, {
     connection: connection2,
-    concurrency: 1
+    telemetry: telemetry2,
+    concurrency: 1,
+    prefix
   });
   worker.on("failed", (job, err) => {
     console.error(`[${name3}] Job ${job?.id} failed:`, err.message);
@@ -251,19 +554,41 @@ var EthTransactionSubmission = {
   queueName: queueName3
 };
 
-// src/queue/workers/Xl1ToEthBridgeParent.ts
+// src/queue/workers/EthTransactionSubmissionStorage.ts
+import { assertEx as assertEx14, isDefined as isDefined8 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/sdk-js";
 import { Worker as Worker4 } from "bullmq";
-var name4 = "Bridge XL1 to Ethereum";
-var queueName4 = "xl1-to-eth-bridge";
-var createWorker4 = /* @__PURE__ */ __name((connection2) => {
+var name4 = "Store ETH Transaction Submission";
+var queueName4 = "eth-tx-store-submission";
+var createWorker4 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const stateMap = assertEx14(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
   const worker = new Worker4(queueName4, async (job) => {
-    await job.log(`[${job.name}] start`);
-    await job.log(`[${job.name}] done`);
+    const { tx } = job.data;
+    const hash = await PayloadBuilder8.hash(tx[0]);
+    const state = assertEx14(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const { submissionHash: existingSubmissionHash } = state;
+    if (isDefined8(existingSubmissionHash)) {
+      await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`);
+      return {
+        submissionHash: existingSubmissionHash
+      };
+    }
+    const childrenValues = await job.getChildrenValues();
+    const jobKey = `${prefix}:${EthTransactionSubmission.queueName}:${hash}`;
+    const childValues = childrenValues?.[jobKey];
+    const submissionHash = childValues?.submissionHash;
+    const resolvedSubmissionHash = assertEx14(submissionHash, () => `[${hash}] child submissionHash not found in children values`);
+    await job.log(`[${hash}] Storing ETH submissionHash`);
+    state.submissionHash = resolvedSubmissionHash;
+    await stateMap.set(hash, state);
+    await job.log(`[${hash}] Stored ETH submissionHash`);
     return {
-      ok: true
+      submissionHash: resolvedSubmissionHash
     };
   }, {
-    connection: connection2
+    connection: connection2,
+    telemetry: telemetry2,
+    prefix
   });
   worker.on("failed", (job, err) => {
     console.error(`[${name4}] Job ${job?.id} failed:`, err.message);
@@ -272,34 +597,62 @@ var createWorker4 = /* @__PURE__ */ __name((connection2) => {
     console.error(`[${name4}] Worker error:`, err);
   });
 }, "createWorker");
-var Xl1ToEthBridgeParent = {
+var EthTransactionSubmissionStorage = {
   createWorker: createWorker4,
   name: name4,
   queueName: queueName4
 };
 
-// src/queue/workers/Xl1TransactionMonitor.ts
-import { assertEx as assertEx7, isDefined as isDefined4, isNull } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
-import { UnrecoverableError, Worker as Worker5 } from "bullmq";
-var name5 = "Monitor Submitted XL1 Transaction";
-var queueName5 = "xl1-tx-monitor";
-var createWorker5 = /* @__PURE__ */ __name((connection2, services) => {
-  const gateway = assertEx7(services?.gateway, () => "gateway service not provided");
-  const stateMap = assertEx7(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+// src/queue/workers/Xl1ToEthBridgeParent.ts
+import { Worker as Worker5 } from "bullmq";
+var name5 = "Bridge XL1 to Ethereum";
+var queueName5 = "xl1-to-eth-bridge";
+var createWorker5 = /* @__PURE__ */ __name((connection2, telemetry2) => {
   const worker = new Worker5(queueName5, async (job) => {
+    await job.log(`[${job.name}] start`);
+    await job.log(`[${job.name}] done`);
+    return {};
+  }, {
+    connection: connection2,
+    telemetry: telemetry2,
+    prefix
+  });
+  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 Xl1ToEthBridgeParent = {
+  createWorker: createWorker5,
+  name: name5,
+  queueName: queueName5
+};
+
+// src/queue/workers/Xl1TransactionMonitor.ts
+import { assertEx as assertEx15, isDefined as isDefined9, isNull } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/sdk-js";
+import { UnrecoverableError, Worker as Worker6 } from "bullmq";
+var name6 = "Monitor Submitted XL1 Transaction";
+var queueName6 = "xl1-tx-monitor";
+var createWorker6 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const gateway = assertEx15(services?.gateway, () => "gateway service not provided");
+  const stateMap = assertEx15(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const viewer = assertEx15(gateway.connection.viewer, () => "viewer not defined on gateway");
+  const worker = new Worker6(queueName6, async (job) => {
     const { tx } = job.data;
-    const hash = await PayloadBuilder5.hash(tx[0]);
-    const viewer = assertEx7(gateway.connection.viewer, () => `[${hash}] viewer not defined on gateway`);
-    const state = assertEx7(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const submissionHash = assertEx7(state?.submissionHash, () => `[${hash}] submissionHash not found`);
+    const hash = await PayloadBuilder9.hash(tx[0]);
+    const state = assertEx15(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const submissionHash = assertEx15(state.submissionHash, () => `[${hash}] submissionHash not found`);
     await job.log(`[${hash}] Checking for XL1 transaction inclusion on chain`);
-    const foundTx = await viewer.transactionByHash(submissionHash);
-    if (isDefined4(foundTx) && !isNull(foundTx)) {
+    const foundTx = await viewer.transaction.byHash(submissionHash);
+    if (isDefined9(foundTx) && !isNull(foundTx)) {
       await job.log(`[${hash}] Found transaction on chain`);
-      state.confirmationHash = await PayloadBuilder5.hash(foundTx[0]);
-      await stateMap.set(hash, state);
-      return {};
+      const submissionHash2 = await PayloadBuilder9.hash(foundTx[0]);
+      return {
+        submissionHash: submissionHash2
+      };
     }
     const currentBlockNumber = await viewer.currentBlockNumber();
     if (tx[0].exp < currentBlockNumber) {
@@ -309,32 +662,34 @@ var createWorker5 = /* @__PURE__ */ __name((connection2, services) => {
     await job.log(`[${hash}] Transaction not yet included, retrying later`);
     throw new Error(`[${hash}] Transaction not yet included`);
   }, {
-    connection: connection2
+    connection: connection2,
+    telemetry: telemetry2,
+    prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name5}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name6}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name5}] Worker error:`, err);
+    console.error(`[${name6}] Worker error:`, err);
   });
 }, "createWorker");
 var Xl1TransactionMonitor = {
-  createWorker: createWorker5,
-  name: name5,
-  queueName: queueName5
+  createWorker: createWorker6,
+  name: name6,
+  queueName: queueName6
 };
 
 // src/queue/workers/Xl1TransactionPreparation.ts
-import { assertEx as assertEx8 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/sdk-js";
-import { Worker as Worker6 } from "bullmq";
-var name6 = "Prepare XL1 Transaction";
-var queueName6 = "xl1-tx-prepare";
-var createWorker6 = /* @__PURE__ */ __name((connection2, services) => {
-  const stateMap = assertEx8(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
-  const worker = new Worker6(queueName6, async (job) => {
+import { assertEx as assertEx16 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/sdk-js";
+import { Worker as Worker7 } from "bullmq";
+var name7 = "Prepare XL1 Transaction";
+var queueName7 = "xl1-tx-prepare";
+var createWorker7 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const stateMap = assertEx16(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const worker = new Worker7(queueName7, async (job) => {
     const { tx } = job.data;
-    const hash = await PayloadBuilder6.hash(tx[0]);
+    const hash = await PayloadBuilder10.hash(tx[0]);
     await job.log(`[${hash}] preparing XL1 transaction`);
     const preparedTx = tx;
     await job.log(`[${hash}] storing XL1 preparedTx`);
@@ -343,39 +698,43 @@ var createWorker6 = /* @__PURE__ */ __name((connection2, services) => {
     });
     await job.log(`[${hash}] stored XL1 preparedTx`);
     await job.log(`[${hash}] prepared XL1 transaction`);
-    return {};
+    return {
+      preparedTx
+    };
   }, {
-    connection: connection2
+    connection: connection2,
+    telemetry: telemetry2,
+    prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name6}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name7}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name6}] Worker error:`, err);
+    console.error(`[${name7}] Worker error:`, err);
   });
 }, "createWorker");
 var Xl1TransactionPreparation = {
-  createWorker: createWorker6,
-  name: name6,
-  queueName: queueName6
+  createWorker: createWorker7,
+  name: name7,
+  queueName: queueName7
 };
 
 // src/queue/workers/Xl1TransactionSubmission.ts
-import { assertEx as assertEx9, isDefined as isDefined5 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/sdk-js";
-import { Worker as Worker7 } from "bullmq";
-var name7 = "Submit XL1 Transaction";
-var queueName7 = "xl1-tx-submit";
-var createWorker7 = /* @__PURE__ */ __name((connection2, services) => {
-  const gateway = assertEx9(services?.gateway, () => "gateway service not provided");
-  const stateMap = assertEx9(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
-  const worker = new Worker7(queueName7, async (job) => {
+import { assertEx as assertEx17, isDefined as isDefined10 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
+import { Worker as Worker8 } from "bullmq";
+var name8 = "Submit XL1 Transaction";
+var queueName8 = "xl1-tx-submit";
+var createWorker8 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const gateway = assertEx17(services?.gateway, () => "gateway service not provided");
+  const stateMap = assertEx17(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const worker = new Worker8(queueName8, async (job) => {
     const { tx } = job.data;
-    const hash = await PayloadBuilder7.hash(tx[0]);
-    const state = assertEx9(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const preparedTx = assertEx9(state?.preparedTx, () => `[${hash}] preparedTx not found`);
+    const hash = await PayloadBuilder11.hash(tx[0]);
+    const state = assertEx17(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const preparedTx = assertEx17(state?.preparedTx, () => `[${hash}] preparedTx not found`);
     const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined5(existingSubmissionHash)) {
+    if (isDefined10(existingSubmissionHash)) {
       await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
       return {
         submissionHash: existingSubmissionHash
@@ -384,33 +743,82 @@ var createWorker7 = /* @__PURE__ */ __name((connection2, services) => {
     await job.log(`[${hash}] Submitting XL1 tx`);
     const [submissionHash] = await submitXl1Transaction(preparedTx, gateway);
     await job.log(`[${hash}] Submitted XL1 tx`);
+    return {
+      submissionHash
+    };
+  }, {
+    connection: connection2,
+    telemetry: telemetry2,
+    prefix
+  });
+  worker.on("failed", (job, err) => {
+    console.error(`[${name8}] Job ${job?.id} failed:`, err.message);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name8}] Worker error:`, err);
+  });
+}, "createWorker");
+var Xl1TransactionSubmission = {
+  createWorker: createWorker8,
+  name: name8,
+  queueName: queueName8
+};
+
+// src/queue/workers/Xl1TransactionSubmissionStorage.ts
+import { assertEx as assertEx18, isDefined as isDefined11 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/sdk-js";
+import { Worker as Worker9 } from "bullmq";
+var name9 = "Store XL1 Transaction Submission";
+var queueName9 = "xl1-tx-store-submission";
+var createWorker9 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const stateMap = assertEx18(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const worker = new Worker9(queueName9, async (job) => {
+    const { tx } = job.data;
+    const hash = await PayloadBuilder12.hash(tx[0]);
+    const state = assertEx18(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const { submissionHash: existingSubmissionHash } = state;
+    if (isDefined11(existingSubmissionHash)) {
+      await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`);
+      return {
+        submissionHash: existingSubmissionHash
+      };
+    }
+    const childrenValues = await job.getChildrenValues();
+    const jobKey = `${prefix}:${Xl1TransactionSubmission.queueName}:${hash}`;
+    const childValues = childrenValues?.[jobKey];
+    const submissionHash = childValues?.submissionHash;
+    const resolvedSubmissionHash = assertEx18(submissionHash, () => `[${hash}] child submissionHash not found in children values`);
     await job.log(`[${hash}] Storing XL1 submissionHash`);
-    state.submissionHash = submissionHash;
+    state.submissionHash = resolvedSubmissionHash;
     await stateMap.set(hash, state);
     await job.log(`[${hash}] Stored XL1 submissionHash`);
     return {
-      submissionHash
+      submissionHash: resolvedSubmissionHash
     };
   }, {
-    connection: connection2
+    connection: connection2,
+    telemetry: telemetry2,
+    prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name7}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name9}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name7}] Worker error:`, err);
+    console.error(`[${name9}] Worker error:`, err);
   });
 }, "createWorker");
-var Xl1TransactionSubmission = {
-  createWorker: createWorker7,
-  name: name7,
-  queueName: queueName7
+var Xl1TransactionSubmissionStorage = {
+  createWorker: createWorker9,
+  name: name9,
+  queueName: queueName9
 };
 
 // src/queue/flows/createXl1ToEthBridgeJob.ts
+import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/sdk-js";
 var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) => {
-  const jobId = await PayloadBuilder8.hash(tx[0]);
+  const jobId = await PayloadBuilder13.hash(tx[0]);
   const flow = await flowProducer2.add({
+    // Step 0 (runs first as parent job)
     name: Xl1ToEthBridgeParent.name,
     queueName: Xl1ToEthBridgeParent.queueName,
     data: {
@@ -421,7 +829,7 @@ var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) =
     },
     children: [
       {
-        // Step 6 (runs after child completes)
+        // Step 8
         name: EthTransactionMonitor.name,
         queueName: EthTransactionMonitor.queueName,
         data: {
@@ -437,17 +845,25 @@ var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) =
         },
         children: [
           {
-            // Step 5
-            name: EthTransactionSubmission.name,
-            queueName: EthTransactionSubmission.queueName,
+            // Step 7
+            name: EthTransactionSubmissionStorage.name,
+            queueName: EthTransactionSubmissionStorage.queueName,
             data: {
               tx
             },
+            opts: {
+              jobId,
+              attempts: 60,
+              backoff: {
+                type: "fixed",
+                delay: 5e3
+              }
+            },
             children: [
               {
-                // Step 4
-                name: EthTransactionPreparation.name,
-                queueName: EthTransactionPreparation.queueName,
+                // Step 6
+                name: EthTransactionSubmission.name,
+                queueName: EthTransactionSubmission.queueName,
                 data: {
                   tx
                 },
@@ -456,9 +872,9 @@ var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) =
                 },
                 children: [
                   {
-                    // Step 3
-                    name: Xl1TransactionMonitor.name,
-                    queueName: Xl1TransactionMonitor.queueName,
+                    // Step 5
+                    name: EthTransactionPreparation.name,
+                    queueName: EthTransactionPreparation.queueName,
                     data: {
                       tx
                     },
@@ -472,26 +888,67 @@ var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) =
                     },
                     children: [
                       {
-                        // Step 2
-                        name: Xl1TransactionSubmission.name,
-                        queueName: Xl1TransactionSubmission.queueName,
+                        // Step 4
+                        name: Xl1TransactionMonitor.name,
+                        queueName: Xl1TransactionMonitor.queueName,
                         data: {
                           tx
                         },
                         opts: {
-                          jobId
+                          jobId,
+                          attempts: 60,
+                          backoff: {
+                            type: "fixed",
+                            delay: 5e3
+                          }
                         },
                         children: [
                           {
-                            // Step 1 (runs first as deepest child)
-                            name: Xl1TransactionPreparation.name,
-                            queueName: Xl1TransactionPreparation.queueName,
+                            // Step 3
+                            name: Xl1TransactionSubmissionStorage.name,
+                            queueName: Xl1TransactionSubmissionStorage.queueName,
                             data: {
                               tx
                             },
                             opts: {
-                              jobId
-                            }
+                              jobId,
+                              attempts: 60,
+                              backoff: {
+                                type: "fixed",
+                                delay: 5e3
+                              }
+                            },
+                            children: [
+                              {
+                                // Step 2
+                                name: Xl1TransactionSubmission.name,
+                                queueName: Xl1TransactionSubmission.queueName,
+                                data: {
+                                  tx
+                                },
+                                opts: {
+                                  jobId
+                                },
+                                children: [
+                                  {
+                                    // Step 1 (runs first as deepest child)
+                                    name: Xl1TransactionPreparation.name,
+                                    queueName: Xl1TransactionPreparation.queueName,
+                                    data: {
+                                      tx
+                                    },
+                                    opts: {
+                                      jobId,
+                                      attempts: 60,
+                                      backoff: {
+                                        type: "fixed",
+                                        delay: 5e3
+                                      }
+                                    }
+                                  }
+                                ]
+                              }
+                            ]
                           }
                         ]
                       }
@@ -508,10 +965,91 @@ var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) =
   return flow;
 }, "createXl1ToEthBridgeJob");
 
+// src/queue/getXl1ToEthQueueJobs.ts
+var getStatusQueueJobs = /* @__PURE__ */ __name(async (queues, jobId) => {
+  const [ethTransactionMonitorJob, ethTransactionPreparationJob, ethTransactionSubmissionJob, xl1ToEthBridgeParentJob, xl1TransactionMonitorJob, xl1TransactionPreparationJob, xl1TransactionSubmissionJob, xl1TransactionSubmissionStorageJob] = await Promise.all([
+    queues.ethTransactionMonitor.getJob(jobId),
+    queues.ethTransactionPreparation.getJob(jobId),
+    queues.ethTransactionSubmission.getJob(jobId),
+    queues.xl1ToEthBridgeParent.getJob(jobId),
+    queues.xl1TransactionMonitor.getJob(jobId),
+    queues.xl1TransactionPreparation.getJob(jobId),
+    queues.xl1TransactionSubmission.getJob(jobId),
+    queues.xl1TransactionSubmissionStorage.getJob(jobId)
+  ]);
+  return {
+    ethTransactionMonitorJob,
+    ethTransactionPreparationJob,
+    ethTransactionSubmissionJob,
+    xl1ToEthBridgeParentJob,
+    xl1TransactionMonitorJob,
+    xl1TransactionPreparationJob,
+    xl1TransactionSubmissionStorageJob,
+    xl1TransactionSubmissionJob
+  };
+}, "getStatusQueueJobs");
+
+// src/queue/getXl1ToEthQueues.ts
+import { Queue } from "bullmq";
+var xl1ToEthQueues;
+var getXl1ToEthQueues = /* @__PURE__ */ __name((config) => {
+  if (xl1ToEthQueues) return xl1ToEthQueues;
+  const connection2 = getConnection(config);
+  xl1ToEthQueues = {
+    ethTransactionMonitor: new Queue(EthTransactionMonitor.queueName, {
+      connection: connection2,
+      prefix
+    }),
+    ethTransactionPreparation: new Queue(EthTransactionPreparation.queueName, {
+      connection: connection2,
+      prefix
+    }),
+    ethTransactionSubmission: new Queue(EthTransactionSubmission.queueName, {
+      connection: connection2,
+      prefix
+    }),
+    xl1ToEthBridgeParent: new Queue(Xl1ToEthBridgeParent.queueName, {
+      connection: connection2,
+      prefix
+    }),
+    xl1TransactionMonitor: new Queue(Xl1TransactionMonitor.queueName, {
+      connection: connection2,
+      prefix
+    }),
+    xl1TransactionPreparation: new Queue(Xl1TransactionPreparation.queueName, {
+      connection: connection2,
+      prefix
+    }),
+    xl1TransactionSubmission: new Queue(Xl1TransactionSubmission.queueName, {
+      connection: connection2,
+      prefix
+    }),
+    xl1TransactionSubmissionStorage: new Queue(Xl1TransactionSubmissionStorage.queueName, {
+      connection: connection2,
+      prefix
+    })
+  };
+  return xl1ToEthQueues;
+}, "getXl1ToEthQueues");
+
+// src/queue/telemetry.ts
+import { isDefined as isDefined12 } from "@xylabs/sdk-js";
+import { BullMQOtel } from "bullmq-otel";
+var telemetry;
+var options = {
+  enableMetrics: true
+};
+var getTelemetry = /* @__PURE__ */ __name(() => {
+  if (isDefined12(telemetry)) return telemetry;
+  telemetry = new BullMQOtel(options);
+  return telemetry;
+}, "getTelemetry");
+
 // src/server/addFlowProducer.ts
 var addFlowProducer = /* @__PURE__ */ __name((app, config) => {
   const connection2 = getConnection(config);
-  const flowProducer2 = getFlowProducer(connection2);
+  const telemetry2 = getTelemetry();
+  const flowProducer2 = getFlowProducer(connection2, telemetry2);
   app.flowProducer = flowProducer2;
   return app;
 }, "addFlowProducer");
@@ -533,147 +1071,6 @@ var addInstrumentation = /* @__PURE__ */ __name(() => {
 // src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts
 import { requestHandlerValidator } from "@xylabs/express";
 import { BridgeSettingsZod } from "@xyo-network/chain-orchestration";
-
-// src/config/asChainId.ts
-import { asHex } from "@xylabs/sdk-js";
-var asChainId = /* @__PURE__ */ __name((value) => {
-  const chainId = asHex(value);
-  return chainId;
-}, "asChainId");
-
-// src/config/asToken.ts
-import { asAddress } from "@xylabs/sdk-js";
-var asToken = /* @__PURE__ */ __name((value) => {
-  const token = asAddress(value);
-  return token;
-}, "asToken");
-
-// src/config/getBridgeEscrowAddress.ts
-import { asAddress as asAddress2, assertEx as assertEx10 } from "@xylabs/sdk-js";
-var tryGetBridgeEscrowAddress = /* @__PURE__ */ __name((config) => {
-  const address = asAddress2(config.escrowAddress);
-  return address;
-}, "tryGetBridgeEscrowAddress");
-
-// src/config/getBridgeFeesAddress.ts
-import { asAddress as asAddress3, assertEx as assertEx11 } from "@xylabs/sdk-js";
-var tryGetBridgeFeesAddress = /* @__PURE__ */ __name((config) => {
-  const address = asAddress3(config.feesAddress);
-  return address;
-}, "tryGetBridgeFeesAddress");
-
-// src/config/getFeeStructure.ts
-var getFeeStructure = /* @__PURE__ */ __name((config) => {
-  const { feeFixed, feeRateBasisPoints } = config;
-  return {
-    feeFixed,
-    feeRateBasisPoints
-  };
-}, "getFeeStructure");
-
-// src/config/getMaxBridgeAmount.ts
-var getMaxBridgeAmount = /* @__PURE__ */ __name((config) => {
-  const { maxBridgeAmount } = config;
-  return maxBridgeAmount;
-}, "getMaxBridgeAmount");
-
-// src/config/getMinBridgeAmount.ts
-var getMinBridgeAmount = /* @__PURE__ */ __name((config) => {
-  const { minBridgeAmount } = config;
-  return minBridgeAmount;
-}, "getMinBridgeAmount");
-
-// src/config/getRemoteChainId.ts
-import { assertEx as assertEx12 } from "@xylabs/sdk-js";
-var getRemoteChainId = /* @__PURE__ */ __name((config) => {
-  const remoteChainId = assertEx12(asChainId(config.remoteChainId), () => "Invalid remote chain ID in config");
-  return remoteChainId;
-}, "getRemoteChainId");
-
-// src/config/getRemoteTokenAddress.ts
-import { assertEx as assertEx13 } from "@xylabs/sdk-js";
-var getRemoteTokenAddress = /* @__PURE__ */ __name((config) => {
-  const token = asToken(config.remoteTokenAddress);
-  return assertEx13(token, () => "Remote token address is not defined in bridge configuration");
-}, "getRemoteTokenAddress");
-
-// src/config/getBridgeWalletAccount.ts
-import { isDefined as isDefined6, isUndefined } from "@xylabs/sdk-js";
-import { HDWallet } from "@xyo-network/wallet";
-import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from "@xyo-network/xl1-sdk";
-var accountServiceSingleton;
-var getBridgeWalletAccount = /* @__PURE__ */ __name(async (config) => {
-  if (accountServiceSingleton) return accountServiceSingleton;
-  let walletPhrase = config.mnemonic;
-  if (isUndefined(walletPhrase)) {
-    console.log("[Bridge] No wallet mnemonic specified!");
-    const randomMnemonic = HDWallet.generateMnemonic();
-    console.log(`[Bridge] Using randomly generated mnemonic:
-    
-${randomMnemonic}
-      
-    `);
-    walletPhrase = randomMnemonic;
-  }
-  const wallet = await generateXyoBaseWalletFromPhrase(walletPhrase);
-  const account = await wallet.derivePath(ADDRESS_INDEX.XYO);
-  accountServiceSingleton = account;
-  return accountServiceSingleton;
-}, "getBridgeWalletAccount");
-
-// src/config/getTransferAddresses.ts
-var getTransferAddresses = /* @__PURE__ */ __name(async (config) => {
-  const escrowAddress = tryGetBridgeEscrowAddress(config) ?? (await getBridgeWalletAccount(config)).address;
-  const feesAddress = tryGetBridgeFeesAddress(config) ?? (await getBridgeWalletAccount(config)).address;
-  return {
-    escrowAddress,
-    feesAddress
-  };
-}, "getTransferAddresses");
-
-// src/config/getXl1ChainId.ts
-import { assertEx as assertEx14, isDefined as isDefined7 } from "@xylabs/sdk-js";
-var getXl1ChainId = /* @__PURE__ */ __name((config) => {
-  const xl1ChainId = config.xl1ChainId;
-  if (isDefined7(xl1ChainId)) {
-    return assertEx14(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
-  }
-  return assertEx14(asChainId(config.chain.id), () => "Invalid chain.id in config");
-}, "getXl1ChainId");
-
-// src/config/getXl1TokenAddress.ts
-import { isDefined as isDefined8 } from "@xylabs/sdk-js";
-var getXl1TokenAddress = /* @__PURE__ */ __name((config) => {
-  const token = asToken(config.xl1TokenAddress);
-  if (isDefined8(token)) return token;
-  return getXl1ChainId(config);
-}, "getXl1TokenAddress");
-
-// src/config/getBridgeSettings.ts
-var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
-  const { feeFixed, feeRateBasisPoints } = getFeeStructure(config);
-  const { feesAddress, escrowAddress } = await getTransferAddresses(config);
-  const maxBridgeAmount = getMaxBridgeAmount(config);
-  const minBridgeAmount = getMinBridgeAmount(config);
-  const remoteChainId = getRemoteChainId(config);
-  const remoteTokenAddress = getRemoteTokenAddress(config);
-  const xl1TokenAddress = getXl1TokenAddress(config);
-  const xl1ChainId = getXl1ChainId(config);
-  return {
-    feeFixed,
-    feeRateBasisPoints,
-    feesAddress,
-    escrowAddress,
-    maxBridgeAmount,
-    minBridgeAmount,
-    remoteChainId,
-    remoteTokenAddress,
-    xl1TokenAddress,
-    xl1ChainId
-  };
-}, "getBridgeSettings");
-
-// src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts
 var BridgeConfigResponseZod = BridgeSettingsZod;
 var validateRequest = requestHandlerValidator({
   response: BridgeConfigResponseZod
@@ -703,18 +1100,18 @@ var makeBridgeConfigRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
 import { requestHandlerValidator as requestHandlerValidator2 } from "@xylabs/express";
-import { toAddress, toHex } from "@xylabs/sdk-js";
+import { toAddress as toAddress2, toHex as toHex2 } from "@xylabs/sdk-js";
 import { PayloadZodStrictOfSchema } from "@xyo-network/sdk-js";
 import { BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema } from "@xyo-network/xl1-sdk";
 import { z } from "zod";
 
 // src/server/routes/bridge/routeDefinitions/pathParams/ChainIdPathParam.ts
-import { asHex as asHex2, HexZod, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { asHex as asHex2, HexZod, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
 var getRemoteChainIdZod = /* @__PURE__ */ __name((config) => {
   const remoteChainId = getRemoteChainId(config);
   return HexZod.superRefine((val, ctx) => {
     const chainId = asHex2(val);
-    if (isUndefined2(chainId)) {
+    if (isUndefined3(chainId)) {
       ctx.addIssue("Not a valid chain id");
       return;
     }
@@ -748,14 +1145,14 @@ var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
       const observation = {
         schema: BridgeDestinationObservationSchema,
         dest: xl1ChainId,
-        destAddress: toAddress("0xabc"),
-        destAmount: toHex("0x100"),
+        destAddress: toAddress2("0xabc"),
+        destAmount: toHex2("0x100"),
         destToken: xl1TokenAddress,
         src: remoteChainId,
-        srcAddress: toAddress("0x123"),
-        srcAmount: toHex("0x200"),
+        srcAddress: toAddress2("0x123"),
+        srcAmount: toHex2("0x200"),
         srcToken: remoteTokenAddress,
-        destConfirmation: toHex("0x9999")
+        destConfirmation: toHex2("0x9999")
       };
       res.json(observation);
     })
@@ -764,118 +1161,9 @@ var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
 import { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
-import { PayloadBuilder as PayloadBuilder12, PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder14, PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/sdk-js";
 import { BridgeIntentFieldsZod, BridgeIntentSchema as BridgeIntentSchema2, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, SignedTransactionBoundWitnessZod, TransferZod } from "@xyo-network/xl1-sdk";
 import { z as z2 } from "zod";
-
-// src/util/calculateBridgeFees.ts
-import { hexToBigInt as hexToBigInt5, toHex as toHex2 } from "@xylabs/sdk-js";
-var calculateBridgeFees = /* @__PURE__ */ __name((srcAmount, feeStructure) => {
-  const { feeFixed, feeRateBasisPoints } = feeStructure;
-  const srcAmountBigInt = hexToBigInt5(srcAmount);
-  const feeFixedBigInt = hexToBigInt5(feeFixed);
-  const feeVariableBigInt = srcAmountBigInt * BigInt(feeRateBasisPoints) / 10000n;
-  const feeVariable = toHex2(feeVariableBigInt);
-  const feeTotalBigInt = feeFixedBigInt + feeVariableBigInt;
-  const destAmountBigInt = srcAmountBigInt > feeTotalBigInt ? srcAmountBigInt - feeTotalBigInt : 0n;
-  const destAmount = toHex2(destAmountBigInt);
-  return {
-    feeFixed,
-    feeVariable,
-    srcAmount
-  };
-}, "calculateBridgeFees");
-
-// src/util/createBridgeTransfer.ts
-import { hexToBigInt as hexToBigInt6 } from "@xylabs/sdk-js";
-import { createTransferPayload } from "@xyo-network/xl1-sdk";
-var createBridgeTransfer = /* @__PURE__ */ __name((sender, srcAmount, escrowAddress, feesAddress, context) => {
-  const { feeFixed, feeVariable } = context;
-  const escrowAmount = hexToBigInt6(srcAmount);
-  const feesAmount = hexToBigInt6(feeFixed) + hexToBigInt6(feeVariable);
-  const transfers = escrowAddress === feesAddress ? {
-    [feesAddress]: escrowAmount + feesAmount
-  } : {
-    [escrowAddress]: escrowAmount,
-    [feesAddress]: feesAmount
-  };
-  const transfer = createTransferPayload(sender, transfers, context);
-  return transfer;
-}, "createBridgeTransfer");
-
-// src/util/generateBridgeEstimate.ts
-import { toAddress as toAddress2 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/sdk-js";
-import { BridgeIntentSchema } from "@xyo-network/xl1-sdk";
-import { v4 } from "uuid";
-var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount, destAddress, config, nonceOverride) => {
-  const { escrowAddress, feeFixed, feeRateBasisPoints, feesAddress, remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
-  const sender = toAddress2(srcAddress);
-  const fees = calculateBridgeFees(srcAmount, {
-    feeFixed,
-    feeRateBasisPoints
-  });
-  const nonce = nonceOverride ?? v4();
-  const bridgeIntentFields = {
-    // Source
-    src: xl1ChainId,
-    srcAddress: sender,
-    srcAmount,
-    srcToken: xl1TokenAddress,
-    // Destination
-    dest: remoteChainId,
-    destAddress,
-    destAmount: srcAmount,
-    destToken: remoteTokenAddress,
-    nonce
-  };
-  const bridgeIntent = new PayloadBuilder9({
-    schema: BridgeIntentSchema
-  }).fields(bridgeIntentFields).build();
-  const transfer = createBridgeTransfer(sender, srcAmount, escrowAddress, feesAddress, fees);
-  return [
-    bridgeIntent,
-    transfer
-  ];
-}, "generateBridgeEstimate");
-
-// src/util/validateBridgeEstimateExact.ts
-import { isUndefined as isUndefined3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/sdk-js";
-var validateBridgeEstimateExact = /* @__PURE__ */ __name(async (intent, transfer, config) => {
-  const { srcAddress, srcAmount, destAddress } = intent;
-  const [calculatedIntent, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
-  if (isUndefined3(calculatedIntent) || isUndefined3(calculatedTransfer)) return false;
-  const { nonce: expectedIntentNonce, ...expectedIntentStatic } = calculatedIntent;
-  const { nonce: actualIntentNonce, ...actualIntentStatic } = intent;
-  if (await PayloadBuilder10.dataHash(expectedIntentStatic) !== await PayloadBuilder10.dataHash(actualIntentStatic)) return false;
-  const { epoch: expectedTransferEpoch, ...expectedTransferStatic } = calculatedTransfer;
-  const { epoch: actualTransferEpoch, ...actualTransferStatic } = transfer;
-  if (await PayloadBuilder10.dataHash(expectedTransferStatic) !== await PayloadBuilder10.dataHash(actualTransferStatic)) return false;
-  return true;
-}, "validateBridgeEstimateExact");
-
-// src/util/validateBridgeTransaction.ts
-import { asAddress as asAddress4, isDefined as isDefined9 } from "@xylabs/sdk-js";
-import { addressesContains, BoundWitnessValidator, payloadHashesContainsAll } from "@xyo-network/boundwitness-validator";
-import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
-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 (isDefined9(errors) && errors.length > 0) return false;
-  const sender = asAddress4(srcAddress, true);
-  if (!addressesContains(signedTxBw, sender)) return false;
-  const hashes = await PayloadBuilder11.hashes([
-    intent,
-    transfer
-  ]);
-  if (!payloadHashesContainsAll(signedTxBw, hashes)) return false;
-  return true;
-}, "validateBridgeTransaction");
-
-// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
 var BridgeToRemoteBodyZod = z2.tuple([
   SignedTransactionBoundWitnessZod,
   PayloadZodLooseOfSchema(BridgeIntentSchema2).extend(BridgeIntentFieldsZod.shape),
@@ -897,6 +1185,7 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
     handlers: validateRequest2(async (req, res) => {
       const [signedTxBw, bridgeIntent, transfer] = req.body;
       const { flowProducer: flowProducer2 } = req.app;
+      const { gateway } = req.app.services;
       const transactionValid = await validateBridgeTransaction(signedTxBw, bridgeIntent, transfer, config);
       if (!transactionValid) {
         res.status(400).send();
@@ -907,6 +1196,11 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
         res.status(400).send();
         return;
       }
+      const sufficientBalance = await validateSufficientXL1SourceAddressBalance(bridgeIntent, gateway, config);
+      if (!sufficientBalance) {
+        res.status(400).send();
+        return;
+      }
       const singedHydratedTransaction = [
         signedTxBw,
         [
@@ -915,14 +1209,14 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
         ]
       ];
       await createXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction);
-      const srcConfirmation = await PayloadBuilder12.hash(signedTxBw);
+      const srcConfirmation = await PayloadBuilder14.hash(signedTxBw);
       const bridgeCommonFieldsZod = z2.object({}).extend(BridgeSourceObservationFieldsZod.shape);
       const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent);
       const bridgeObservationFields = {
         ...bridgeCommonFields,
         srcConfirmation
       };
-      const bridgeObservation = new PayloadBuilder12({
+      const bridgeObservation = new PayloadBuilder14({
         schema: BridgeSourceObservationSchema
       }).fields(bridgeObservationFields).build();
       res.json(bridgeObservation);
@@ -932,7 +1226,7 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
 import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
-import { assertEx as assertEx15, toAddress as toAddress3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx19, toAddress as toAddress3 } from "@xylabs/sdk-js";
 import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3 } from "@xyo-network/sdk-js";
 import { BridgeIntentFieldsZod as BridgeIntentFieldsZod2, BridgeIntentSchema as BridgeIntentSchema3, buildUnsignedTransaction, toXL1BlockNumber, TransactionBoundWitnessZod, TransferZod as TransferZod2 } from "@xyo-network/xl1-sdk";
 import { z as z3 } from "zod";
@@ -963,7 +1257,7 @@ var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) =
       const { srcAddress, srcAmount, destAddress } = req.body;
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
       const sender = toAddress3(srcAddress);
-      const viewer = assertEx15(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const viewer = assertEx19(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);
@@ -983,10 +1277,9 @@ var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) =
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteStatus.ts
 import { requestHandlerValidator as requestHandlerValidator5 } from "@xylabs/express";
-import { asHex as asHex3, isDefined as isDefined10 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder13, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema4 } from "@xyo-network/sdk-js";
+import { asHex as asHex3, isDefined as isDefined13 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder15, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema4 } from "@xyo-network/sdk-js";
 import { asBridgeIntent, BridgeDestinationObservationFieldsZod as BridgeDestinationObservationFieldsZod2, BridgeDestinationObservationSchema as BridgeDestinationObservationSchema2, BridgeIntentFieldsZod as BridgeIntentFieldsZod3, BridgeIntentSchema as BridgeIntentSchema4, BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod2, BridgeSourceObservationSchema as BridgeSourceObservationSchema2, isBridgeIntent as isBridgeIntent5 } from "@xyo-network/xl1-sdk";
-import { Queue } from "bullmq";
 import { z as z4 } from "zod";
 var BridgeIntentResponseZod = PayloadZodStrictOfSchema4(BridgeIntentSchema4).extend(BridgeIntentFieldsZod3.shape);
 var BridgeSourceResponseZod = PayloadZodStrictOfSchema4(BridgeSourceObservationSchema2).extend(BridgeSourceObservationFieldsZod2.shape);
@@ -1006,55 +1299,6 @@ var BridgeToRemoteStatusResponseZod = z4.union([
     BridgeDestinationResponseZod
   ])
 ]);
-var statusQueues;
-var getStatusQueues = /* @__PURE__ */ __name((config) => {
-  if (statusQueues) return statusQueues;
-  const connection2 = getConnection(config);
-  statusQueues = {
-    ethTransactionMonitor: new Queue(EthTransactionMonitor.queueName, {
-      connection: connection2
-    }),
-    ethTransactionPreparation: new Queue(EthTransactionPreparation.queueName, {
-      connection: connection2
-    }),
-    ethTransactionSubmission: new Queue(EthTransactionSubmission.queueName, {
-      connection: connection2
-    }),
-    xl1ToEthBridgeParent: new Queue(Xl1ToEthBridgeParent.queueName, {
-      connection: connection2
-    }),
-    xl1TransactionMonitor: new Queue(Xl1TransactionMonitor.queueName, {
-      connection: connection2
-    }),
-    xl1TransactionPreparation: new Queue(Xl1TransactionPreparation.queueName, {
-      connection: connection2
-    }),
-    xl1TransactionSubmission: new Queue(Xl1TransactionSubmission.queueName, {
-      connection: connection2
-    })
-  };
-  return statusQueues;
-}, "getStatusQueues");
-var getStatusQueueJobs = /* @__PURE__ */ __name(async (queues, jobId) => {
-  const [ethTransactionMonitorJob, ethTransactionPreparationJob, ethTransactionSubmissionJob, xl1ToEthBridgeParentJob, xl1TransactionMonitorJob, xl1TransactionPreparationJob, xl1TransactionSubmissionJob] = await Promise.all([
-    queues.ethTransactionMonitor.getJob(jobId),
-    queues.ethTransactionPreparation.getJob(jobId),
-    queues.ethTransactionSubmission.getJob(jobId),
-    queues.xl1ToEthBridgeParent.getJob(jobId),
-    queues.xl1TransactionMonitor.getJob(jobId),
-    queues.xl1TransactionPreparation.getJob(jobId),
-    queues.xl1TransactionSubmission.getJob(jobId)
-  ]);
-  return {
-    ethTransactionMonitorJob,
-    ethTransactionPreparationJob,
-    ethTransactionSubmissionJob,
-    xl1ToEthBridgeParentJob,
-    xl1TransactionMonitorJob,
-    xl1TransactionPreparationJob,
-    xl1TransactionSubmissionJob
-  };
-}, "getStatusQueueJobs");
 var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
   const params = z4.object({
     chainId: getRemoteChainIdZod(config),
@@ -1070,41 +1314,42 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
     handlers: validateRequest2(async (req, res) => {
       const jobId = req.params.nonce;
       const result = [];
-      const queues = getStatusQueues(config);
+      const queues = getXl1ToEthQueues(config);
       const statusQueueJobs = await getStatusQueueJobs(queues, jobId);
-      const tx = Object.values(statusQueueJobs).map((job) => job?.data?.tx).find((tx2) => isDefined10(tx2));
+      const tx = statusQueueJobs.xl1ToEthBridgeParentJob?.data?.tx;
       if (!tx) return res.sendStatus(404);
       const bridgeIntent = tx[1].find(isBridgeIntent5);
       if (!bridgeIntent) return res.sendStatus(404);
-      result[0] = asBridgeIntent(PayloadBuilder13.omitMeta(bridgeIntent));
+      result[0] = asBridgeIntent(PayloadBuilder15.omitMeta(bridgeIntent));
       const { xl1TransactionMonitorJob } = statusQueueJobs;
       const xl1MonitorState = xl1TransactionMonitorJob ? await xl1TransactionMonitorJob.getState() : void 0;
-      const srcConfirmation = asHex3(jobId);
-      if (xl1MonitorState === "completed" && isDefined10(srcConfirmation)) {
-        const bridgeCommonFieldsZod = z4.object({}).extend(BridgeSourceObservationFieldsZod2.shape);
-        const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent);
-        const observation = {
-          schema: BridgeSourceObservationSchema2,
-          ...bridgeCommonFields,
-          srcConfirmation
-        };
-        result[1] = observation;
+      if (xl1MonitorState === "completed") {
+        const srcConfirmation = xl1TransactionMonitorJob?.returnvalue?.submissionHash;
+        if (isDefined13(srcConfirmation)) {
+          const schema = BridgeSourceObservationSchema2;
+          const bridgeSourceObservationFields = BridgeSourceObservationFieldsZod2.parse(bridgeIntent);
+          const observation = {
+            schema,
+            ...bridgeSourceObservationFields,
+            srcConfirmation
+          };
+          result[1] = observation;
+        }
       }
       const { ethTransactionMonitorJob } = statusQueueJobs;
       const ethMonitorState = ethTransactionMonitorJob ? await ethTransactionMonitorJob.getState() : void 0;
-      const blockHash = ethTransactionMonitorJob?.returnvalue?.blockHash;
-      const destConfirmation = asHex3(blockHash);
-      if (ethMonitorState === "completed" && isDefined10(blockHash)) {
-        const bridgeDestinationFieldsZod = z4.object({}).extend(BridgeDestinationObservationFieldsZod2.shape);
-        const bridgeDestinationFields = bridgeDestinationFieldsZod.parse({
-          ...bridgeIntent,
-          destConfirmation
-        });
-        const observation = {
-          schema: BridgeDestinationObservationSchema2,
-          ...bridgeDestinationFields
-        };
-        result[2] = observation;
+      if (ethMonitorState === "completed") {
+        const destConfirmation = asHex3(ethTransactionMonitorJob?.returnvalue?.submissionHash);
+        if (isDefined13(destConfirmation)) {
+          const schema = BridgeDestinationObservationSchema2;
+          const bridgeDestinationObservationFields = BridgeDestinationObservationFieldsZod2.parse(bridgeIntent);
+          const observation = {
+            schema,
+            ...bridgeDestinationObservationFields,
+            destConfirmation
+          };
+          result[2] = observation;
+        }
       }
       res.json(result);
     })
@@ -1157,10 +1402,10 @@ var getApp = /* @__PURE__ */ __name((config, gateway) => {
 }, "getApp");
 
 // src/services/getServices.ts
-import { assertEx as assertEx16, isDefined as isDefined11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx20, isDefined as isDefined14 } from "@xylabs/sdk-js";
 import { initEvmProvider } from "@xyo-network/chain-orchestration";
+import { HDWallet as HDWallet2 } from "@xyo-network/sdk-js";
 import { BridgeableToken__factory, LiquidityPoolBridge__factory } from "@xyo-network/typechain";
-import { HDWallet as HDWallet2 } from "@xyo-network/wallet";
 import { getAddress as getAddress2, Wallet } from "ethers";
 
 // src/services/getIterableMap.ts
@@ -1202,12 +1447,12 @@ var getServices = /* @__PURE__ */ __name(async (context, gateway) => {
   const xl1TxStateMap = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_xl1_tx_state");
   const provider = await initEvmProvider(context);
   const { remoteBridgeContractAddress, remoteChainWalletPrivateKey, remoteTokenAddress, mnemonic } = config;
-  const account = isDefined11(mnemonic) ? await HDWallet2.fromPhrase(mnemonic) : await HDWallet2.random();
+  const account = isDefined14(mnemonic) ? await HDWallet2.fromPhrase(mnemonic) : await HDWallet2.random();
   const wallet = new Wallet(remoteChainWalletPrivateKey, provider);
   const bridgeableToken = BridgeableToken__factory.connect(getAddress2(remoteTokenAddress), wallet);
   const bridge = LiquidityPoolBridge__factory.connect(getAddress2(remoteBridgeContractAddress), wallet);
   const bridgeOwner = await bridge.owner();
-  assertEx16(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
+  assertEx20(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
   return {
     account,
     bridge,
@@ -1223,7 +1468,8 @@ var getServices = /* @__PURE__ */ __name(async (context, gateway) => {
 // src/server/addWorkers.ts
 var addWorkers = /* @__PURE__ */ __name((config, services) => {
   const connection2 = getConnection(config);
-  createWorkers(connection2, services);
+  const telemetry2 = getTelemetry();
+  createWorkers(connection2, telemetry2, services);
 }, "addWorkers");
 
 // src/server/server.ts
@@ -1233,6 +1479,7 @@ var getServer = /* @__PURE__ */ __name(async (context, gateway) => {
   const { port } = config;
   const app = getApp(config, gateway);
   const services = await getServices(context, gateway);
+  app.services = services;
   addWorkers(config, services);
   const server = app.listen(port, hostname, () => logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`));
   server.setTimeout(2e4);