@xyo-network/chain-bridge 1.20.28 → 1.21.0

package/dist/node/index.mjs

@@ -3,143 +3,15 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/BridgeActor.ts
 import { creatable } from "@xylabs/sdk-js";
-import { asBridgeConfigContext } from "@xyo-network/chain-orchestration";
-import { ActorV3, XyoGatewayRunnerMoniker } from "@xyo-network/xl1-sdk";
+import { ActorV3, asBridgeConfigContext } from "@xyo-network/chain-orchestration";
+import { XyoGatewayRunnerMoniker, XyoViewerMoniker } from "@xyo-network/xl1-sdk";
 
-// src/monitoring/createBalanceMonitor.ts
-var DEFAULT_INTERVAL_MS = 6e4;
-var WEI_PER_GWEI = 10n ** 9n;
-var TOKEN_DECIMALS = 10n ** 18n;
-function createBalanceMonitor(config) {
-  const { account, bridge, bridgeableToken, gateway, meter, provider, wallet, intervalMs = DEFAULT_INTERVAL_MS } = config;
-  let timer;
-  const ethWalletGasBalance = meter.createGauge("bridge_eth_wallet_gas_balance_gwei", {
-    description: "ETH balance of the bridge runner wallet (in gwei)",
-    unit: "gwei"
-  });
-  const liquidityTokenBalance = meter.createGauge("bridge_eth_liquidity_token_balance", {
-    description: "ERC-20 token balance of the liquidity source (in whole tokens)",
-    unit: "tokens"
-  });
-  const liquidityTokenAllowance = meter.createGauge("bridge_eth_liquidity_token_allowance", {
-    description: "ERC-20 token allowance from liquidity source to bridge contract (in whole tokens)",
-    unit: "tokens"
-  });
-  const xl1AccountBalance = meter.createGauge("bridge_xl1_account_balance", {
-    description: "XL1 native balance of the bridge account (in whole XL1)",
-    unit: "xl1"
-  });
-  const walletAddress = wallet.address;
-  async function poll() {
-    try {
-      const balance = await provider.getBalance(walletAddress);
-      ethWalletGasBalance.record(Number(balance / WEI_PER_GWEI), {
-        address: walletAddress
-      });
-    } catch (err) {
-      console.error("[BalanceMonitor] Failed to read ETH wallet gas balance:", err);
-    }
-    try {
-      const liquiditySourceAddress = await bridge.liquiditySource();
-      const balance = await bridgeableToken.balanceOf(liquiditySourceAddress);
-      liquidityTokenBalance.record(Number(balance / TOKEN_DECIMALS), {
-        address: liquiditySourceAddress
-      });
-    } catch (err) {
-      console.error("[BalanceMonitor] Failed to read liquidity source token balance:", err);
-    }
-    try {
-      const liquiditySourceAddress = await bridge.liquiditySource();
-      const bridgeAddress = await bridge.getAddress();
-      const allowance = await bridgeableToken.allowance(liquiditySourceAddress, bridgeAddress);
-      liquidityTokenAllowance.record(Number(allowance / TOKEN_DECIMALS), {
-        address: liquiditySourceAddress
-      });
-    } catch (err) {
-      console.error("[BalanceMonitor] Failed to read liquidity source token allowance:", err);
-    }
-    try {
-      const viewer = gateway.connection.viewer;
-      if (viewer) {
-        const balance = await viewer.account.balance.accountBalance(account.address);
-        xl1AccountBalance.record(Number(balance / TOKEN_DECIMALS), {
-          address: account.address.toString()
-        });
-      }
-    } catch (err) {
-      console.error("[BalanceMonitor] Failed to read XL1 account balance:", err);
-    }
-  }
-  __name(poll, "poll");
-  return {
-    start() {
-      void poll();
-      timer = setInterval(() => void poll(), intervalMs);
-    },
-    stop() {
-      if (timer) {
-        clearInterval(timer);
-        timer = void 0;
-      }
-    }
-  };
-}
-__name(createBalanceMonitor, "createBalanceMonitor");
-
-// src/monitoring/createQueueMetrics.ts
-var DEFAULT_INTERVAL_MS2 = 3e4;
-function createQueueMetrics(config) {
-  const { meter, queues, intervalMs = DEFAULT_INTERVAL_MS2 } = config;
-  let timer;
-  const waitingGauge = meter.createGauge("bridge_queue_waiting", {
-    description: "Number of waiting jobs in the bridge queue"
-  });
-  const activeGauge = meter.createGauge("bridge_queue_active", {
-    description: "Number of active jobs in the bridge queue"
-  });
-  const completedGauge = meter.createGauge("bridge_queue_completed", {
-    description: "Number of completed jobs in the bridge queue"
-  });
-  const failedGauge = meter.createGauge("bridge_queue_failed", {
-    description: "Number of failed jobs in the bridge queue"
-  });
-  const delayedGauge = meter.createGauge("bridge_queue_delayed", {
-    description: "Number of delayed jobs in the bridge queue"
-  });
-  async function poll() {
-    for (const [name10, queue] of Object.entries(queues)) {
-      try {
-        const counts = await queue.getJobCounts("waiting", "active", "completed", "failed", "delayed");
-        const attrs = {
-          queue_name: name10
-        };
-        waitingGauge.record(counts.waiting ?? 0, attrs);
-        activeGauge.record(counts.active ?? 0, attrs);
-        completedGauge.record(counts.completed ?? 0, attrs);
-        failedGauge.record(counts.failed ?? 0, attrs);
-        delayedGauge.record(counts.delayed ?? 0, attrs);
-      } catch (err) {
-        console.error(`[QueueMetrics] Failed to read job counts for queue ${name10}:`, err);
-      }
-    }
-  }
-  __name(poll, "poll");
-  return {
-    start() {
-      void poll();
-      timer = setInterval(() => void poll(), intervalMs);
-    },
-    stop() {
-      if (timer) {
-        clearInterval(timer);
-        timer = void 0;
-      }
-    }
-  };
-}
-__name(createQueueMetrics, "createQueueMetrics");
+// src/server/app.ts
+import { standardErrors } from "@xylabs/express";
+import { sharedMiddleware } from "@xyo-network/chain-orchestration";
+import express from "express";
 
-// src/queue/connection.ts
+// src/services/queue/connection.ts
 import { isDefined } from "@xylabs/sdk-js";
 import { Redis } from "ioredis";
 var connection;
@@ -155,14 +27,14 @@ var getConnection = /* @__PURE__ */ __name((config) => {
   return connection;
 }, "getConnection");
 
-// src/queue/flowProducer.ts
+// src/services/queue/flowProducer.ts
 import { isDefined as isDefined2 } from "@xylabs/sdk-js";
 import { FlowProducer } from "bullmq";
 
-// src/queue/prefix.ts
+// src/services/queue/prefix.ts
 var prefix = "xl1-bridge";
 
-// src/queue/flowProducer.ts
+// src/services/queue/flowProducer.ts
 var flowProducer;
 var getFlowProducer = /* @__PURE__ */ __name((connection2, telemetry2) => {
   if (isDefined2(flowProducer)) return flowProducer;
@@ -174,21 +46,210 @@ var getFlowProducer = /* @__PURE__ */ __name((connection2, telemetry2) => {
   return flowProducer;
 }, "getFlowProducer");
 
-// src/queue/workers/EthTransactionMonitor.ts
-import { assertEx } from "@xylabs/sdk-js";
+// src/services/queue/workers/EthEventVerification.ts
+import { assertEx as assertEx2, isNull } from "@xylabs/sdk-js";
+import { UnrecoverableError, Worker } from "bullmq";
+
+// src/services/queue/workers/util/buildEthToXl1ReserveTx.ts
+import { toHex } from "@xylabs/sdk-js";
 import { PayloadBuilder } from "@xyo-network/sdk-js";
-import { Worker } from "bullmq";
-var name = "Monitor Submitted ETH Transaction";
-var queueName = "eth-tx-monitor";
+import { BridgeIntentSchema, BridgeSourceObservationSchema, buildTransaction, createTransferPayload } from "@xyo-network/xl1-sdk";
+async function buildEthToXl1ReserveTx(options2) {
+  const { amount, bridgeAccount, bridgeId, destAddress, evmChainId, evmContractAddress, evmSrcAddress, evmTokenAddress, evmTxHash, exp, nbf, xl1ChainId, xl1TokenAddress } = options2;
+  const amountHex = toHex(amount);
+  const nonce = `evm:${evmChainId.toLowerCase()}:${evmContractAddress.toLowerCase()}:${bridgeId.toString()}`;
+  const transfer = createTransferPayload(bridgeAccount.address, {
+    [destAddress]: amount
+  });
+  const intent = new PayloadBuilder({
+    schema: BridgeIntentSchema
+  }).fields({
+    dest: xl1ChainId,
+    destAddress,
+    destAmount: amountHex,
+    destToken: xl1TokenAddress,
+    nonce,
+    src: evmChainId,
+    srcAddress: evmSrcAddress,
+    srcAmount: amountHex,
+    srcToken: evmTokenAddress
+  }).build();
+  const sourceObservation = new PayloadBuilder({
+    schema: BridgeSourceObservationSchema
+  }).fields({
+    dest: xl1ChainId,
+    destAddress,
+    destAmount: amountHex,
+    destToken: xl1TokenAddress,
+    src: evmChainId,
+    srcAddress: evmSrcAddress,
+    srcAmount: amountHex,
+    srcConfirmation: evmTxHash,
+    srcToken: evmTokenAddress
+  }).build();
+  return buildTransaction(xl1ChainId, [
+    transfer
+  ], [
+    intent,
+    sourceObservation
+  ], bridgeAccount, nbf, exp);
+}
+__name(buildEthToXl1ReserveTx, "buildEthToXl1ReserveTx");
+
+// src/services/queue/workers/util/resolveEvmBlockTagAtDepth.ts
+async function resolveEvmBlockTagAtDepth(provider, depth) {
+  if (depth === "finalized") return "finalized";
+  const head = await provider.getBlockNumber();
+  return Math.max(head - depth, 0);
+}
+__name(resolveEvmBlockTagAtDepth, "resolveEvmBlockTagAtDepth");
+
+// src/services/queue/workers/util/submitEthTransaction.ts
+import { assertEx, hexToBigInt, toEthAddress } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import { isBridgeIntent } from "@xyo-network/xl1-sdk";
+var submitEthTransaction = /* @__PURE__ */ __name(async (tx, offChainPayloads, bridge, wallet) => {
+  const xl1Transaction = assertEx(tx[0], () => "No corresponding XL1 transaction found");
+  const allPayloads = [
+    ...tx[1],
+    ...offChainPayloads
+  ];
+  const bridgeIntent = assertEx(allPayloads.find(isBridgeIntent), () => "No bridge intent found");
+  const srcAddress = toEthAddress(bridgeIntent.srcAddress);
+  const destAddress = toEthAddress(bridgeIntent.destAddress);
+  const amount = hexToBigInt(bridgeIntent.destAmount);
+  const nonce = hexToBigInt(await PayloadBuilder2.hash(xl1Transaction));
+  const bridgeTx = await bridge.connect(wallet).bridgeFromRemote(srcAddress, destAddress, amount, nonce);
+  const receipt = await bridgeTx.wait(1);
+  return receipt?.hash;
+}, "submitEthTransaction");
+
+// src/services/queue/workers/util/submitXl1Transaction.ts
+var submitXl1Transaction = /* @__PURE__ */ __name(async (preparedTx, offChain = [], gateway) => {
+  const result = await gateway.addTransactionToChain(preparedTx, offChain);
+  return result;
+}, "submitXl1Transaction");
+
+// src/services/queue/workers/util/verifyEthBridgeEvent.ts
+import { asHex, toAddress } from "@xylabs/sdk-js";
+import { ZeroAddress } from "ethers";
+async function verifyEthBridgeEvent(id, bridge, provider, confirmationDepth) {
+  const blockTag = await resolveEvmBlockTagAtDepth(provider, confirmationDepth);
+  const data = await bridge.bridgesToRemote(id, {
+    blockTag
+  });
+  if (data.srcAddress === ZeroAddress) {
+    return null;
+  }
+  const filter = bridge.filters.BridgedToRemote(id);
+  const events = await bridge.queryFilter(filter, 0, blockTag);
+  const event = events[0];
+  if (event === void 0) {
+    return null;
+  }
+  return {
+    amount: data.amount,
+    destAddress: toAddress(data.destAddress),
+    destToken: toAddress(data.destToken),
+    evmTxHash: asHex(event.transactionHash, true),
+    srcAddress: toAddress(data.srcAddress)
+  };
+}
+__name(verifyEthBridgeEvent, "verifyEthBridgeEvent");
+
+// src/services/queue/workers/EthEventVerification.ts
+var name = "Verify ETH Bridge Event at Depth";
+var queueName = "eth-event-verify";
 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 svc = assertEx2(services, () => "services not provided");
+  const { bridge, bridgeFulfillmentMap, provider, remoteConfirmationDepth } = svc;
   const worker = new Worker(queueName, async (job) => {
+    const { bridgeId, identity } = job.data;
+    const id = BigInt(bridgeId);
+    const existing = await bridgeFulfillmentMap.get(identity);
+    if (existing?.canonical) {
+      await job.log(`[${identity}] canonical already set; verification skipped`);
+      return;
+    }
+    const state = existing ?? {
+      identity,
+      previousAttempts: []
+    };
+    if (state.failed) state.failed = void 0;
+    await job.log(`[${identity}] verifying BridgedToRemote(${id}) at depth ${remoteConfirmationDepth}`);
+    const data = await verifyEthBridgeEvent(id, bridge, provider, remoteConfirmationDepth);
+    if (isNull(data)) {
+      state.failed = {
+        at: Date.now(),
+        reason: "non-canonical at confirmation depth \u2014 orphaned by reorg or never reached canonical state"
+      };
+      await bridgeFulfillmentMap.set(identity, state);
+      await job.log(`[${identity}] non-canonical at depth \u2014 marked failed`);
+      throw new UnrecoverableError(`[${identity}] bridgesToRemote slot empty at confirmation depth ${remoteConfirmationDepth}`);
+    }
+    state.canonical = data;
+    await bridgeFulfillmentMap.set(identity, state);
+    await job.log(`[${identity}] verified: src=${data.srcAddress} dest=${data.destAddress} amount=${data.amount} evmTxHash=${data.evmTxHash}`);
+  }, {
+    connection: connection2,
+    telemetry: telemetry2,
+    prefix
+  });
+  worker.on("failed", (job, err) => {
+    console.error(`[${name}] Job ${job?.id} failed:`, err.message);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name}] Worker error:`, err);
+  });
+}, "createWorker");
+var EthEventVerification = {
+  createWorker,
+  name,
+  queueName
+};
+
+// src/services/queue/workers/EthToXl1BridgeParent.ts
+import { Worker as Worker2 } from "bullmq";
+var name2 = "Bridge Ethereum to XL1";
+var queueName2 = "eth-to-xl1-bridge";
+var createWorker2 = /* @__PURE__ */ __name((connection2, telemetry2) => {
+  const worker = new Worker2(queueName2, 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(`[${name2}] Job ${job?.id} failed:`, err.message);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name2}] Worker error:`, err);
+  });
+}, "createWorker");
+var EthToXl1BridgeParent = {
+  createWorker: createWorker2,
+  name: name2,
+  queueName: queueName2
+};
+
+// src/services/queue/workers/EthTransactionMonitor.ts
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk-js";
+import { Worker as Worker3 } from "bullmq";
+var name3 = "Monitor Submitted ETH Transaction";
+var queueName3 = "eth-tx-monitor";
+var createWorker3 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const provider = assertEx3(services?.provider, () => "provider service not provided");
+  const stateMap = assertEx3(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const worker = new Worker3(queueName3, async (job) => {
     const { tx } = job.data;
-    const hash = await PayloadBuilder.hash(tx[0]);
-    const state = assertEx(await stateMap.get(hash), () => "State not found");
-    const submissionHash = assertEx(state?.submissionHash, () => "submissionHash not found");
-    const receipt = assertEx(await provider.getTransactionReceipt(submissionHash), () => "Transaction receipt not found");
+    const hash = await PayloadBuilder3.hash(tx[0]);
+    const state = assertEx3(await stateMap.get(hash), () => "State not found");
+    const submissionHash = assertEx3(state?.submissionHash, () => "submissionHash not found");
+    const receipt = assertEx3(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;
@@ -204,58 +265,58 @@ var createWorker = /* @__PURE__ */ __name((connection2, telemetry2, services) =>
     prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name3}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name}] Worker error:`, err);
+    console.error(`[${name3}] Worker error:`, err);
   });
 }, "createWorker");
 var EthTransactionMonitor = {
-  createWorker,
-  name,
-  queueName
+  createWorker: createWorker3,
+  name: name3,
+  queueName: queueName3
 };
 
-// src/queue/workers/EthTransactionPreparation.ts
-import { assertEx as assertEx11, hexToBigInt as hexToBigInt8 } 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";
+// src/services/queue/workers/EthTransactionPreparation.ts
+import { assertEx as assertEx14, hexToBigInt as hexToBigInt9 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/sdk-js";
+import { isBridgeIntent as isBridgeIntent4 } from "@xyo-network/xl1-sdk";
+import { Worker as Worker4 } from "bullmq";
 import { getAddress } from "ethers";
 
-// src/validation/validateBridgeEstimateExact.ts
-import { hexToBigInt as hexToBigInt4, isUndefined } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk-js";
+// src/services/validation/validateBridgeEstimateExact.ts
+import { hexToBigInt as hexToBigInt5, isUndefined } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
 
-// src/config/asChainId.ts
-import { asHex } from "@xylabs/sdk-js";
+// src/services/evm/asChainId.ts
+import { asHex as asHex2 } from "@xylabs/sdk-js";
 var asChainId = /* @__PURE__ */ __name((value) => {
-  const chainId = asHex(value);
+  const chainId = asHex2(value);
   return chainId;
 }, "asChainId");
 
-// src/config/asToken.ts
+// src/services/evm/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";
+// src/services/evm/getBridgeEscrowAddress.ts
+import { asAddress as asAddress2, assertEx as assertEx4 } 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";
+// src/services/evm/getBridgeFeesAddress.ts
+import { asAddress as asAddress3, assertEx as assertEx5 } from "@xylabs/sdk-js";
 var tryGetBridgeFeesAddress = /* @__PURE__ */ __name((config) => {
   const address = asAddress3(config.feesAddress);
   return address;
 }, "tryGetBridgeFeesAddress");
 
-// src/config/getFeeStructure.ts
+// src/services/evm/getFeeStructure.ts
 var getFeeStructure = /* @__PURE__ */ __name((config) => {
   const { feeFixed, feeRateBasisPoints } = config;
   return {
@@ -264,33 +325,33 @@ var getFeeStructure = /* @__PURE__ */ __name((config) => {
   };
 }, "getFeeStructure");
 
-// src/config/getMaxBridgeAmount.ts
+// src/services/evm/getMaxBridgeAmount.ts
 var getMaxBridgeAmount = /* @__PURE__ */ __name((config) => {
   const { maxBridgeAmount } = config;
   return maxBridgeAmount;
 }, "getMaxBridgeAmount");
 
-// src/config/getMinBridgeAmount.ts
+// src/services/evm/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";
+// src/services/evm/getRemoteChainId.ts
+import { assertEx as assertEx6 } from "@xylabs/sdk-js";
 var getRemoteChainId = /* @__PURE__ */ __name((config) => {
-  const remoteChainId = assertEx4(asChainId(config.remoteChainId), () => "Invalid remote chain ID in config");
+  const remoteChainId = assertEx6(asChainId(config.remoteChainId), () => "Invalid remote chain ID in config");
   return remoteChainId;
 }, "getRemoteChainId");
 
-// src/config/getRemoteTokenAddress.ts
-import { assertEx as assertEx5 } from "@xylabs/sdk-js";
+// src/services/evm/getRemoteTokenAddress.ts
+import { assertEx as assertEx7 } 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");
+  return assertEx7(token, () => "Remote token address is not defined in bridge configuration");
 }, "getRemoteTokenAddress");
 
-// src/config/getBridgeWalletAccount.ts
+// src/services/evm/getBridgeWalletAccount.ts
 import { isDefined as isDefined3 } from "@xylabs/sdk-js";
 import { resolveWalletForActor } from "@xyo-network/chain-orchestration";
 var accountServiceSingleton;
@@ -302,7 +363,7 @@ var getBridgeWalletAccount = /* @__PURE__ */ __name(async (config) => {
   return accountServiceSingleton;
 }, "getBridgeWalletAccount");
 
-// src/config/getTransferAddresses.ts
+// src/services/evm/getTransferAddresses.ts
 var getTransferAddresses = /* @__PURE__ */ __name(async (config) => {
   const escrowAddress = tryGetBridgeEscrowAddress(config) ?? (await getBridgeWalletAccount(config)).address;
   const feesAddress = tryGetBridgeFeesAddress(config) ?? (await getBridgeWalletAccount(config)).address;
@@ -312,17 +373,17 @@ var getTransferAddresses = /* @__PURE__ */ __name(async (config) => {
   };
 }, "getTransferAddresses");
 
-// src/config/getXl1ChainId.ts
-import { assertEx as assertEx6, isDefined as isDefined4 } from "@xylabs/sdk-js";
+// src/services/evm/getXl1ChainId.ts
+import { assertEx as assertEx8, 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 assertEx8(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
   }
-  return assertEx6(asChainId(config.chain.id), () => "Invalid chain.id in config");
+  return assertEx8(asChainId(config.chain.id), () => "Invalid chain.id in config");
 }, "getXl1ChainId");
 
-// src/config/getXl1TokenAddress.ts
+// src/services/evm/getXl1TokenAddress.ts
 import { isDefined as isDefined5 } from "@xylabs/sdk-js";
 var getXl1TokenAddress = /* @__PURE__ */ __name((config) => {
   const token = asToken(config.xl1TokenAddress);
@@ -330,7 +391,7 @@ var getXl1TokenAddress = /* @__PURE__ */ __name((config) => {
   return getXl1ChainId(config);
 }, "getXl1TokenAddress");
 
-// src/config/getBridgeSettings.ts
+// src/services/evm/getBridgeSettings.ts
 var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
   const { feeFixed, feeRateBasisPoints } = getFeeStructure(config);
   const { feesAddress, escrowAddress } = await getTransferAddresses(config);
@@ -354,13 +415,35 @@ var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
   };
 }, "getBridgeSettings");
 
-// src/util/calculateBridgeFees.ts
-import { hexToBigInt, toHex } from "@xylabs/sdk-js";
+// src/services/evm/getRemoteConfirmationDepth.ts
+import { isDefined as isDefined6 } from "@xylabs/sdk-js";
+var HARDHAT_CHAIN_ID = "0x7a69";
+var ETHEREUM_MAINNET_CHAIN_ID = "0x1";
+var FALLBACK_CONFIRMATION_DEPTH = 32;
+var DEFAULT_CONFIRMATION_DEPTH_BY_CHAIN_ID = {
+  [HARDHAT_CHAIN_ID]: 0,
+  [ETHEREUM_MAINNET_CHAIN_ID]: 32
+};
+function getRemoteConfirmationDepth(config) {
+  if (isDefined6(config.remoteConfirmationDepth)) return config.remoteConfirmationDepth;
+  const chainId = getRemoteChainId(config).toLowerCase();
+  return DEFAULT_CONFIRMATION_DEPTH_BY_CHAIN_ID[chainId] ?? FALLBACK_CONFIRMATION_DEPTH;
+}
+__name(getRemoteConfirmationDepth, "getRemoteConfirmationDepth");
+
+// src/services/evm/getScannerIntervalMs.ts
+function getScannerIntervalMs(config) {
+  return config.scannerIntervalMs;
+}
+__name(getScannerIntervalMs, "getScannerIntervalMs");
+
+// src/services/util/calculateBridgeFees.ts
+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 srcAmountBigInt = hexToBigInt2(srcAmount);
   const feeVariableBigInt = srcAmountBigInt * BigInt(feeRateBasisPoints) / 10000n;
-  const feeVariable = toHex(feeVariableBigInt);
+  const feeVariable = toHex2(feeVariableBigInt);
   return {
     feeFixed,
     feeVariable,
@@ -368,42 +451,42 @@ var calculateBridgeFees = /* @__PURE__ */ __name((srcAmount, feeStructure) => {
   };
 }, "calculateBridgeFees");
 
-// src/util/calculateMaxBridgeAmount.ts
-import { hexToBigInt as hexToBigInt2, toHex as toHex2 } from "@xylabs/sdk-js";
+// src/services/util/calculateMaxBridgeAmount.ts
+import { hexToBigInt as hexToBigInt3, toHex as toHex3 } from "@xylabs/sdk-js";
 var calculateMaxBridgeAmount = /* @__PURE__ */ __name((balance, feeStructure) => {
   const { feeFixed, feeRateBasisPoints } = feeStructure;
-  const balanceBigInt = hexToBigInt2(balance);
-  const feeFixedBigInt = hexToBigInt2(feeFixed);
-  if (balanceBigInt <= feeFixedBigInt) return toHex2(0n);
+  const balanceBigInt = hexToBigInt3(balance);
+  const feeFixedBigInt = hexToBigInt3(feeFixed);
+  if (balanceBigInt <= feeFixedBigInt) return toHex3(0n);
   const maxAmount = (balanceBigInt - feeFixedBigInt) * 10000n / (10000n + BigInt(feeRateBasisPoints));
-  return toHex2(maxAmount);
+  return toHex3(maxAmount);
 }, "calculateMaxBridgeAmount");
 
-// src/util/createBridgeTransfer.ts
-import { hexToBigInt as hexToBigInt3 } from "@xylabs/sdk-js";
-import { createTransferPayload } from "@xyo-network/xl1-sdk";
+// src/services/util/createBridgeTransfer.ts
+import { hexToBigInt as hexToBigInt4 } from "@xylabs/sdk-js";
+import { createTransferPayload as createTransferPayload2 } from "@xyo-network/xl1-sdk";
 var createBridgeTransfer = /* @__PURE__ */ __name((sender, srcAmount, escrowAddress, feesAddress, context) => {
   const { feeFixed, feeVariable } = context;
-  const escrowAmount = hexToBigInt3(srcAmount);
-  const feesAmount = hexToBigInt3(feeFixed) + hexToBigInt3(feeVariable);
+  const escrowAmount = hexToBigInt4(srcAmount);
+  const feesAmount = hexToBigInt4(feeFixed) + hexToBigInt4(feeVariable);
   const transfers = escrowAddress === feesAddress ? {
     [feesAddress]: escrowAmount + feesAmount
   } : {
     [escrowAddress]: escrowAmount,
     [feesAddress]: feesAmount
   };
-  const transfer = createTransferPayload(sender, transfers, context);
+  const transfer = createTransferPayload2(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 { BridgeIntentSchema } from "@xyo-network/xl1-sdk";
+// src/services/util/generateBridgeEstimate.ts
+import { toAddress as toAddress2 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
+import { BridgeIntentSchema as BridgeIntentSchema2 } 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 = toAddress(srcAddress);
+  const sender = toAddress2(srcAddress);
   const fees = calculateBridgeFees(srcAmount, {
     feeFixed,
     feeRateBasisPoints
@@ -422,8 +505,8 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
     destToken: remoteTokenAddress,
     nonce
   };
-  const bridgeIntent = new PayloadBuilder2({
-    schema: BridgeIntentSchema
+  const bridgeIntent = new PayloadBuilder4({
+    schema: BridgeIntentSchema2
   }).fields(bridgeIntentFields).build();
   const transfer = createBridgeTransfer(sender, srcAmount, escrowAddress, feesAddress, fees);
   return [
@@ -432,37 +515,37 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
   ];
 }, "generateBridgeEstimate");
 
-// src/validation/validateBridgeEstimateExact.ts
+// src/services/validation/validateBridgeEstimateExact.ts
 var validateBridgeEstimateExact = /* @__PURE__ */ __name(async (intent, transfer, config) => {
   const { srcAddress, srcAmount, destAddress } = intent;
-  if (hexToBigInt4(srcAmount) < hexToBigInt4(getMinBridgeAmount(config))) return false;
-  if (hexToBigInt4(srcAmount) > hexToBigInt4(getMaxBridgeAmount(config))) return false;
+  if (hexToBigInt5(srcAmount) < hexToBigInt5(getMinBridgeAmount(config))) return false;
+  if (hexToBigInt5(srcAmount) > hexToBigInt5(getMaxBridgeAmount(config))) return false;
   const [calculatedIntent, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
   if (isUndefined(calculatedIntent) || isUndefined(calculatedTransfer)) return false;
   const { nonce: expectedIntentNonce, ...expectedIntentStatic } = calculatedIntent;
   const { nonce: actualIntentNonce, ...actualIntentStatic } = intent;
-  if (await PayloadBuilder3.dataHash(expectedIntentStatic) !== await PayloadBuilder3.dataHash(actualIntentStatic)) return false;
+  if (await PayloadBuilder5.dataHash(expectedIntentStatic) !== await PayloadBuilder5.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;
+  if (await PayloadBuilder5.dataHash(expectedTransferStatic) !== await PayloadBuilder5.dataHash(actualTransferStatic)) return false;
   return true;
 }, "validateBridgeEstimateExact");
 
-// src/validation/validateBridgeTransaction.ts
+// src/services/validation/validateBridgeTransaction.ts
 import { asAddress as asAddress4 } from "@xylabs/sdk-js";
 import { addressesContains, BoundWitnessValidator, payloadHashesContainsAll, payloadSchemasContainsAll } from "@xyo-network/boundwitness-validator";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
-import { BridgeIntentSchema as BridgeIntentSchema2, TransferSchema } from "@xyo-network/xl1-sdk";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/sdk-js";
+import { BridgeIntentSchema as BridgeIntentSchema3, TransferSchema } from "@xyo-network/xl1-sdk";
 var validateBridgeTransaction = /* @__PURE__ */ __name(async (signedTxBw, intent, transfer, config) => {
   const { srcAddress } = intent;
   const chainId = getXl1ChainId(config);
   if (signedTxBw.chain !== chainId) return false;
   if (signedTxBw.payload_hashes.length != 2) return false;
   if (!payloadSchemasContainsAll(signedTxBw, [
-    BridgeIntentSchema2,
+    BridgeIntentSchema3,
     TransferSchema
   ])) return false;
-  const hashes = await PayloadBuilder4.hashes([
+  const hashes = await PayloadBuilder6.hashes([
     intent,
     transfer
   ]);
@@ -474,16 +557,16 @@ var validateBridgeTransaction = /* @__PURE__ */ __name(async (signedTxBw, intent
   return true;
 }, "validateBridgeTransaction");
 
-// src/validation/validateSufficientLiquiditySourceAllowance.ts
-import { assertEx as assertEx7, hexToBigInt as hexToBigInt5 } from "@xylabs/sdk-js";
-import { isBridgeIntent } from "@xyo-network/xl1-sdk";
+// src/services/validation/validateSufficientLiquiditySourceAllowance.ts
+import { assertEx as assertEx9, hexToBigInt as hexToBigInt6 } from "@xylabs/sdk-js";
+import { isBridgeIntent as isBridgeIntent2 } from "@xyo-network/xl1-sdk";
 var validateSufficientLiquiditySourceAllowance = /* @__PURE__ */ __name(async (tx, offChainPayloads, bridgeableToken, bridge, logger) => {
   const allPayloads = [
     ...tx[1],
     ...offChainPayloads
   ];
-  const bridgeIntent = assertEx7(allPayloads.find(isBridgeIntent), () => "No bridge intent found");
-  const amount = hexToBigInt5(bridgeIntent.destAmount);
+  const bridgeIntent = assertEx9(allPayloads.find(isBridgeIntent2), () => "No bridge intent found");
+  const amount = hexToBigInt6(bridgeIntent.destAmount);
   const liquiditySourceAddress = await bridge.liquiditySource();
   const bridgeAddress = await bridge.getAddress();
   const remainingAllowance = await bridgeableToken.allowance(liquiditySourceAddress, bridgeAddress);
@@ -491,27 +574,27 @@ var validateSufficientLiquiditySourceAllowance = /* @__PURE__ */ __name(async (t
   return remainingAllowance >= amount;
 }, "validateSufficientLiquiditySourceAllowance");
 
-// src/validation/validateSufficientLiquiditySourceBalance.ts
-import { assertEx as assertEx8, hexToBigInt as hexToBigInt6 } from "@xylabs/sdk-js";
-import { isBridgeIntent as isBridgeIntent2 } from "@xyo-network/xl1-sdk";
+// src/services/validation/validateSufficientLiquiditySourceBalance.ts
+import { assertEx as assertEx10, hexToBigInt as hexToBigInt7 } from "@xylabs/sdk-js";
+import { isBridgeIntent as isBridgeIntent3 } from "@xyo-network/xl1-sdk";
 var validateSufficientLiquiditySourceBalance = /* @__PURE__ */ __name(async (tx, offChainPayloads, bridgeableToken, bridge, logger) => {
   const allPayloads = [
     ...tx[1],
     ...offChainPayloads
   ];
-  const bridgeIntent = assertEx8(allPayloads.find(isBridgeIntent2), () => "No bridge intent found");
-  const amount = hexToBigInt6(bridgeIntent.destAmount);
+  const bridgeIntent = assertEx10(allPayloads.find(isBridgeIntent3), () => "No bridge intent found");
+  const amount = hexToBigInt7(bridgeIntent.destAmount);
   const liquiditySourceAddress = await bridge.liquiditySource();
   const balance = await bridgeableToken.balanceOf(liquiditySourceAddress);
   await logger?.log(`Remaining balance: ${balance.toString()}`);
   return balance >= amount;
 }, "validateSufficientLiquiditySourceBalance");
 
-// src/validation/validateSufficientRunnerEthBalanceForGas.ts
-import { assertEx as assertEx9 } from "@xylabs/sdk-js";
+// src/services/validation/validateSufficientRunnerEthBalanceForGas.ts
+import { assertEx as assertEx11 } 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 provider = assertEx11(wallet.provider, () => "Wallet provider is not defined");
   const feeData = await provider.getFeeData();
   const perGas = feeData.maxFeePerGas ?? feeData.gasPrice;
   if (perGas == null) {
@@ -531,30 +614,40 @@ var validateSufficientRunnerEthBalanceForGas = /* @__PURE__ */ __name(async (pre
   return balance >= required;
 }, "validateSufficientRunnerEthBalanceForGas");
 
-// src/validation/validateSufficientXL1SourceAddressBalance.ts
-import { asAddress as asAddress5, assertEx as assertEx10, hexToBigInt as hexToBigInt7 } from "@xylabs/sdk-js";
+// src/services/validation/validateSufficientXl1ReserveBalance.ts
+import { assertEx as assertEx12 } from "@xylabs/sdk-js";
+async function validateSufficientXl1ReserveBalance({ amount, bridgeAccount, gateway, logger }) {
+  const viewer = assertEx12(gateway.connection.viewer, () => "Gateway connection does not have a viewer");
+  const balance = await viewer.account.balance.accountBalance(bridgeAccount.address);
+  await logger?.log(`XL1 reserve account ${bridgeAccount.address} balance: ${balance.toString()}; required: ${amount.toString()}`);
+  return balance >= amount;
+}
+__name(validateSufficientXl1ReserveBalance, "validateSufficientXl1ReserveBalance");
+
+// src/services/validation/validateSufficientXL1SourceAddressBalance.ts
+import { asAddress as asAddress5, assertEx as assertEx13, hexToBigInt as hexToBigInt8 } 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 viewer = assertEx13(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 + hexToBigInt7(transfer), 0n);
+  const totalAmount = Object.values(calculatedTransfer.transfers).reduce((acc, transfer) => acc + hexToBigInt8(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, 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) => {
+// src/services/queue/workers/EthTransactionPreparation.ts
+var name4 = "Prepare ETH Transaction";
+var queueName4 = "eth-tx-prepare";
+var createWorker4 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const bridge = assertEx14(services?.bridge, () => "bridge service not provided");
+  const bridgeableToken = assertEx14(services?.bridgeableToken, () => "bridgeableToken service not provided");
+  const stateMap = assertEx14(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const wallet = assertEx14(services?.wallet, () => "wallet service not provided");
+  const worker = new Worker4(queueName4, async (job) => {
     const { tx, offChainPayloads } = job.data;
-    const hash = await PayloadBuilder5.hash(tx[0]);
+    const hash = await PayloadBuilder7.hash(tx[0]);
     await job.log(`[${hash}] preparing ETH transaction`);
     await job.log(`[${hash}] validating liquiditySource has sufficient allowance`);
     if (!await validateSufficientLiquiditySourceAllowance(tx, offChainPayloads, bridgeableToken, bridge, job)) {
@@ -571,11 +664,11 @@ var createWorker2 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
       ...tx[1],
       ...offChainPayloads
     ];
-    const bridgeIntent = assertEx11(allPayloads.find(isBridgeIntent3), () => "No bridge intent found");
-    const amount = hexToBigInt8(bridgeIntent.destAmount);
+    const bridgeIntent = assertEx14(allPayloads.find(isBridgeIntent4), () => "No bridge intent found");
+    const amount = hexToBigInt9(bridgeIntent.destAmount);
     const srcAddress = getAddress(bridgeIntent.srcAddress);
     const destAddress = getAddress(bridgeIntent.destAddress);
-    const nonce = hexToBigInt8(await PayloadBuilder5.hash(tx[0]));
+    const nonce = hexToBigInt9(await PayloadBuilder7.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`);
@@ -596,69 +689,41 @@ var createWorker2 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
     prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name2}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name4}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name2}] Worker error:`, err);
+    console.error(`[${name4}] Worker error:`, err);
   });
 }, "createWorker");
 var EthTransactionPreparation = {
-  createWorker: createWorker2,
-  name: name2,
-  queueName: queueName2
+  createWorker: createWorker4,
+  name: name4,
+  queueName: queueName4
 };
 
-// src/queue/workers/EthTransactionSubmission.ts
-import { assertEx as assertEx13, isDefined as isDefined6 } 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 hexToBigInt9, 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, offChainPayloads, bridge, wallet) => {
-  const xl1Transaction = assertEx12(tx[0], () => "No corresponding XL1 transaction found");
-  const allPayloads = [
-    ...tx[1],
-    ...offChainPayloads
-  ];
-  const bridgeIntent = assertEx12(allPayloads.find(isBridgeIntent4), () => "No bridge intent found");
-  const srcAddress = toEthAddress(bridgeIntent.srcAddress);
-  const destAddress = toEthAddress(bridgeIntent.destAddress);
-  const amount = hexToBigInt9(bridgeIntent.destAmount);
-  const nonce = hexToBigInt9(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
-var submitXl1Transaction = /* @__PURE__ */ __name(async (preparedTx, offChain = [], gateway) => {
-  const result = await gateway.addTransactionToChain(preparedTx, offChain);
-  return result;
-}, "submitXl1Transaction");
-
-// src/queue/workers/EthTransactionSubmission.ts
-var name3 = "Submit ETH Transaction";
-var queueName3 = "eth-tx-submit";
-var createWorker3 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const bridge = assertEx13(services?.bridge, () => "bridge 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) => {
+// src/services/queue/workers/EthTransactionSubmission.ts
+import { assertEx as assertEx15, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/sdk-js";
+import { Worker as Worker5 } from "bullmq";
+var name5 = "Submit ETH Transaction";
+var queueName5 = "eth-tx-submit";
+var createWorker5 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const bridge = assertEx15(services?.bridge, () => "bridge service not provided");
+  const wallet = assertEx15(services?.wallet, () => "wallet service not provided");
+  const stateMap = assertEx15(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const worker = new Worker5(queueName5, async (job) => {
     const { tx, offChainPayloads } = job.data;
-    const hash = await PayloadBuilder7.hash(tx[0]);
-    const state = assertEx13(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const hash = await PayloadBuilder8.hash(tx[0]);
+    const state = assertEx15(await stateMap.get(hash), () => `[${hash}] state not found`);
     const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined6(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 = assertEx13(await submitEthTransaction(tx, offChainPayloads, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`);
+    const submissionHash = assertEx15(await submitEthTransaction(tx, offChainPayloads, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`);
     await job.log(`[${hash}] Submitted ETH tx and received submission response hash ${submissionHash}`);
     return {
       submissionHash
@@ -670,32 +735,32 @@ var createWorker3 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
     prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name3}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name5}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name3}] Worker error:`, err);
+    console.error(`[${name5}] Worker error:`, err);
   });
 }, "createWorker");
 var EthTransactionSubmission = {
-  createWorker: createWorker3,
-  name: name3,
-  queueName: queueName3
+  createWorker: createWorker5,
+  name: name5,
+  queueName: queueName5
 };
 
-// src/queue/workers/EthTransactionSubmissionStorage.ts
-import { assertEx as assertEx14, isDefined as isDefined7 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/sdk-js";
-import { Worker as Worker4 } from "bullmq";
-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) => {
+// src/services/queue/workers/EthTransactionSubmissionStorage.ts
+import { assertEx as assertEx16, isDefined as isDefined8 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/sdk-js";
+import { Worker as Worker6 } from "bullmq";
+var name6 = "Store ETH Transaction Submission";
+var queueName6 = "eth-tx-store-submission";
+var createWorker6 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const stateMap = assertEx16(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const worker = new Worker6(queueName6, async (job) => {
     const { tx } = job.data;
-    const hash = await PayloadBuilder8.hash(tx[0]);
-    const state = assertEx14(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const hash = await PayloadBuilder9.hash(tx[0]);
+    const state = assertEx16(await stateMap.get(hash), () => `[${hash}] state not found`);
     const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined7(existingSubmissionHash)) {
+    if (isDefined8(existingSubmissionHash)) {
       await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`);
       return {
         submissionHash: existingSubmissionHash
@@ -705,7 +770,7 @@ var createWorker4 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
     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`);
+    const resolvedSubmissionHash = assertEx16(submissionHash, () => `[${hash}] child submissionHash not found in children values`);
     await job.log(`[${hash}] Storing ETH submissionHash`);
     state.submissionHash = resolvedSubmissionHash;
     await stateMap.set(hash, state);
@@ -719,24 +784,193 @@ var createWorker4 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
     prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name4}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name6}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name4}] Worker error:`, err);
+    console.error(`[${name6}] Worker error:`, err);
   });
 }, "createWorker");
 var EthTransactionSubmissionStorage = {
-  createWorker: createWorker4,
-  name: name4,
-  queueName: queueName4
+  createWorker: createWorker6,
+  name: name6,
+  queueName: queueName6
 };
 
-// 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) => {
+// src/services/queue/workers/Xl1ReserveTxFulfillment.ts
+import { assertEx as assertEx17, delay, isDefined as isDefined9, isNull as isNull2 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/sdk-js";
+import { asXL1BlockNumber } from "@xyo-network/xl1-sdk";
+import { Worker as Worker7 } from "bullmq";
+var name7 = "XL1 Reserve Transfer Fulfillment";
+var queueName7 = "eth-to-xl1-fulfill";
+var EXP_BLOCKS_AHEAD = 1e3;
+var POLL_INTERVAL_MS = 5e3;
+var CONCURRENCY = 32;
+async function tryResumeCurrentAttempt(ctx) {
+  const { fulfillmentMap, identity, job, state, viewer } = ctx;
+  const attempt = assertEx17(state.currentAttempt, () => "tryResumeCurrentAttempt called without currentAttempt");
+  const found = await viewer.transaction.byHash(attempt.txHash);
+  if (isDefined9(found) && !isNull2(found)) {
+    state.fulfilled = attempt;
+    state.currentAttempt = void 0;
+    await fulfillmentMap.set(identity, state);
+    await job.log(`[${identity}] tx ${attempt.txHash} included on resume`);
+    return;
+  }
+  const head = await viewer.currentBlockNumber();
+  if (head > attempt.exp) {
+    state.previousAttempts.push(attempt);
+    state.currentAttempt = void 0;
+    await fulfillmentMap.set(identity, state);
+    await job.log(`[${identity}] resumed attempt expired (head=${head}); will build fresh`);
+  }
+}
+__name(tryResumeCurrentAttempt, "tryResumeCurrentAttempt");
+async function buildAndSubmitFreshAttempt(ctx) {
+  const { account, bridgeId, contractAddress, evmChainId, fulfillmentMap, gateway, identity, job, state, viewer, xl1ChainId, xl1TokenAddress } = ctx;
+  const canonical = assertEx17(state.canonical, () => "buildAndSubmitFreshAttempt requires canonical");
+  const sufficient = await validateSufficientXl1ReserveBalance({
+    amount: canonical.amount,
+    bridgeAccount: account,
+    gateway
+  });
+  if (!sufficient) {
+    const msg = `[${identity}] XL1 reserve below required ${canonical.amount.toString()}; will retry`;
+    await job.log(msg);
+    throw new Error(msg);
+  }
+  const head = await viewer.currentBlockNumber();
+  const nbf = asXL1BlockNumber(head, true);
+  const exp = asXL1BlockNumber(head + EXP_BLOCKS_AHEAD, true);
+  const tx = await buildEthToXl1ReserveTx({
+    amount: canonical.amount,
+    bridgeAccount: account,
+    bridgeId,
+    destAddress: canonical.destAddress,
+    evmChainId,
+    evmContractAddress: contractAddress,
+    evmSrcAddress: canonical.srcAddress,
+    evmTokenAddress: canonical.destToken,
+    evmTxHash: canonical.evmTxHash,
+    exp,
+    nbf,
+    xl1ChainId,
+    xl1TokenAddress
+  });
+  const txHash = await PayloadBuilder10.hash(tx[0]);
+  state.currentAttempt = {
+    exp: head + EXP_BLOCKS_AHEAD,
+    nbf: head,
+    submittedAt: Date.now(),
+    txHash
+  };
+  await fulfillmentMap.set(identity, state);
+  await submitXl1Transaction(tx, [], gateway);
+  await job.log(`[${identity}] attempt ${state.previousAttempts.length + 1} submitted: txHash=${txHash} nbf=${head} exp=${head + EXP_BLOCKS_AHEAD}`);
+}
+__name(buildAndSubmitFreshAttempt, "buildAndSubmitFreshAttempt");
+async function pollUntilIncludedOrExpired(ctx) {
+  const { fulfillmentMap, identity, job, state, viewer } = ctx;
+  const attempt = assertEx17(state.currentAttempt, () => "pollUntilIncludedOrExpired requires currentAttempt");
+  while (true) {
+    const found = await viewer.transaction.byHash(attempt.txHash);
+    if (isDefined9(found) && !isNull2(found)) {
+      state.fulfilled = attempt;
+      state.currentAttempt = void 0;
+      await fulfillmentMap.set(identity, state);
+      await job.log(`[${identity}] tx ${attempt.txHash} included`);
+      return;
+    }
+    const head = await viewer.currentBlockNumber();
+    if (head > attempt.exp) {
+      state.previousAttempts.push(attempt);
+      state.currentAttempt = void 0;
+      await fulfillmentMap.set(identity, state);
+      const msg = `[${identity}] attempt ${state.previousAttempts.length} expired (head=${head}, exp=${attempt.exp})`;
+      await job.log(msg);
+      throw new Error(msg);
+    }
+    await delay(POLL_INTERVAL_MS);
+  }
+}
+__name(pollUntilIncludedOrExpired, "pollUntilIncludedOrExpired");
+var createWorker7 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const svc = assertEx17(services, () => "services not provided");
+  const { account, bridgeFulfillmentMap, gateway } = svc;
+  const worker = new Worker7(queueName7, async (job) => {
+    const { bridgeId, contractAddress, evmChainId, identity, xl1ChainId, xl1TokenAddress } = job.data;
+    const initialState = await bridgeFulfillmentMap.get(identity);
+    if (initialState?.fulfilled) {
+      await job.log(`[${identity}] already fulfilled \u2014 skipping`);
+      return;
+    }
+    const state = assertEx17(initialState, () => `[${identity}] no fulfillment state \u2014 Stage 1 did not run`);
+    assertEx17(state.canonical, () => `[${identity}] canonical missing \u2014 Stage 1 did not write canonical`);
+    if (state.failed) {
+      state.failed = void 0;
+      await bridgeFulfillmentMap.set(identity, state);
+    }
+    const viewer = assertEx17(gateway.connection.viewer, () => `[${identity}] gateway viewer not available`);
+    const ctx = {
+      fulfillmentMap: bridgeFulfillmentMap,
+      identity,
+      job,
+      state,
+      viewer
+    };
+    if (state.currentAttempt) {
+      await tryResumeCurrentAttempt(ctx);
+      if (state.fulfilled) return;
+    }
+    if (!state.currentAttempt) {
+      await buildAndSubmitFreshAttempt({
+        ...ctx,
+        account,
+        bridgeId: BigInt(bridgeId),
+        contractAddress,
+        evmChainId,
+        gateway,
+        xl1ChainId,
+        xl1TokenAddress
+      });
+    }
+    await pollUntilIncludedOrExpired(ctx);
+  }, {
+    concurrency: CONCURRENCY,
+    connection: connection2,
+    prefix,
+    telemetry: telemetry2
+  });
+  worker.on("failed", async (job, err) => {
+    if (!isDefined9(job)) return;
+    const attemptsAllowed = job.opts.attempts ?? Infinity;
+    if (job.attemptsMade < attemptsAllowed) return;
+    const identity = job.data?.identity;
+    if (!isDefined9(identity)) return;
+    const state = await bridgeFulfillmentMap.get(identity);
+    if (!isDefined9(state)) return;
+    state.failed = {
+      at: Date.now(),
+      reason: `attempts exhausted (${job.attemptsMade}/${attemptsAllowed}): ${err.message}`
+    };
+    await bridgeFulfillmentMap.set(identity, state);
+  });
+  worker.on("error", (err) => {
+    console.error(`[${name7}] Worker error:`, err);
+  });
+}, "createWorker");
+var Xl1ReserveTxFulfillment = {
+  createWorker: createWorker7,
+  name: name7,
+  queueName: queueName7
+};
+
+// src/services/queue/workers/Xl1ToEthBridgeParent.ts
+import { Worker as Worker8 } from "bullmq";
+var name8 = "Bridge XL1 to Ethereum";
+var queueName8 = "xl1-to-eth-bridge";
+var createWorker8 = /* @__PURE__ */ __name((connection2, telemetry2) => {
+  const worker = new Worker8(queueName8, async (job) => {
     await job.log(`[${job.name}] start`);
     await job.log(`[${job.name}] done`);
     return {};
@@ -746,38 +980,38 @@ var createWorker5 = /* @__PURE__ */ __name((connection2, telemetry2) => {
     prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name5}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name8}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name5}] Worker error:`, err);
+    console.error(`[${name8}] Worker error:`, err);
   });
 }, "createWorker");
 var Xl1ToEthBridgeParent = {
-  createWorker: createWorker5,
-  name: name5,
-  queueName: queueName5
+  createWorker: createWorker8,
+  name: name8,
+  queueName: queueName8
 };
 
-// src/queue/workers/Xl1TransactionMonitor.ts
-import { assertEx as assertEx15, isDefined as isDefined8, 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) => {
+// src/services/queue/workers/Xl1TransactionMonitor.ts
+import { assertEx as assertEx18, isDefined as isDefined10, isNull as isNull3 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
+import { UnrecoverableError as UnrecoverableError2, Worker as Worker9 } from "bullmq";
+var name9 = "Monitor Submitted XL1 Transaction";
+var queueName9 = "xl1-tx-monitor";
+var createWorker9 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const gateway = assertEx18(services?.gateway, () => "gateway service not provided");
+  const stateMap = assertEx18(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const viewer = assertEx18(gateway.connection.viewer, () => "viewer not defined on gateway");
+  const worker = new Worker9(queueName9, async (job) => {
     const { tx } = job.data;
-    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`);
+    const hash = await PayloadBuilder11.hash(tx[0]);
+    const state = assertEx18(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const submissionHash = assertEx18(state.submissionHash, () => `[${hash}] submissionHash not found`);
     await job.log(`[${hash}] Checking for XL1 transaction inclusion on chain`);
     const foundTx = await viewer.transaction.byHash(submissionHash);
-    if (isDefined8(foundTx) && !isNull(foundTx)) {
+    if (isDefined10(foundTx) && !isNull3(foundTx)) {
       await job.log(`[${hash}] Found transaction on chain`);
-      const submissionHash2 = await PayloadBuilder9.hash(foundTx[0]);
+      const submissionHash2 = await PayloadBuilder11.hash(foundTx[0]);
       return {
         submissionHash: submissionHash2
       };
@@ -785,7 +1019,7 @@ var createWorker6 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
     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`);
+      throw new UnrecoverableError2(`[${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`);
@@ -795,29 +1029,29 @@ var createWorker6 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
     prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name6}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name9}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name6}] Worker error:`, err);
+    console.error(`[${name9}] Worker error:`, err);
   });
 }, "createWorker");
 var Xl1TransactionMonitor = {
-  createWorker: createWorker6,
-  name: name6,
-  queueName: queueName6
+  createWorker: createWorker9,
+  name: name9,
+  queueName: queueName9
 };
 
-// src/queue/workers/Xl1TransactionPreparation.ts
-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) => {
+// src/services/queue/workers/Xl1TransactionPreparation.ts
+import { assertEx as assertEx19 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/sdk-js";
+import { Worker as Worker10 } from "bullmq";
+var name10 = "Prepare XL1 Transaction";
+var queueName10 = "xl1-tx-prepare";
+var createWorker10 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const stateMap = assertEx19(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const worker = new Worker10(queueName10, async (job) => {
     const { tx, offChainPayloads = [] } = job.data;
-    const hash = await PayloadBuilder10.hash(tx[0]);
+    const hash = await PayloadBuilder12.hash(tx[0]);
     await job.log(`[${hash}] preparing XL1 transaction`);
     const preparedTx = tx;
     await job.log(`[${hash}] storing XL1 preparedTx`);
@@ -836,39 +1070,39 @@ var createWorker7 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
     prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name7}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name10}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name7}] Worker error:`, err);
+    console.error(`[${name10}] Worker error:`, err);
   });
 }, "createWorker");
 var Xl1TransactionPreparation = {
-  createWorker: createWorker7,
-  name: name7,
-  queueName: queueName7
+  createWorker: createWorker10,
+  name: name10,
+  queueName: queueName10
 };
 
-// src/queue/workers/Xl1TransactionSubmission.ts
-import { assertEx as assertEx17, isDefined as isDefined9 } 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) => {
+// src/services/queue/workers/Xl1TransactionSubmission.ts
+import { assertEx as assertEx20, isDefined as isDefined11 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/sdk-js";
+import { Worker as Worker11 } from "bullmq";
+var name11 = "Submit XL1 Transaction";
+var queueName11 = "xl1-tx-submit";
+var createWorker11 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const gateway = assertEx20(services?.gateway, () => "gateway service not provided");
+  const stateMap = assertEx20(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const worker = new Worker11(queueName11, async (job) => {
     const { tx } = job.data;
-    const hash = await PayloadBuilder11.hash(tx[0]);
-    const state = assertEx17(await stateMap.get(hash), () => `[${hash}] state not found`);
+    const hash = await PayloadBuilder13.hash(tx[0]);
+    const state = assertEx20(await stateMap.get(hash), () => `[${hash}] state not found`);
     const { preparedTx, offChainPayloads = [], submissionHash: existingSubmissionHash } = state;
-    if (isDefined9(existingSubmissionHash)) {
+    if (isDefined11(existingSubmissionHash)) {
       await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
       return {
         submissionHash: existingSubmissionHash
       };
     }
-    const txToSubmit = assertEx17(preparedTx, () => `[${hash}] preparedTx not found`);
+    const txToSubmit = assertEx20(preparedTx, () => `[${hash}] preparedTx not found`);
     await job.log(`[${hash}] Submitting XL1 tx`);
     const [submissionHash] = await submitXl1Transaction(txToSubmit, offChainPayloads, gateway);
     await job.log(`[${hash}] Submitted XL1 tx`);
@@ -881,32 +1115,32 @@ var createWorker8 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
     prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name8}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name11}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name8}] Worker error:`, err);
+    console.error(`[${name11}] Worker error:`, err);
   });
 }, "createWorker");
 var Xl1TransactionSubmission = {
-  createWorker: createWorker8,
-  name: name8,
-  queueName: queueName8
+  createWorker: createWorker11,
+  name: name11,
+  queueName: queueName11
 };
 
-// src/queue/workers/Xl1TransactionSubmissionStorage.ts
-import { assertEx as assertEx18, isDefined as isDefined10 } 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) => {
+// src/services/queue/workers/Xl1TransactionSubmissionStorage.ts
+import { assertEx as assertEx21, isDefined as isDefined12 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/sdk-js";
+import { Worker as Worker12 } from "bullmq";
+var name12 = "Store XL1 Transaction Submission";
+var queueName12 = "xl1-tx-store-submission";
+var createWorker12 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  const stateMap = assertEx21(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const worker = new Worker12(queueName12, 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 hash = await PayloadBuilder14.hash(tx[0]);
+    const state = assertEx21(await stateMap.get(hash), () => `[${hash}] state not found`);
     const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined10(existingSubmissionHash)) {
+    if (isDefined12(existingSubmissionHash)) {
       await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`);
       return {
         submissionHash: existingSubmissionHash
@@ -916,7 +1150,7 @@ var createWorker9 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
     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`);
+    const resolvedSubmissionHash = assertEx21(submissionHash, () => `[${hash}] child submissionHash not found in children values`);
     await job.log(`[${hash}] Storing XL1 submissionHash`);
     state.submissionHash = resolvedSubmissionHash;
     await stateMap.set(hash, state);
@@ -930,39 +1164,102 @@ var createWorker9 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
     prefix
   });
   worker.on("failed", (job, err) => {
-    console.error(`[${name9}] Job ${job?.id} failed:`, err.message);
+    console.error(`[${name12}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
-    console.error(`[${name9}] Worker error:`, err);
+    console.error(`[${name12}] Worker error:`, err);
+  });
+}, "createWorker");
+var Xl1TransactionSubmissionStorage = {
+  createWorker: createWorker12,
+  name: name12,
+  queueName: queueName12
+};
+
+// src/services/queue/workers/createWorkers.ts
+var createWorkers = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+  EthEventVerification.createWorker(connection2, telemetry2, services);
+  EthToXl1BridgeParent.createWorker(connection2, telemetry2);
+  EthTransactionMonitor.createWorker(connection2, telemetry2, services);
+  EthTransactionPreparation.createWorker(connection2, telemetry2, services);
+  EthTransactionSubmission.createWorker(connection2, telemetry2, services);
+  EthTransactionSubmissionStorage.createWorker(connection2, telemetry2, services);
+  Xl1ReserveTxFulfillment.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/services/queue/flows/createEthToXl1BridgeJob/getJobIdForEthToXl1BridgeJob.ts
+function getJobIdForEthToXl1BridgeJob(context) {
+  return `evm:${context.evmChainId.toLowerCase()}:${context.contractAddress.toLowerCase()}:${context.bridgeId.toString()}`;
+}
+__name(getJobIdForEthToXl1BridgeJob, "getJobIdForEthToXl1BridgeJob");
+
+// src/services/queue/flows/createEthToXl1BridgeJob/createEthToXl1BridgeJob.ts
+var STAGE_2_RETRY = {
+  attempts: 1e3,
+  backoff: {
+    delay: 1e4,
+    type: "fixed"
+  }
+};
+var STAGE_1_RETRY = {
+  attempts: 1
+};
+var createEthToXl1BridgeJob = /* @__PURE__ */ __name(async (flowProducer2, context) => {
+  const jobId = getJobIdForEthToXl1BridgeJob(context);
+  const identity = jobId;
+  const stageJobData = {
+    bridgeId: context.bridgeId.toString(),
+    contractAddress: context.contractAddress,
+    evmChainId: context.evmChainId,
+    identity,
+    xl1ChainId: context.xl1ChainId,
+    xl1TokenAddress: context.xl1TokenAddress
+  };
+  return flowProducer2.add({
+    name: EthToXl1BridgeParent.name,
+    queueName: EthToXl1BridgeParent.queueName,
+    data: stageJobData,
+    opts: {
+      jobId
+    },
+    children: [
+      {
+        name: Xl1ReserveTxFulfillment.name,
+        queueName: Xl1ReserveTxFulfillment.queueName,
+        data: stageJobData,
+        opts: {
+          jobId,
+          ...STAGE_2_RETRY
+        },
+        children: [
+          {
+            name: EthEventVerification.name,
+            queueName: EthEventVerification.queueName,
+            data: stageJobData,
+            opts: {
+              jobId,
+              ...STAGE_1_RETRY
+            }
+          }
+        ]
+      }
+    ]
   });
-}, "createWorker");
-var Xl1TransactionSubmissionStorage = {
-  createWorker: createWorker9,
-  name: name9,
-  queueName: queueName9
-};
-
-// src/queue/workers/createWorkers.ts
-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");
+}, "createEthToXl1BridgeJob");
 
-// src/queue/flows/createXl1ToEthBridgeJob/getJobIdForXl1ToEthBridgeJob.ts
-import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/sdk-js";
+// src/services/queue/flows/createXl1ToEthBridgeJob/getJobIdForXl1ToEthBridgeJob.ts
+import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/sdk-js";
 var getJobIdForXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (tx) => {
-  const jobId = await PayloadBuilder13.hash(tx[0]);
+  const jobId = await PayloadBuilder15.hash(tx[0]);
   return jobId;
 }, "getJobIdForXl1ToEthBridgeJob");
 
-// src/queue/flows/createXl1ToEthBridgeJob/createXl1ToEthBridgeJob.ts
+// src/services/queue/flows/createXl1ToEthBridgeJob/createXl1ToEthBridgeJob.ts
 var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx, offChainPayloads = []) => {
   const jobId = await getJobIdForXl1ToEthBridgeJob(tx);
   const flow = await flowProducer2.add({
@@ -1117,7 +1414,7 @@ var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx, o
   return flow;
 }, "createXl1ToEthBridgeJob");
 
-// src/queue/flows/createXl1ToEthBridgeJob/getXl1ToEthBridgeJob.ts
+// src/services/queue/flows/createXl1ToEthBridgeJob/getXl1ToEthBridgeJob.ts
 var getXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) => {
   const id = await getJobIdForXl1ToEthBridgeJob(tx);
   const flow = await flowProducer2.getFlow({
@@ -1127,7 +1424,30 @@ var getXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) => {
   return flow;
 }, "getXl1ToEthBridgeJob");
 
-// src/queue/getXl1ToEthQueueJobs.ts
+// src/services/queue/getEthToXl1Queues.ts
+import { Queue } from "bullmq";
+var ethToXl1Queues;
+var getEthToXl1Queues = /* @__PURE__ */ __name((config) => {
+  if (ethToXl1Queues) return ethToXl1Queues;
+  const connection2 = getConnection(config);
+  ethToXl1Queues = {
+    ethEventVerification: new Queue(EthEventVerification.queueName, {
+      connection: connection2,
+      prefix
+    }),
+    ethToXl1BridgeParent: new Queue(EthToXl1BridgeParent.queueName, {
+      connection: connection2,
+      prefix
+    }),
+    xl1ReserveTxFulfillment: new Queue(Xl1ReserveTxFulfillment.queueName, {
+      connection: connection2,
+      prefix
+    })
+  };
+  return ethToXl1Queues;
+}, "getEthToXl1Queues");
+
+// src/services/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),
@@ -1151,42 +1471,42 @@ var getStatusQueueJobs = /* @__PURE__ */ __name(async (queues, jobId) => {
   };
 }, "getStatusQueueJobs");
 
-// src/queue/getXl1ToEthQueues.ts
-import { Queue } from "bullmq";
+// src/services/queue/getXl1ToEthQueues.ts
+import { Queue as Queue2 } from "bullmq";
 var xl1ToEthQueues;
 var getXl1ToEthQueues = /* @__PURE__ */ __name((config) => {
   if (xl1ToEthQueues) return xl1ToEthQueues;
   const connection2 = getConnection(config);
   xl1ToEthQueues = {
-    ethTransactionMonitor: new Queue(EthTransactionMonitor.queueName, {
+    ethTransactionMonitor: new Queue2(EthTransactionMonitor.queueName, {
       connection: connection2,
       prefix
     }),
-    ethTransactionPreparation: new Queue(EthTransactionPreparation.queueName, {
+    ethTransactionPreparation: new Queue2(EthTransactionPreparation.queueName, {
       connection: connection2,
       prefix
     }),
-    ethTransactionSubmission: new Queue(EthTransactionSubmission.queueName, {
+    ethTransactionSubmission: new Queue2(EthTransactionSubmission.queueName, {
       connection: connection2,
       prefix
     }),
-    xl1ToEthBridgeParent: new Queue(Xl1ToEthBridgeParent.queueName, {
+    xl1ToEthBridgeParent: new Queue2(Xl1ToEthBridgeParent.queueName, {
       connection: connection2,
       prefix
     }),
-    xl1TransactionMonitor: new Queue(Xl1TransactionMonitor.queueName, {
+    xl1TransactionMonitor: new Queue2(Xl1TransactionMonitor.queueName, {
       connection: connection2,
       prefix
     }),
-    xl1TransactionPreparation: new Queue(Xl1TransactionPreparation.queueName, {
+    xl1TransactionPreparation: new Queue2(Xl1TransactionPreparation.queueName, {
       connection: connection2,
       prefix
     }),
-    xl1TransactionSubmission: new Queue(Xl1TransactionSubmission.queueName, {
+    xl1TransactionSubmission: new Queue2(Xl1TransactionSubmission.queueName, {
       connection: connection2,
       prefix
     }),
-    xl1TransactionSubmissionStorage: new Queue(Xl1TransactionSubmissionStorage.queueName, {
+    xl1TransactionSubmissionStorage: new Queue2(Xl1TransactionSubmissionStorage.queueName, {
       connection: connection2,
       prefix
     })
@@ -1194,24 +1514,167 @@ var getXl1ToEthQueues = /* @__PURE__ */ __name((config) => {
   return xl1ToEthQueues;
 }, "getXl1ToEthQueues");
 
-// src/queue/telemetry.ts
-import { isDefined as isDefined11 } from "@xylabs/sdk-js";
+// src/services/queue/scanner/createEnqueueEthToXl1Bridge.ts
+function createEnqueueEthToXl1Bridge(options2) {
+  const { evmChainId, evmContractAddress, flowProducer: flowProducer2, xl1ChainId, xl1TokenAddress } = options2;
+  return async (bridgeId, jobLog) => {
+    await createEthToXl1BridgeJob(flowProducer2, {
+      bridgeId,
+      contractAddress: evmContractAddress,
+      evmChainId,
+      xl1ChainId,
+      xl1TokenAddress
+    });
+    await jobLog?.(`[bridge-scanner] bridgeId ${bridgeId} enqueued`);
+  };
+}
+__name(createEnqueueEthToXl1Bridge, "createEnqueueEthToXl1Bridge");
+
+// src/services/queue/scanner/EvmBridgeScanner.ts
+import { isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+
+// src/services/queue/scanner/EvmBridgeCursor.ts
+function getEvmBridgeCursorKey(chainId, contractAddress) {
+  return `${chainId.toLowerCase()}:${contractAddress.toLowerCase()}`;
+}
+__name(getEvmBridgeCursorKey, "getEvmBridgeCursorKey");
+
+// src/services/queue/scanner/EvmBridgeScanner.ts
+function createEvmBridgeScanner(options2) {
+  const { bridge, bridgeAddress, chainId, confirmationDepth, cursors, enqueue, provider } = options2;
+  const cursorKey = getEvmBridgeCursorKey(chainId, bridgeAddress);
+  return {
+    async scan(options3) {
+      const jobLog = options3?.jobLog;
+      const blockTag = await resolveEvmBlockTagAtDepth(provider, confirmationDepth);
+      const confirmedHigh = await bridge.nextBridgeToId({
+        blockTag
+      });
+      const cursor = await cursors.get(cursorKey);
+      const lastProcessedId = isUndefined2(cursor) ? 0n : BigInt(cursor.lastProcessedId);
+      if (confirmedHigh <= lastProcessedId) {
+        return {
+          confirmedHigh,
+          enqueued: 0,
+          lastProcessedId
+        };
+      }
+      let enqueued = 0;
+      for (let id = lastProcessedId + 1n; id <= confirmedHigh; id++) {
+        await enqueue(id, jobLog);
+        enqueued++;
+      }
+      await cursors.set(cursorKey, {
+        lastProcessedId: confirmedHigh.toString()
+      });
+      return {
+        confirmedHigh,
+        enqueued,
+        lastProcessedId
+      };
+    }
+  };
+}
+__name(createEvmBridgeScanner, "createEvmBridgeScanner");
+
+// src/services/queue/scanner/EvmBridgeScannerRunner.ts
+import { Queue as Queue3, Worker as Worker13 } from "bullmq";
+var QUEUE_NAME = "eth-to-xl1-scanner";
+var REPEATABLE_JOB_NAME = "scan";
+var REPEATABLE_JOB_ID = "eth-to-xl1-scanner-tick";
+function createEvmBridgeScannerRunner(options2) {
+  const { connection: connection2, intervalMs, scanner, telemetry: telemetry2 } = options2;
+  const logger = options2.logger ?? console;
+  let queue;
+  let worker;
+  return {
+    async start() {
+      queue = new Queue3(QUEUE_NAME, {
+        connection: connection2,
+        prefix,
+        telemetry: telemetry2
+      });
+      worker = new Worker13(QUEUE_NAME, async (job) => {
+        await job.log("[scanner] tick start");
+        const result = await scanner.scan({
+          jobLog: /* @__PURE__ */ __name((msg) => job.log(msg), "jobLog")
+        });
+        await job.log(`[scanner] tick complete: enqueued=${result.enqueued} confirmedHigh=${result.confirmedHigh.toString()} lastProcessedId=${result.lastProcessedId.toString()}`);
+      }, {
+        connection: connection2,
+        prefix,
+        telemetry: telemetry2
+      });
+      worker.on("failed", (job, err) => {
+        logger.error(`[scanner] tick ${job?.id} failed:`, err.message);
+      });
+      worker.on("error", (err) => {
+        logger.error("[scanner] worker error:", err);
+      });
+      await queue.add(REPEATABLE_JOB_NAME, {}, {
+        jobId: REPEATABLE_JOB_ID,
+        repeat: {
+          every: intervalMs
+        }
+      });
+    },
+    async stop() {
+      await worker?.close();
+      await queue?.close();
+      worker = void 0;
+      queue = void 0;
+    }
+  };
+}
+__name(createEvmBridgeScannerRunner, "createEvmBridgeScannerRunner");
+
+// src/services/queue/scanner/buildEvmBridgeScannerRunner.ts
+function buildEvmBridgeScannerRunner(options2) {
+  const { config, connection: connection2, flowProducer: flowProducer2, logger, services, telemetry: telemetry2 } = options2;
+  const evmChainId = getRemoteChainId(config);
+  const evmContractAddress = config.remoteBridgeContractAddress;
+  const xl1ChainId = getXl1ChainId(config);
+  const xl1TokenAddress = getXl1TokenAddress(config);
+  const intervalMs = getScannerIntervalMs(config);
+  const enqueue = createEnqueueEthToXl1Bridge({
+    evmChainId,
+    evmContractAddress,
+    flowProducer: flowProducer2,
+    xl1ChainId,
+    xl1TokenAddress
+  });
+  const scanner = createEvmBridgeScanner({
+    bridge: services.bridge,
+    bridgeAddress: evmContractAddress,
+    chainId: evmChainId,
+    confirmationDepth: services.remoteConfirmationDepth,
+    cursors: services.evmBridgeCursorMap,
+    enqueue,
+    provider: services.provider
+  });
+  return createEvmBridgeScannerRunner({
+    connection: connection2,
+    intervalMs,
+    logger,
+    scanner,
+    telemetry: telemetry2
+  });
+}
+__name(buildEvmBridgeScannerRunner, "buildEvmBridgeScannerRunner");
+
+// src/services/queue/telemetry.ts
+import { isDefined as isDefined13 } from "@xylabs/sdk-js";
 import { BullMQOtel } from "bullmq-otel";
 var telemetry;
 var options = {
   enableMetrics: true
 };
 var getTelemetry = /* @__PURE__ */ __name(() => {
-  if (isDefined11(telemetry)) return telemetry;
+  if (isDefined13(telemetry)) return telemetry;
   telemetry = new BullMQOtel(options);
   return telemetry;
 }, "getTelemetry");
 
-// src/server/app.ts
-import { standardErrors } from "@xylabs/express";
-import { sharedMiddleware } from "@xyo-network/chain-orchestration";
-import express from "express";
-
 // src/server/addFlowProducer.ts
 var addFlowProducer = /* @__PURE__ */ __name((app, config) => {
   const connection2 = getConnection(config);
@@ -1310,18 +1773,18 @@ var makeBridgeConfigRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
 import { requestHandlerValidator as requestHandlerValidator2 } from "@xylabs/express";
-import { toAddress as toAddress2, toHex as toHex3 } from "@xylabs/sdk-js";
+import { isDefined as isDefined14, toHex as toHex4 } from "@xylabs/sdk-js";
 import { PayloadZodStrictOfSchema } from "@xyo-network/sdk-js";
-import { BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema } from "@xyo-network/xl1-sdk";
+import { BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema, BridgeIntentFieldsZod, BridgeIntentSchema as BridgeIntentSchema4, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema as BridgeSourceObservationSchema2 } 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 asHex3, 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)) {
+    const chainId = asHex3(val);
+    if (isUndefined3(chainId)) {
       ctx.addIssue("Not a valid chain id");
       return;
     }
@@ -1332,55 +1795,128 @@ var getRemoteChainIdZod = /* @__PURE__ */ __name((config) => {
 }, "getRemoteChainIdZod");
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
+var BridgeIntentResponseZod = PayloadZodStrictOfSchema(BridgeIntentSchema4).extend(BridgeIntentFieldsZod.shape);
+var BridgeSourceResponseZod = PayloadZodStrictOfSchema(BridgeSourceObservationSchema2).extend(BridgeSourceObservationFieldsZod.shape);
+var BridgeDestinationResponseZod = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape);
+var BridgeFromRemoteStatusResponseZod = z.union([
+  z.tuple([]),
+  z.tuple([
+    BridgeIntentResponseZod
+  ]),
+  z.tuple([
+    BridgeIntentResponseZod,
+    BridgeSourceResponseZod
+  ]),
+  z.tuple([
+    BridgeIntentResponseZod,
+    BridgeSourceResponseZod,
+    BridgeDestinationResponseZod
+  ])
+]);
+function buildIntentAndSource(ctx) {
+  const { canonical, config, nonce } = ctx;
+  const amountHex = toHex4(canonical.amount);
+  const xl1ChainId = getXl1ChainId(config);
+  const xl1TokenAddress = getXl1TokenAddress(config);
+  const evmChainId = config.remoteChainId;
+  const evmTokenAddress = getRemoteTokenAddress(config);
+  const intentFields = BridgeIntentFieldsZod.parse({
+    dest: xl1ChainId,
+    destAddress: canonical.destAddress,
+    destAmount: amountHex,
+    destToken: xl1TokenAddress,
+    nonce,
+    src: evmChainId,
+    srcAddress: canonical.srcAddress,
+    srcAmount: amountHex,
+    srcToken: evmTokenAddress
+  });
+  const intent = {
+    schema: BridgeIntentSchema4,
+    ...intentFields
+  };
+  const sourceFields = BridgeSourceObservationFieldsZod.parse({
+    ...intentFields,
+    srcConfirmation: canonical.evmTxHash
+  });
+  const source = {
+    schema: BridgeSourceObservationSchema2,
+    ...sourceFields
+  };
+  return [
+    intent,
+    source
+  ];
+}
+__name(buildIntentAndSource, "buildIntentAndSource");
 var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
   const params = z.object({
     chainId: getRemoteChainIdZod(config),
-    nonce: z.string().nonempty()
+    nonce: z.string().regex(/^\d+$/, "nonce must be a non-negative integer (the bridge contract's id)")
   });
-  const response = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape);
   const validateRequest2 = requestHandlerValidator2({
     params,
-    response
+    response: BridgeFromRemoteStatusResponseZod
   });
   return {
     method: "get",
     path: "/bridge/chains/:chainId/bridgeFromRemote/status/:nonce",
     handlers: validateRequest2(async (req, res) => {
-      const { remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
-      const rand = await Promise.resolve(Math.random());
-      const found = rand > 0.5;
-      if (!found) return res.sendStatus(404);
-      const confirmed = rand > 0.8;
-      if (!confirmed) return res.sendStatus(204);
-      const observation = {
+      const bridgeId = BigInt(req.params.nonce);
+      const contractAddress = config.remoteBridgeContractAddress;
+      const evmChainId = config.remoteChainId;
+      const identity = getJobIdForEthToXl1BridgeJob({
+        bridgeId,
+        contractAddress,
+        evmChainId
+      });
+      const services = req.app.services;
+      const state = await services.bridgeFulfillmentMap.get(identity);
+      if (state?.failed) return res.sendStatus(504);
+      if (!state?.canonical) {
+        const queues = getEthToXl1Queues(config);
+        const parentJob = await queues.ethToXl1BridgeParent.getJob(identity);
+        if (!isDefined14(parentJob)) return res.sendStatus(404);
+        return res.json([]);
+      }
+      const [intent, source] = buildIntentAndSource({
+        canonical: state.canonical,
+        config,
+        nonce: identity
+      });
+      if (!state.fulfilled) return res.json([
+        intent,
+        source
+      ]);
+      const destinationFields = BridgeDestinationObservationFieldsZod.parse({
+        ...intent,
+        destConfirmation: state.fulfilled.txHash
+      });
+      const destination = {
         schema: BridgeDestinationObservationSchema,
-        dest: xl1ChainId,
-        destAddress: toAddress2("0xabc"),
-        destAmount: toHex3("0x100"),
-        destToken: xl1TokenAddress,
-        src: remoteChainId,
-        srcAddress: toAddress2("0x123"),
-        srcAmount: toHex3("0x200"),
-        srcToken: remoteTokenAddress,
-        destConfirmation: toHex3("0x9999")
+        ...destinationFields
       };
-      res.json(observation);
+      res.json([
+        intent,
+        source,
+        destination
+      ]);
     })
   };
 }, "makeBridgeFromRemoteStatusRoute");
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
 import { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
-import { isDefined as isDefined12 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder14, PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/sdk-js";
-import { BridgeIntentFieldsZod, BridgeIntentSchema as BridgeIntentSchema3, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema, SignedTransactionBoundWitnessZod, TransferZod } from "@xyo-network/xl1-sdk";
+import { isDefined as isDefined15 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder16, PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/sdk-js";
+import { BridgeIntentFieldsZod as BridgeIntentFieldsZod2, BridgeIntentSchema as BridgeIntentSchema5, BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod2, BridgeSourceObservationSchema as BridgeSourceObservationSchema3, SignedTransactionBoundWitnessZod, TransferZod } from "@xyo-network/xl1-sdk";
 import { z as z2 } from "zod";
 var BridgeToRemoteBodyZod = z2.tuple([
   SignedTransactionBoundWitnessZod,
-  PayloadZodLooseOfSchema(BridgeIntentSchema3).extend(BridgeIntentFieldsZod.shape),
+  PayloadZodLooseOfSchema(BridgeIntentSchema5).extend(BridgeIntentFieldsZod2.shape),
   TransferZod
 ]);
-var BridgeToRemoteResponseZod = PayloadZodStrictOfSchema2(BridgeSourceObservationSchema).extend(BridgeSourceObservationFieldsZod.shape);
+var BridgeToRemoteResponseZod = PayloadZodStrictOfSchema2(BridgeSourceObservationSchema3).extend(BridgeSourceObservationFieldsZod2.shape);
 var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
   const params = z2.object({
     chainId: getRemoteChainIdZod(config)
@@ -1419,22 +1955,22 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
         ]
       ];
       const existingFlow = await getXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction);
-      if (isDefined12(existingFlow)) {
+      if (isDefined15(existingFlow)) {
         res.status(200).send();
         return;
       }
       await createXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction, [
         bridgeIntent
       ]);
-      const srcConfirmation = await PayloadBuilder14.hash(signedTxBw);
-      const bridgeCommonFieldsZod = z2.object({}).extend(BridgeSourceObservationFieldsZod.shape);
+      const srcConfirmation = await PayloadBuilder16.hash(signedTxBw);
+      const bridgeCommonFieldsZod = z2.object({}).extend(BridgeSourceObservationFieldsZod2.shape);
       const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent);
       const bridgeObservationFields = {
         ...bridgeCommonFields,
         srcConfirmation
       };
-      const bridgeObservation = new PayloadBuilder14({
-        schema: BridgeSourceObservationSchema
+      const bridgeObservation = new PayloadBuilder16({
+        schema: BridgeSourceObservationSchema3
       }).fields(bridgeObservationFields).build();
       res.status(202).json(bridgeObservation);
     })
@@ -1443,18 +1979,18 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
 import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
-import { assertEx as assertEx19, hexToBigInt as hexToBigInt10, toAddress as toAddress3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx22, hexToBigInt as hexToBigInt10, toAddress as toAddress3 } from "@xylabs/sdk-js";
 import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3 } from "@xyo-network/sdk-js";
-import { BridgeIntentFieldsZod as BridgeIntentFieldsZod2, BridgeIntentSchema as BridgeIntentSchema4, buildUnsignedTransaction, toXL1BlockNumber, TransactionBoundWitnessZod, TransferZod as TransferZod2 } from "@xyo-network/xl1-sdk";
+import { BridgeIntentFieldsZod as BridgeIntentFieldsZod3, BridgeIntentSchema as BridgeIntentSchema6, buildUnsignedTransaction, toXL1BlockNumber, TransactionBoundWitnessZod, TransferZod as TransferZod2 } from "@xyo-network/xl1-sdk";
 import { z as z3 } from "zod";
-var BridgeToRemoteEstimateBodyZod = BridgeIntentFieldsZod2.pick({
+var BridgeToRemoteEstimateBodyZod = BridgeIntentFieldsZod3.pick({
   destAddress: true,
   srcAddress: true,
   srcAmount: true
 });
 var BridgeToRemoteEstimateResponseZod = z3.tuple([
   TransactionBoundWitnessZod,
-  PayloadZodStrictOfSchema3(BridgeIntentSchema4).extend(BridgeIntentFieldsZod2.shape),
+  PayloadZodStrictOfSchema3(BridgeIntentSchema6).extend(BridgeIntentFieldsZod3.shape),
   TransferZod2
 ]);
 var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) => {
@@ -1479,7 +2015,7 @@ var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) =
       }
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
       const sender = toAddress3(srcAddress);
-      const viewer = assertEx19(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const viewer = assertEx22(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);
@@ -1499,18 +2035,18 @@ var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) =
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteMaxEstimate.ts
 import { requestHandlerValidator as requestHandlerValidator5 } from "@xylabs/express";
-import { assertEx as assertEx20, hexToBigInt as hexToBigInt11, toAddress as toAddress4, toHex as toHex4 } from "@xylabs/sdk-js";
+import { assertEx as assertEx23, hexToBigInt as hexToBigInt11, toAddress as toAddress4, toHex as toHex5 } from "@xylabs/sdk-js";
 import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema4 } from "@xyo-network/sdk-js";
-import { BridgeIntentFieldsZod as BridgeIntentFieldsZod3, BridgeIntentSchema as BridgeIntentSchema5, buildUnsignedTransaction as buildUnsignedTransaction2, toXL1BlockNumber as toXL1BlockNumber2, TransactionBoundWitnessZod as TransactionBoundWitnessZod2, TransferZod as TransferZod3 } from "@xyo-network/xl1-sdk";
+import { BridgeIntentFieldsZod as BridgeIntentFieldsZod4, BridgeIntentSchema as BridgeIntentSchema7, buildUnsignedTransaction as buildUnsignedTransaction2, toXL1BlockNumber as toXL1BlockNumber2, TransactionBoundWitnessZod as TransactionBoundWitnessZod2, TransferZod as TransferZod3 } from "@xyo-network/xl1-sdk";
 import { z as z4 } from "zod";
-var BridgeToRemoteMaxEstimateBodyZod = BridgeIntentFieldsZod3.pick({
+var BridgeToRemoteMaxEstimateBodyZod = BridgeIntentFieldsZod4.pick({
   destAddress: true,
   srcAddress: true,
   srcAmount: true
 });
 var BridgeToRemoteMaxEstimateResponseZod = z4.tuple([
   TransactionBoundWitnessZod2,
-  PayloadZodStrictOfSchema4(BridgeIntentSchema5).extend(BridgeIntentFieldsZod3.shape),
+  PayloadZodStrictOfSchema4(BridgeIntentSchema7).extend(BridgeIntentFieldsZod4.shape),
   TransferZod3
 ]);
 var makeBridgeToRemoteMaxEstimateRoute = /* @__PURE__ */ __name((config, gateway) => {
@@ -1532,10 +2068,10 @@ var makeBridgeToRemoteMaxEstimateRoute = /* @__PURE__ */ __name((config, gateway
         feeFixed,
         feeRateBasisPoints
       });
-      const maxBridgeAmount = toHex4(hexToBigInt11(balanceMax) < hexToBigInt11(configMax) ? balanceMax : configMax);
+      const maxBridgeAmount = toHex5(hexToBigInt11(balanceMax) < hexToBigInt11(configMax) ? balanceMax : configMax);
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, maxBridgeAmount, destAddress, config);
       const sender = toAddress4(srcAddress);
-      const viewer = assertEx20(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const viewer = assertEx23(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
       const currentBlockNumber = await viewer.currentBlockNumber();
       const nbf = toXL1BlockNumber2(currentBlockNumber, true);
       const exp = toXL1BlockNumber2(currentBlockNumber + 1e3, true);
@@ -1555,26 +2091,26 @@ var makeBridgeToRemoteMaxEstimateRoute = /* @__PURE__ */ __name((config, gateway
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteStatus.ts
 import { requestHandlerValidator as requestHandlerValidator6 } from "@xylabs/express";
-import { asHex as asHex3, isDefined as isDefined13 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder15, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema5 } from "@xyo-network/sdk-js";
-import { asBridgeIntent, BridgeDestinationObservationFieldsZod as BridgeDestinationObservationFieldsZod2, BridgeDestinationObservationSchema as BridgeDestinationObservationSchema2, BridgeIntentFieldsZod as BridgeIntentFieldsZod4, BridgeIntentSchema as BridgeIntentSchema6, BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod2, BridgeSourceObservationSchema as BridgeSourceObservationSchema2, isBridgeIntent as isBridgeIntent5 } from "@xyo-network/xl1-sdk";
+import { asHex as asHex4, isDefined as isDefined16 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder17, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema5 } from "@xyo-network/sdk-js";
+import { asBridgeIntent, BridgeDestinationObservationFieldsZod as BridgeDestinationObservationFieldsZod2, BridgeDestinationObservationSchema as BridgeDestinationObservationSchema2, BridgeIntentFieldsZod as BridgeIntentFieldsZod5, BridgeIntentSchema as BridgeIntentSchema8, BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod3, BridgeSourceObservationSchema as BridgeSourceObservationSchema4, isBridgeIntent as isBridgeIntent5 } from "@xyo-network/xl1-sdk";
 import { z as z5 } from "zod";
-var BridgeIntentResponseZod = PayloadZodStrictOfSchema5(BridgeIntentSchema6).extend(BridgeIntentFieldsZod4.shape);
-var BridgeSourceResponseZod = PayloadZodStrictOfSchema5(BridgeSourceObservationSchema2).extend(BridgeSourceObservationFieldsZod2.shape);
-var BridgeDestinationResponseZod = PayloadZodStrictOfSchema5(BridgeDestinationObservationSchema2).extend(BridgeDestinationObservationFieldsZod2.shape);
+var BridgeIntentResponseZod2 = PayloadZodStrictOfSchema5(BridgeIntentSchema8).extend(BridgeIntentFieldsZod5.shape);
+var BridgeSourceResponseZod2 = PayloadZodStrictOfSchema5(BridgeSourceObservationSchema4).extend(BridgeSourceObservationFieldsZod3.shape);
+var BridgeDestinationResponseZod2 = PayloadZodStrictOfSchema5(BridgeDestinationObservationSchema2).extend(BridgeDestinationObservationFieldsZod2.shape);
 var BridgeToRemoteStatusResponseZod = z5.union([
   z5.tuple([]),
   z5.tuple([
-    BridgeIntentResponseZod
+    BridgeIntentResponseZod2
   ]),
   z5.tuple([
-    BridgeIntentResponseZod,
-    BridgeSourceResponseZod
+    BridgeIntentResponseZod2,
+    BridgeSourceResponseZod2
   ]),
   z5.tuple([
-    BridgeIntentResponseZod,
-    BridgeSourceResponseZod,
-    BridgeDestinationResponseZod
+    BridgeIntentResponseZod2,
+    BridgeSourceResponseZod2,
+    BridgeDestinationResponseZod2
   ])
 ]);
 var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
@@ -1602,14 +2138,14 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
       ];
       const bridgeIntent = allPayloads.find(isBridgeIntent5);
       if (!bridgeIntent) return res.sendStatus(404);
-      result[0] = asBridgeIntent(PayloadBuilder15.omitMeta(bridgeIntent));
+      result[0] = asBridgeIntent(PayloadBuilder17.omitMeta(bridgeIntent));
       const { xl1TransactionMonitorJob } = statusQueueJobs;
       const xl1MonitorState = xl1TransactionMonitorJob ? await xl1TransactionMonitorJob.getState() : void 0;
       if (xl1MonitorState === "completed") {
         const srcConfirmation = xl1TransactionMonitorJob?.returnvalue?.submissionHash;
-        if (isDefined13(srcConfirmation)) {
-          const schema = BridgeSourceObservationSchema2;
-          const bridgeSourceObservationFields = BridgeSourceObservationFieldsZod2.parse(bridgeIntent);
+        if (isDefined16(srcConfirmation)) {
+          const schema = BridgeSourceObservationSchema4;
+          const bridgeSourceObservationFields = BridgeSourceObservationFieldsZod3.parse(bridgeIntent);
           const observation = {
             schema,
             ...bridgeSourceObservationFields,
@@ -1621,8 +2157,8 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
       const { ethTransactionMonitorJob } = statusQueueJobs;
       const ethMonitorState = ethTransactionMonitorJob ? await ethTransactionMonitorJob.getState() : void 0;
       if (ethMonitorState === "completed") {
-        const destConfirmation = asHex3(ethTransactionMonitorJob?.returnvalue?.submissionHash);
-        if (isDefined13(destConfirmation)) {
+        const destConfirmation = asHex4(ethTransactionMonitorJob?.returnvalue?.submissionHash);
+        if (isDefined16(destConfirmation)) {
           const schema = BridgeDestinationObservationSchema2;
           const bridgeDestinationObservationFields = BridgeDestinationObservationFieldsZod2.parse(bridgeIntent);
           const observation = {
@@ -1676,7 +2212,7 @@ var getApp = /* @__PURE__ */ __name((config, gateway) => {
 }, "getApp");
 
 // src/services/getServices.ts
-import { assertEx as assertEx21 } from "@xylabs/sdk-js";
+import { assertEx as assertEx24 } from "@xylabs/sdk-js";
 import { initEvmProvider, resolveWalletForActor as resolveWalletForActor2 } from "@xyo-network/chain-orchestration";
 import { BridgeableToken__factory, LiquidityPoolBridge__factory } from "@xyo-network/typechain";
 import { getAddress as getAddress2, Wallet } from "ethers";
@@ -1718,6 +2254,8 @@ var getServices = /* @__PURE__ */ __name(async (context, gateway) => {
   const { config } = context;
   const ethTxStateMap = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_eth_tx_state");
   const xl1TxStateMap = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_xl1_tx_state");
+  const evmBridgeCursorMap = await getIterableMap(config, "liquidity_bridge_eth_to_xl1_scanner_cursor");
+  const bridgeFulfillmentMap = await getIterableMap(config, "liquidity_bridge_eth_to_xl1_fulfillment");
   const provider = await initEvmProvider(context);
   const { remoteBridgeContractAddress, remoteChainWalletPrivateKey, remoteTokenAddress, accountPath } = config;
   const account = await resolveWalletForActor2(config.name, accountPath);
@@ -1725,14 +2263,18 @@ var getServices = /* @__PURE__ */ __name(async (context, gateway) => {
   const bridgeableToken = BridgeableToken__factory.connect(getAddress2(remoteTokenAddress), wallet);
   const bridge = LiquidityPoolBridge__factory.connect(getAddress2(remoteBridgeContractAddress), wallet);
   const bridgeOwner = await bridge.owner();
-  assertEx21(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
+  assertEx24(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
+  const remoteConfirmationDepth = getRemoteConfirmationDepth(config);
   return {
     account,
     bridge,
     bridgeableToken,
+    bridgeFulfillmentMap,
     ethTxStateMap,
+    evmBridgeCursorMap,
     gateway,
     provider,
+    remoteConfirmationDepth,
     wallet,
     xl1TxStateMap
   };
@@ -1754,7 +2296,13 @@ var getServer = /* @__PURE__ */ __name(async (context, 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}`));
+  const server = await new Promise((resolve, reject) => {
+    const srv = app.listen(port, hostname, () => {
+      logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`);
+      resolve(srv);
+    });
+    srv.once("error", reject);
+  });
   server.setTimeout(2e4);
   return {
     server,
@@ -1762,6 +2310,139 @@ var getServer = /* @__PURE__ */ __name(async (context, gateway) => {
   };
 }, "getServer");
 
+// src/telemetry/createBalanceMonitor.ts
+var DEFAULT_INTERVAL_MS = 6e4;
+var WEI_PER_GWEI = 10n ** 9n;
+var TOKEN_DECIMALS = 10n ** 18n;
+function createBalanceMonitor(config) {
+  const { account, bridge, bridgeableToken, gateway, meter, provider, wallet, intervalMs = DEFAULT_INTERVAL_MS } = config;
+  let timer;
+  const ethWalletGasBalance = meter.createGauge("bridge_eth_wallet_gas_balance_gwei", {
+    description: "ETH balance of the bridge runner wallet (in gwei)",
+    unit: "gwei"
+  });
+  const liquidityTokenBalance = meter.createGauge("bridge_eth_liquidity_token_balance", {
+    description: "ERC-20 token balance of the liquidity source (in whole tokens)",
+    unit: "tokens"
+  });
+  const liquidityTokenAllowance = meter.createGauge("bridge_eth_liquidity_token_allowance", {
+    description: "ERC-20 token allowance from liquidity source to bridge contract (in whole tokens)",
+    unit: "tokens"
+  });
+  const xl1AccountBalance = meter.createGauge("bridge_xl1_account_balance", {
+    description: "XL1 native balance of the bridge reserve account (in whole XL1)",
+    unit: "xl1"
+  });
+  const walletAddress = wallet.address;
+  async function poll() {
+    try {
+      const balance = await provider.getBalance(walletAddress);
+      ethWalletGasBalance.record(Number(balance / WEI_PER_GWEI), {
+        address: walletAddress
+      });
+    } catch (err) {
+      console.error("[BalanceMonitor] Failed to read ETH wallet gas balance:", err);
+    }
+    try {
+      const liquiditySourceAddress = await bridge.liquiditySource();
+      const balance = await bridgeableToken.balanceOf(liquiditySourceAddress);
+      liquidityTokenBalance.record(Number(balance / TOKEN_DECIMALS), {
+        address: liquiditySourceAddress
+      });
+    } catch (err) {
+      console.error("[BalanceMonitor] Failed to read liquidity source token balance:", err);
+    }
+    try {
+      const liquiditySourceAddress = await bridge.liquiditySource();
+      const bridgeAddress = await bridge.getAddress();
+      const allowance = await bridgeableToken.allowance(liquiditySourceAddress, bridgeAddress);
+      liquidityTokenAllowance.record(Number(allowance / TOKEN_DECIMALS), {
+        address: liquiditySourceAddress
+      });
+    } catch (err) {
+      console.error("[BalanceMonitor] Failed to read liquidity source token allowance:", err);
+    }
+    try {
+      const viewer = gateway.connection.viewer;
+      if (viewer) {
+        const balance = await viewer.account.balance.accountBalance(account.address);
+        xl1AccountBalance.record(Number(balance / TOKEN_DECIMALS), {
+          address: account.address.toString()
+        });
+      }
+    } catch (err) {
+      console.error("[BalanceMonitor] Failed to read XL1 account balance:", err);
+    }
+  }
+  __name(poll, "poll");
+  return {
+    start() {
+      void poll();
+      timer = setInterval(() => void poll(), intervalMs);
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
+__name(createBalanceMonitor, "createBalanceMonitor");
+
+// src/telemetry/createQueueMetrics.ts
+var DEFAULT_INTERVAL_MS2 = 3e4;
+function createQueueMetrics(config) {
+  const { meter, queues, intervalMs = DEFAULT_INTERVAL_MS2 } = config;
+  let timer;
+  const waitingGauge = meter.createGauge("bridge_queue_waiting", {
+    description: "Number of waiting jobs in the bridge queue"
+  });
+  const activeGauge = meter.createGauge("bridge_queue_active", {
+    description: "Number of active jobs in the bridge queue"
+  });
+  const completedGauge = meter.createGauge("bridge_queue_completed", {
+    description: "Number of completed jobs in the bridge queue"
+  });
+  const failedGauge = meter.createGauge("bridge_queue_failed", {
+    description: "Number of failed jobs in the bridge queue"
+  });
+  const delayedGauge = meter.createGauge("bridge_queue_delayed", {
+    description: "Number of delayed jobs in the bridge queue"
+  });
+  async function poll() {
+    for (const [name13, queue] of Object.entries(queues)) {
+      try {
+        const counts = await queue.getJobCounts("waiting", "active", "completed", "failed", "delayed");
+        const attrs = {
+          queue_name: name13
+        };
+        waitingGauge.record(counts.waiting ?? 0, attrs);
+        activeGauge.record(counts.active ?? 0, attrs);
+        completedGauge.record(counts.completed ?? 0, attrs);
+        failedGauge.record(counts.failed ?? 0, attrs);
+        delayedGauge.record(counts.delayed ?? 0, attrs);
+      } catch (err) {
+        console.error(`[QueueMetrics] Failed to read job counts for queue ${name13}:`, err);
+      }
+    }
+  }
+  __name(poll, "poll");
+  return {
+    start() {
+      void poll();
+      timer = setInterval(() => void poll(), intervalMs);
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
+__name(createQueueMetrics, "createQueueMetrics");
+
 // src/BridgeActor.ts
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -1774,9 +2455,16 @@ var BridgeActor = class extends ActorV3 {
   static {
     __name(this, "BridgeActor");
   }
+  static needs = {
+    required: [
+      XyoGatewayRunnerMoniker,
+      XyoViewerMoniker
+    ]
+  };
   _gatewayRunner;
   _balanceMonitor;
   _queueMetrics;
+  _scannerRunner;
   server;
   get gatewayRunner() {
     return this._gatewayRunner;
@@ -1792,6 +2480,8 @@ var BridgeActor = class extends ActorV3 {
   }
   async stopHandler() {
     await super.stopHandler();
+    await this._scannerRunner?.stop();
+    this._scannerRunner = void 0;
     this._balanceMonitor?.stop();
     this._queueMetrics?.stop();
     this._balanceMonitor = void 0;
@@ -1800,8 +2490,21 @@ var BridgeActor = class extends ActorV3 {
   }
   async startServer() {
     const context = asBridgeConfigContext(this.context, true);
+    const config = context.config;
     const { server, services } = await getServer(context, this._gatewayRunner);
     this.server = server;
+    const connection2 = getConnection(config);
+    const telemetry2 = getTelemetry();
+    const flowProducer2 = getFlowProducer(connection2, telemetry2);
+    this._scannerRunner = buildEvmBridgeScannerRunner({
+      config,
+      connection: connection2,
+      flowProducer: flowProducer2,
+      logger: this.logger,
+      services,
+      telemetry: telemetry2
+    });
+    await this._scannerRunner.start();
     if (this.meter) {
       this._balanceMonitor = createBalanceMonitor({
         account: services.account,
@@ -1813,7 +2516,10 @@ var BridgeActor = class extends ActorV3 {
         wallet: services.wallet
       });
       this._balanceMonitor.start();
-      const queues = getXl1ToEthQueues(context.config);
+      const queues = {
+        ...getXl1ToEthQueues(config),
+        ...getEthToXl1Queues(config)
+      };
       this._queueMetrics = createQueueMetrics({
         meter: this.meter,
         queues
@@ -1829,9 +2535,59 @@ var BridgeActor = class extends ActorV3 {
 BridgeActor = _ts_decorate([
   creatable()
 ], BridgeActor);
+
+// src/command.ts
+import { BridgeConfigZod } from "@xyo-network/chain-orchestration";
+
+// src/run.ts
+import { exists } from "@xylabs/sdk-js";
+import { initActorWallet } from "@xyo-network/chain-orchestration";
+var getBridgeActor = /* @__PURE__ */ __name(async (config, locator) => {
+  const account = await initActorWallet({
+    config,
+    logger: locator.context.logger,
+    singletons: {},
+    caches: {}
+  });
+  return await BridgeActor.create({
+    account,
+    config,
+    locator
+  });
+}, "getBridgeActor");
+var runBridge = /* @__PURE__ */ __name(async (config, orchestrator, locator) => {
+  const bridge = await getBridgeActor(config, locator);
+  const actors = [
+    bridge
+  ].filter(exists);
+  for (const actor of actors) {
+    await orchestrator.registerActor(actor);
+  }
+  await orchestrator.start();
+}, "runBridge");
+
+// src/command.ts
+function bridgeCommand(getConfiguration, getLocatorsFromConfig) {
+  return {
+    command: "bridge",
+    deprecated: 'Use "start bridge" instead',
+    describe: "Run a XL1 Bridge Node",
+    handler: /* @__PURE__ */ __name(async () => {
+      const configuration = getConfiguration();
+      const { locators, orchestrator } = await getLocatorsFromConfig([
+        "bridge"
+      ], configuration);
+      await runBridge(BridgeConfigZod.parse(locators["bridge"].context.config), orchestrator, locators["bridge"]);
+    }, "handler")
+  };
+}
+__name(bridgeCommand, "bridgeCommand");
 export {
   BridgeActor,
+  bridgeCommand,
   createBalanceMonitor,
-  createQueueMetrics
+  createQueueMetrics,
+  getBridgeActor,
+  runBridge
 };
 //# sourceMappingURL=index.mjs.map