@xyo-network/chain-bridge 1.23.0 → 2.0.0

package/dist/node/index.mjs

@@ -1,5 +1,15 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/BridgeActor.ts
 import { creatable } from "@xylabs/sdk-js";
@@ -16,7 +26,7 @@ import { isDefined } from "@xylabs/sdk-js";
 import { Redis } from "ioredis";
 var connection;
 var maxRetriesPerRequest = null;
-var getConnection = /* @__PURE__ */ __name((config) => {
+var getConnection = (config) => {
   if (isDefined(connection)) return connection;
   const { redisHost: host, redisPort: port } = config;
   connection = new Redis({
@@ -25,7 +35,7 @@ var getConnection = /* @__PURE__ */ __name((config) => {
     maxRetriesPerRequest
   });
   return connection;
-}, "getConnection");
+};
 
 // src/services/queue/flowProducer.ts
 import { isDefined as isDefined2 } from "@xylabs/sdk-js";
@@ -36,7 +46,7 @@ var prefix = "xl1-bridge";
 
 // src/services/queue/flowProducer.ts
 var flowProducer;
-var getFlowProducer = /* @__PURE__ */ __name((connection2, telemetry2) => {
+var getFlowProducer = (connection2, telemetry2) => {
   if (isDefined2(flowProducer)) return flowProducer;
   flowProducer = new FlowProducer({
     connection: connection2,
@@ -44,355 +54,392 @@ var getFlowProducer = /* @__PURE__ */ __name((connection2, telemetry2) => {
     prefix
   });
   return flowProducer;
-}, "getFlowProducer");
+};
 
 // src/services/queue/workers/EthEventVerification.ts
-import { assertEx as assertEx2, isNull } from "@xylabs/sdk-js";
+import {
+  assertEx as assertEx7,
+  isNull,
+  spanAsync as spanAsync4
+} 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 { 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);
+// src/telemetry/bucketFailureReason.ts
+function bucketFailureReason(failedReason) {
+  if (/below_min_bridge_amount/i.test(failedReason)) return "below_min_bridge_amount";
+  if (/reserve below required|reserve_insufficient/i.test(failedReason)) return "reserve_insufficient";
+  if (/bridgestoremote slot empty|orphaned by reorg|non-canonical at/i.test(failedReason)) return "orphaned_at_depth";
+  if (/attempts? exhausted|attempt \d+ expired/i.test(failedReason)) return "attempts_exhausted";
+  return "other";
 }
-__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;
+// src/telemetry/createBalanceMonitor.ts
+import { spanAsync } from "@xylabs/sdk-js";
+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,
+    remoteChainId,
+    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() {
+    await spanAsync("bridge:balance-monitor:poll", async () => {
+      try {
+        const balance = await provider.getBalance(walletAddress);
+        ethWalletGasBalance.record(Number(balance / WEI_PER_GWEI), { address: walletAddress, remoteChainId });
+      } 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, remoteChainId });
+      } 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, remoteChainId });
+      } 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(), remoteChainId });
+        }
+      } catch (err) {
+        console.error("[BalanceMonitor] Failed to read XL1 account balance:", err);
+      }
+    }, { timeBudgetLimit: 2e3 });
   }
   return {
-    amount: data.amount,
-    destAddress: toAddress(data.destAddress),
-    destToken: toAddress(data.destToken),
-    evmTxHash: asHex(event.transactionHash, true),
-    srcAddress: toAddress(data.srcAddress)
+    start() {
+      void poll();
+      timer = setInterval(() => void poll(), intervalMs);
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+    }
   };
 }
-__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 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: []
+// src/telemetry/createBridgeFlowMetrics.ts
+function createBridgeFlowMetrics(config) {
+  const { meter, remoteChainId } = config;
+  if (meter === void 0) {
+    const noop = () => {
     };
-    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 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;
-    await stateMap.set(hash, state);
     return {
-      blockHash,
-      blockNumber,
-      submissionHash
+      recordAttemptExpiration: noop,
+      recordRetried: noop,
+      recordSuccess: noop,
+      recordTerminalFailure: noop
     };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
-  worker.on("failed", (job, err) => {
-    console.error(`[${name3}] Job ${job?.id} failed:`, err.message);
-  });
-  worker.on("error", (err) => {
-    console.error(`[${name3}] Worker error:`, err);
-  });
-}, "createWorker");
-var EthTransactionMonitor = {
-  createWorker: createWorker3,
-  name: name3,
-  queueName: queueName3
-};
+  }
+  const completed = meter.createCounter(
+    "bridge_completed_total",
+    { description: "Successful bridge settlements, per direction" }
+  );
+  const settleLatency = meter.createHistogram(
+    "bridge_settle_latency_seconds",
+    { description: "Wall-clock seconds from acceptance to fulfillment, per direction", unit: "s" }
+  );
+  const feeRevenue = meter.createCounter(
+    "bridge_fee_revenue_total",
+    { description: "Cumulative bridge fees collected (AttoXL1), per direction and token", unit: "AttoXL1" }
+  );
+  const attemptExpirations = meter.createCounter(
+    "bridge_attempt_expirations_total",
+    { description: "Per-attempt failures that did not exhaust retries \u2014 chain or network friction" }
+  );
+  const terminalFailures = meter.createCounter(
+    "bridge_terminal_failures_total",
+    { description: "Terminal failures (retries exhausted or UnrecoverableError), bucketed by reason" }
+  );
+  const retried = meter.createCounter(
+    "bridge_retried_total",
+    { description: "Operator-initiated retries (failed \u2192 waiting), per direction and trigger" }
+  );
+  return {
+    recordSuccess({
+      direction,
+      feeAmount,
+      latencySeconds,
+      token
+    }) {
+      completed.add(1, { remoteChainId, direction });
+      if (latencySeconds !== void 0) {
+        settleLatency.record(latencySeconds, { remoteChainId, direction });
+      }
+      feeRevenue.add(Number(feeAmount), {
+        remoteChainId,
+        direction,
+        token
+      });
+    },
+    recordAttemptExpiration({ direction }) {
+      attemptExpirations.add(1, { remoteChainId, direction });
+    },
+    recordRetried({
+      count,
+      direction,
+      trigger
+    }) {
+      const delta = count ?? 1;
+      if (delta <= 0) return;
+      retried.add(delta, {
+        remoteChainId,
+        direction,
+        trigger
+      });
+    },
+    recordTerminalFailure({ direction, reason }) {
+      terminalFailures.add(1, {
+        remoteChainId,
+        direction,
+        reason
+      });
+    }
+  };
+}
 
-// 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/telemetry/createInFlightPoller.ts
+import { spanAsync as spanAsync2 } from "@xylabs/sdk-js";
+var DEFAULT_INTERVAL_MS2 = 6e4;
+function createInFlightPoller(config) {
+  const {
+    bridgeFulfillmentMap,
+    meter,
+    remoteChainId,
+    intervalMs = DEFAULT_INTERVAL_MS2
+  } = config;
+  let timer;
+  const inFlightGauge = meter.createGauge(
+    "bridge_in_flight",
+    { description: "Bridges currently in-flight (canonical observed, fulfillment pending), per direction" }
+  );
+  const poll = async () => {
+    await spanAsync2("bridge:inflight:poll", async () => {
+      try {
+        let count = 0;
+        for await (const [, state] of bridgeFulfillmentMap) {
+          if (state.canonical !== void 0 && state.fulfilled === void 0) count++;
+        }
+        inFlightGauge.record(count, { remoteChainId, direction: "inbound" });
+      } catch (err) {
+        console.error("[InFlightPoller] Failed to poll bridgeFulfillmentMap:", err);
+      }
+    }, { timeBudgetLimit: 1e3 });
+  };
+  return {
+    poll,
+    start() {
+      void poll();
+      timer = setInterval(() => void poll(), intervalMs);
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
 
-// src/services/validation/validateBridgeEstimateExact.ts
-import { hexToBigInt as hexToBigInt5, isUndefined } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
+// src/telemetry/createQueueMetrics.ts
+import { spanAsync as spanAsync3 } from "@xylabs/sdk-js";
+var DEFAULT_INTERVAL_MS3 = 3e4;
+function createQueueMetrics(config) {
+  const {
+    meter,
+    queues,
+    remoteChainId,
+    intervalMs = DEFAULT_INTERVAL_MS3
+  } = 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() {
+    await spanAsync3("bridge:queue-metrics:poll", async () => {
+      for (const [name13, queue] of Object.entries(queues)) {
+        try {
+          const counts = await queue.getJobCounts("waiting", "active", "completed", "failed", "delayed");
+          const attrs = { queue_name: name13, remoteChainId };
+          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);
+        }
+      }
+    }, { timeBudgetLimit: 1e3 });
+  }
+  return {
+    start() {
+      void poll();
+      timer = setInterval(() => void poll(), intervalMs);
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
 
 // src/services/evm/asChainId.ts
-import { asHex as asHex2 } from "@xylabs/sdk-js";
-var asChainId = /* @__PURE__ */ __name((value) => {
-  const chainId = asHex2(value);
+import { asHex } from "@xylabs/sdk-js";
+var asChainId = (value) => {
+  const chainId = asHex(value);
   return chainId;
-}, "asChainId");
+};
 
 // src/services/evm/asToken.ts
 import { asAddress } from "@xylabs/sdk-js";
-var asToken = /* @__PURE__ */ __name((value) => {
+var asToken = (value) => {
   const token = asAddress(value);
   return token;
-}, "asToken");
+};
 
 // src/services/evm/getBridgeEscrowAddress.ts
-import { asAddress as asAddress2, assertEx as assertEx4 } from "@xylabs/sdk-js";
-var tryGetBridgeEscrowAddress = /* @__PURE__ */ __name((config) => {
+import { asAddress as asAddress2, assertEx } from "@xylabs/sdk-js";
+var tryGetBridgeEscrowAddress = (config) => {
   const address = asAddress2(config.escrowAddress);
   return address;
-}, "tryGetBridgeEscrowAddress");
+};
 
 // src/services/evm/getBridgeFeesAddress.ts
-import { asAddress as asAddress3, assertEx as assertEx5 } from "@xylabs/sdk-js";
-var tryGetBridgeFeesAddress = /* @__PURE__ */ __name((config) => {
+import { asAddress as asAddress3, assertEx as assertEx2 } from "@xylabs/sdk-js";
+var tryGetBridgeFeesAddress = (config) => {
   const address = asAddress3(config.feesAddress);
   return address;
-}, "tryGetBridgeFeesAddress");
+};
 
 // src/services/evm/getFeeStructure.ts
-var getFeeStructure = /* @__PURE__ */ __name((config) => {
+var getFeeStructure = (config) => {
   const { feeFixed, feeRateBasisPoints } = config;
-  return {
-    feeFixed,
-    feeRateBasisPoints
-  };
-}, "getFeeStructure");
+  return { feeFixed, feeRateBasisPoints };
+};
 
 // src/services/evm/getMaxBridgeAmount.ts
-var getMaxBridgeAmount = /* @__PURE__ */ __name((config) => {
+var getMaxBridgeAmount = (config) => {
   const { maxBridgeAmount } = config;
   return maxBridgeAmount;
-}, "getMaxBridgeAmount");
+};
 
 // src/services/evm/getMinBridgeAmount.ts
-var getMinBridgeAmount = /* @__PURE__ */ __name((config) => {
+var getMinBridgeAmount = (config) => {
   const { minBridgeAmount } = config;
   return minBridgeAmount;
-}, "getMinBridgeAmount");
+};
 
 // src/services/evm/getRemoteChainId.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
-var getRemoteChainId = /* @__PURE__ */ __name((config) => {
-  const remoteChainId = assertEx6(asChainId(config.remoteChainId), () => "Invalid remote chain ID in config");
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+var getRemoteChainId = (config) => {
+  const remoteChainId = assertEx3(asChainId(config.remoteChainId), () => "Invalid remote chain ID in config");
   return remoteChainId;
-}, "getRemoteChainId");
+};
 
 // src/services/evm/getRemoteTokenAddress.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
-var getRemoteTokenAddress = /* @__PURE__ */ __name((config) => {
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+var getRemoteTokenAddress = (config) => {
   const token = asToken(config.remoteTokenAddress);
-  return assertEx7(token, () => "Remote token address is not defined in bridge configuration");
-}, "getRemoteTokenAddress");
+  return assertEx4(token, () => "Remote token address is not defined in bridge configuration");
+};
 
 // src/services/evm/getBridgeWalletAccount.ts
 import { isDefined as isDefined3 } from "@xylabs/sdk-js";
 import { resolveWalletForActor } from "@xyo-network/chain-orchestration";
 var accountServiceSingleton;
-var getBridgeWalletAccount = /* @__PURE__ */ __name(async (config) => {
+var getBridgeWalletAccount = async (config) => {
   if (accountServiceSingleton) return accountServiceSingleton;
   const accountPath = typeof config.accountPath === "string" ? config.accountPath : void 0;
   const account = await resolveWalletForActor(config.name, accountPath);
   accountServiceSingleton = account;
   return accountServiceSingleton;
-}, "getBridgeWalletAccount");
+};
 
 // src/services/evm/getTransferAddresses.ts
-var getTransferAddresses = /* @__PURE__ */ __name(async (config) => {
+var getTransferAddresses = async (config) => {
   const escrowAddress = tryGetBridgeEscrowAddress(config) ?? (await getBridgeWalletAccount(config)).address;
   const feesAddress = tryGetBridgeFeesAddress(config) ?? (await getBridgeWalletAccount(config)).address;
-  return {
-    escrowAddress,
-    feesAddress
-  };
-}, "getTransferAddresses");
+  return { escrowAddress, feesAddress };
+};
 
 // src/services/evm/getXl1ChainId.ts
-import { assertEx as assertEx8, isDefined as isDefined4 } from "@xylabs/sdk-js";
-var getXl1ChainId = /* @__PURE__ */ __name((config) => {
+import { assertEx as assertEx5, isDefined as isDefined4 } from "@xylabs/sdk-js";
+var getXl1ChainId = (config) => {
   const xl1ChainId = config.xl1ChainId;
   if (isDefined4(xl1ChainId)) {
-    return assertEx8(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
+    return assertEx5(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
   }
-  return assertEx8(asChainId(config.chain.id), () => "Invalid chain.id in config");
-}, "getXl1ChainId");
+  return assertEx5(asChainId(config.chain.id), () => "Invalid chain.id in config");
+};
 
 // src/services/evm/getXl1TokenAddress.ts
 import { isDefined as isDefined5 } from "@xylabs/sdk-js";
-var getXl1TokenAddress = /* @__PURE__ */ __name((config) => {
+var getXl1TokenAddress = (config) => {
   const token = asToken(config.xl1TokenAddress);
   if (isDefined5(token)) return token;
   return getXl1ChainId(config);
-}, "getXl1TokenAddress");
+};
 
 // src/services/evm/getBridgeSettings.ts
-var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
+var getBridgeSettings = async (config) => {
   const { feeFixed, feeRateBasisPoints } = getFeeStructure(config);
   const { feesAddress, escrowAddress } = await getTransferAddresses(config);
   const maxBridgeAmount = getMaxBridgeAmount(config);
@@ -413,111 +460,479 @@ var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
     xl1TokenAddress,
     xl1ChainId
   };
-}, "getBridgeSettings");
+};
 
 // src/services/evm/getRemoteConfirmationDepth.ts
-import { isDefined as isDefined6 } from "@xylabs/sdk-js";
-var HARDHAT_CHAIN_ID = "0x7a69";
-var ETHEREUM_MAINNET_CHAIN_ID = "0x1";
+import { isDefined as isDefined6, toHex } from "@xylabs/sdk-js";
+var HARDHAT_CHAIN_ID = toHex("0x7a69");
+var ETHEREUM_MAINNET_CHAIN_ID = toHex("0x1");
 var FALLBACK_CONFIRMATION_DEPTH = 32;
-var DEFAULT_CONFIRMATION_DEPTH_BY_CHAIN_ID = {
-  [HARDHAT_CHAIN_ID]: 0,
-  [ETHEREUM_MAINNET_CHAIN_ID]: 32
-};
+var DEFAULT_CONFIRMATION_DEPTH_BY_CHAIN_ID = /* @__PURE__ */ new Map([
+  [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;
+  const chainId = toHex(getRemoteChainId(config));
+  return DEFAULT_CONFIRMATION_DEPTH_BY_CHAIN_ID.get(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 = hexToBigInt2(srcAmount);
-  const feeVariableBigInt = srcAmountBigInt * BigInt(feeRateBasisPoints) / 10000n;
-  const feeVariable = toHex2(feeVariableBigInt);
-  return {
+
+// src/services/evm/resolveDeployBlock.ts
+import { getAddress } from "ethers";
+async function contractExistsAt(provider, address, blockNumber) {
+  const code = await provider.getCode(getAddress(address), blockNumber);
+  return code !== "0x" && code.length > 2;
+}
+async function resolveDeployBlockByBinarySearch(provider, address) {
+  const head = await provider.getBlockNumber();
+  if (!await contractExistsAt(provider, address, head)) {
+    throw new Error(`resolveDeployBlockByBinarySearch: no contract code at ${address} at head=${head}`);
+  }
+  let low = 0;
+  let high = head;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if (await contractExistsAt(provider, address, mid)) {
+      high = mid;
+    } else {
+      low = mid + 1;
+    }
+  }
+  return low;
+}
+async function resolveDeployBlock(opts) {
+  const {
+    configuredDeployBlock,
+    contractAddress,
+    provider
+  } = opts;
+  if (configuredDeployBlock !== void 0 && configuredDeployBlock >= 0) return configuredDeployBlock;
+  return resolveDeployBlockByBinarySearch(provider, contractAddress);
+}
+
+// src/services/queue/workers/util/buildAcceptedSnapshot.ts
+import { hexToBigInt, toHex as toHex2 } from "@xylabs/sdk-js";
+import { buildEthToXl1BridgePayloads, calculateBridgeFees } from "@xyo-network/chain-bridge-shared";
+import { PayloadBuilder } from "@xyo-network/sdk-js";
+import {
+  BridgeDestinationObservationFieldsZod,
+  BridgeDestinationObservationSchema,
+  BridgeSourceObservationFieldsZod,
+  BridgeSourceObservationSchema
+} from "@xyo-network/xl1-sdk";
+function buildAcceptedSnapshot(options2) {
+  const {
+    amount,
+    bridgeAccountAddress,
+    bridgeId,
+    destAddress,
+    evmChainId,
+    evmContractAddress,
+    evmSrcAddress,
+    evmTokenAddress,
+    evmTxHash,
     feeFixed,
-    feeVariable,
-    srcAmount
-  };
-}, "calculateBridgeFees");
-
-// 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 = hexToBigInt3(balance);
-  const feeFixedBigInt = hexToBigInt3(feeFixed);
-  if (balanceBigInt <= feeFixedBigInt) return toHex3(0n);
-  const maxAmount = (balanceBigInt - feeFixedBigInt) * 10000n / (10000n + BigInt(feeRateBasisPoints));
-  return toHex3(maxAmount);
-}, "calculateMaxBridgeAmount");
-
-// 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 = hexToBigInt4(srcAmount);
-  const feesAmount = hexToBigInt4(feeFixed) + hexToBigInt4(feeVariable);
-  const transfers = escrowAddress === feesAddress ? {
-    [feesAddress]: escrowAmount + feesAmount
-  } : {
-    [escrowAddress]: escrowAmount,
-    [feesAddress]: feesAmount
+    feeRateBasisPoints,
+    feesAddress,
+    xl1ChainId,
+    xl1TokenAddress
+  } = options2;
+  const acceptedFees = calculateBridgeFees(toHex2(amount), { feeFixed, feeRateBasisPoints });
+  const feesAmount = hexToBigInt(acceptedFees.feeFixed) + hexToBigInt(acceptedFees.feeVariable);
+  const { intent: acceptedIntent } = buildEthToXl1BridgePayloads({
+    amount,
+    bridgeAccountAddress,
+    bridgeId,
+    destAddress,
+    evmChainId,
+    evmContractAddress,
+    evmSrcAddress,
+    evmTokenAddress,
+    feesAddress,
+    feesAmount,
+    xl1ChainId,
+    xl1TokenAddress
+  });
+  const sourceFields = BridgeSourceObservationFieldsZod.parse({
+    ...acceptedIntent,
+    srcConfirmation: evmTxHash
+  });
+  const acceptedSourceObservation = new PayloadBuilder({ schema: BridgeSourceObservationSchema }).fields(sourceFields).build();
+  return {
+    acceptedFees,
+    acceptedIntent,
+    acceptedSourceObservation
   };
-  const transfer = createTransferPayload2(sender, transfers, context);
-  return transfer;
-}, "createBridgeTransfer");
+}
+function buildAcceptedDestinationObservation(intent, destConfirmation) {
+  const fields = BridgeDestinationObservationFieldsZod.parse({
+    ...intent,
+    destConfirmation
+  });
+  return new PayloadBuilder({ schema: BridgeDestinationObservationSchema }).fields(fields).build();
+}
 
-// 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 = toAddress2(srcAddress);
-  const fees = calculateBridgeFees(srcAmount, {
-    feeFixed,
-    feeRateBasisPoints
+// src/services/queue/workers/util/buildEthToXl1ReserveTx.ts
+import { toHex as toHex3 } from "@xylabs/sdk-js";
+import { buildEthToXl1BridgePayloads as buildEthToXl1BridgePayloads2 } from "@xyo-network/chain-bridge-shared";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import { BridgeSourceObservationSchema as BridgeSourceObservationSchema2, buildTransaction } from "@xyo-network/xl1-sdk";
+async function buildEthToXl1ReserveTx(options2) {
+  const {
+    amount,
+    bridgeAccount,
+    bridgeId,
+    destAddress,
+    evmChainId,
+    evmContractAddress,
+    evmSrcAddress,
+    evmTokenAddress,
+    evmTxHash,
+    exp,
+    feesAddress,
+    feesAmount,
+    nbf,
+    xl1ChainId,
+    xl1TokenAddress
+  } = options2;
+  const { intent, transfer } = buildEthToXl1BridgePayloads2({
+    amount,
+    bridgeAccountAddress: bridgeAccount.address,
+    bridgeId,
+    destAddress,
+    evmChainId,
+    evmContractAddress,
+    evmSrcAddress,
+    evmTokenAddress,
+    feesAddress,
+    feesAmount,
+    xl1ChainId,
+    xl1TokenAddress
   });
-  const nonce = nonceOverride ?? v4();
-  const bridgeIntentFields = {
-    // Source
-    src: xl1ChainId,
-    srcAddress: sender,
-    srcAmount,
-    srcToken: xl1TokenAddress,
-    // Destination
-    dest: remoteChainId,
+  const destAmountHex = toHex3(amount - feesAmount);
+  const srcAmountHex = toHex3(amount);
+  const sourceObservation = new PayloadBuilder2({ schema: BridgeSourceObservationSchema2 }).fields({
+    dest: xl1ChainId,
     destAddress,
-    destAmount: srcAmount,
-    destToken: remoteTokenAddress,
-    nonce
+    destAmount: destAmountHex,
+    destToken: xl1TokenAddress,
+    src: evmChainId,
+    srcAddress: evmSrcAddress,
+    srcAmount: srcAmountHex,
+    srcConfirmation: evmTxHash,
+    srcToken: evmTokenAddress
+  }).build();
+  return buildTransaction(
+    xl1ChainId,
+    [transfer],
+    [intent, sourceObservation],
+    bridgeAccount,
+    nbf,
+    exp
+  );
+}
+
+// src/services/queue/workers/util/resolveEvmBlockTagAtDepth.ts
+async function resolveEvmBlockTagAtDepth(provider, depth, deployBlock) {
+  if (depth === "finalized") return "finalized";
+  if (depth === 0) return "latest";
+  const head = await provider.getBlockNumber();
+  return Math.max(head - depth, deployBlock);
+}
+
+// src/services/queue/workers/util/submitEthTransaction.ts
+import {
+  assertEx as assertEx6,
+  hexToBigInt as hexToBigInt2,
+  toEthAddress
+} from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk-js";
+import { isBridgeIntent } from "@xyo-network/xl1-sdk";
+var submitEthTransaction = async (tx, offChainPayloads, bridge, wallet) => {
+  const xl1Transaction = assertEx6(tx[0], () => "No corresponding XL1 transaction found");
+  const allPayloads = [...tx[1], ...offChainPayloads];
+  const bridgeIntent = assertEx6(allPayloads.find(isBridgeIntent), () => "No bridge intent found");
+  const srcAddress = toEthAddress(bridgeIntent.srcAddress);
+  const destAddress = toEthAddress(bridgeIntent.destAddress);
+  const amount = hexToBigInt2(bridgeIntent.destAmount);
+  const nonce = hexToBigInt2(await PayloadBuilder3.hash(xl1Transaction));
+  const bridgeTx = await bridge.connect(wallet).bridgeFromRemote(srcAddress, destAddress, amount, nonce);
+  const receipt = await bridgeTx.wait(1);
+  return receipt?.hash;
+};
+
+// src/services/queue/workers/util/submitXl1Transaction.ts
+var submitXl1Transaction = async (preparedTx, offChain = [], gateway) => {
+  const result = await gateway.addTransactionToChain(preparedTx, offChain);
+  return result;
+};
+
+// src/services/queue/workers/util/verifyEthBridgeEvent.ts
+import { asHex as asHex2, toAddress } from "@xylabs/sdk-js";
+import { ZeroAddress } from "ethers";
+async function verifyEthBridgeEvent(id, bridge, provider, confirmationDepth, deployBlock) {
+  const blockTag = await resolveEvmBlockTagAtDepth(provider, confirmationDepth, deployBlock);
+  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, deployBlock, blockTag);
+  const event = events[0];
+  if (event === void 0) {
+    return null;
+  }
+  return {
+    amount: data.amount,
+    destAddress: toAddress(data.destAddress),
+    destToken: toAddress(data.destToken),
+    evmTxHash: asHex2(event.transactionHash, true),
+    observedAt: Date.now(),
+    srcAddress: toAddress(data.srcAddress)
   };
-  const bridgeIntent = new PayloadBuilder4({
-    schema: BridgeIntentSchema2
-  }).fields(bridgeIntentFields).build();
-  const transfer = createBridgeTransfer(sender, srcAmount, escrowAddress, feesAddress, fees);
-  return [
-    bridgeIntent,
-    transfer
-  ];
-}, "generateBridgeEstimate");
+}
+
+// src/services/queue/workers/EthEventVerification.ts
+var name = "Verify ETH Bridge Event at Depth";
+var queueName = "eth-event-verify";
+var createWorker = (connection2, telemetry2, services) => {
+  const svc = assertEx7(services, () => "services not provided");
+  const {
+    account,
+    bridge,
+    bridgeFlowMetrics,
+    bridgeFulfillmentMap,
+    config,
+    evmBridgeDeployBlock,
+    logger,
+    provider,
+    remoteConfirmationDepth
+  } = svc;
+  const worker = new Worker(
+    queueName,
+    async (job) => {
+      await spanAsync4("bridge:worker:eth-event-verify", async () => {
+        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: [] };
+        await job.log(`[${identity}] verifying BridgedToRemote(${id}) at depth ${remoteConfirmationDepth}`);
+        const data = await verifyEthBridgeEvent(id, bridge, provider, remoteConfirmationDepth, evmBridgeDeployBlock);
+        if (isNull(data)) {
+          await job.log(`[${identity}] non-canonical at confirmation depth \u2014 orphaned by reorg or never reached canonical state`);
+          throw new UnrecoverableError(`[${identity}] bridgesToRemote slot empty at confirmation depth ${remoteConfirmationDepth}`);
+        }
+        state.canonical = data;
+        const { feeFixed, feeRateBasisPoints } = getFeeStructure(config);
+        const { feesAddress } = await getTransferAddresses(config);
+        const snapshot = buildAcceptedSnapshot({
+          amount: data.amount,
+          bridgeAccountAddress: account.address,
+          bridgeId: id,
+          destAddress: data.destAddress,
+          evmChainId: config.remoteChainId,
+          evmContractAddress: config.remoteBridgeContractAddress,
+          evmSrcAddress: data.srcAddress,
+          evmTokenAddress: data.destToken,
+          evmTxHash: data.evmTxHash,
+          feeFixed,
+          feeRateBasisPoints,
+          feesAddress,
+          xl1ChainId: getXl1ChainId(config),
+          xl1TokenAddress: getXl1TokenAddress(config)
+        });
+        state.acceptedIntent = snapshot.acceptedIntent;
+        state.acceptedFees = snapshot.acceptedFees;
+        state.acceptedSourceObservation = snapshot.acceptedSourceObservation;
+        await bridgeFulfillmentMap.set(identity, state);
+        await job.log(
+          `[${identity}] verified: src=${data.srcAddress} dest=${data.destAddress} amount=${data.amount} evmTxHash=${data.evmTxHash} snapshot: feeFixed=${snapshot.acceptedFees.feeFixed} feeVariable=${snapshot.acceptedFees.feeVariable}`
+        );
+      }, { logger, timeBudgetLimit: 5e3 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
+    }
+  );
+  worker.on("failed", (job, err) => {
+    logger.error(`[eth-verify] job ${job?.id} failed: ${err.message}`);
+    if (job === void 0) return;
+    const attemptsAllowed = job.opts.attempts ?? 1;
+    if (job.attemptsMade >= attemptsAllowed) {
+      bridgeFlowMetrics.recordTerminalFailure({ direction: "inbound", reason: bucketFailureReason(err.message) });
+    }
+  });
+  worker.on("error", (err) => {
+    logger.error(`[eth-verify] worker error: ${err.message}`);
+  });
+};
+var EthEventVerification = {
+  createWorker,
+  name,
+  queueName
+};
+
+// src/services/queue/workers/EthToXl1BridgeParent.ts
+import { assertEx as assertEx8, spanAsync as spanAsync5 } from "@xylabs/sdk-js";
+import { Worker as Worker2 } from "bullmq";
+var name2 = "Bridge Ethereum to XL1";
+var queueName2 = "eth-to-xl1-bridge";
+var createWorker2 = (connection2, telemetry2, services) => {
+  const logger = assertEx8(services?.logger, () => "logger service not provided");
+  const worker = new Worker2(
+    queueName2,
+    async (job) => {
+      return await spanAsync5("bridge:worker:eth-to-xl1-bridge", async () => {
+        await job.log(`[${job.name}] start`);
+        await job.log(`[${job.name}] done`);
+        return {};
+      }, { logger, timeBudgetLimit: 5e3 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
+    }
+  );
+  worker.on("failed", (job, err) => {
+    logger.error(`[eth-to-xl1-parent] job ${job?.id} failed: ${err.message}`);
+  });
+  worker.on("error", (err) => {
+    logger.error(`[eth-to-xl1-parent] worker error: ${err.message}`);
+  });
+};
+var EthToXl1BridgeParent = {
+  createWorker: createWorker2,
+  name: name2,
+  queueName: queueName2
+};
+
+// src/services/queue/workers/EthTransactionMonitor.ts
+import {
+  assertEx as assertEx9,
+  hexToBigInt as hexToBigInt3,
+  spanAsync as spanAsync6
+} from "@xylabs/sdk-js";
+import { calculateBridgeFees as calculateBridgeFees2 } from "@xyo-network/chain-bridge-shared";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
+import { isBridgeIntent as isBridgeIntent2 } from "@xyo-network/xl1-sdk";
+import { Worker as Worker3 } from "bullmq";
+var name3 = "Monitor Submitted ETH Transaction";
+var queueName3 = "eth-tx-monitor";
+var createWorker3 = (connection2, telemetry2, services) => {
+  const provider = assertEx9(services?.provider, () => "provider service not provided");
+  const stateMap = assertEx9(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const logger = assertEx9(services?.logger, () => "logger service not provided");
+  const config = assertEx9(services?.config, () => "config service not provided");
+  const bridgeFlowMetrics = assertEx9(services?.bridgeFlowMetrics, () => "bridgeFlowMetrics service not provided");
+  const worker = new Worker3(
+    queueName3,
+    async (job) => {
+      return await spanAsync6("bridge:worker:eth-tx-monitor", async () => {
+        const { tx } = job.data;
+        const hash = await PayloadBuilder4.hash(tx[0]);
+        const state = assertEx9(await stateMap.get(hash), () => "State not found");
+        const submissionHash = assertEx9(state?.submissionHash, () => "submissionHash not found");
+        const receipt = assertEx9(await provider.getTransactionReceipt(submissionHash), () => "Transaction receipt not found");
+        await job.log(`[${hash}] confirmed ETH tx ${submissionHash} in block ${receipt.blockNumber}`);
+        const { blockHash, blockNumber } = receipt;
+        state.confirmationHash = blockHash;
+        await stateMap.set(hash, state);
+        const bridgeIntent = tx[1].find(isBridgeIntent2);
+        const feeAmount = (() => {
+          if (bridgeIntent === void 0) return 0n;
+          const fees = calculateBridgeFees2(bridgeIntent.srcAmount, getFeeStructure(config));
+          return hexToBigInt3(fees.feeFixed) + hexToBigInt3(fees.feeVariable);
+        })();
+        const latencySeconds = (Date.now() - job.timestamp) / 1e3;
+        bridgeFlowMetrics.recordSuccess({
+          direction: "outbound",
+          feeAmount,
+          latencySeconds,
+          token: getXl1TokenAddress(config)
+        });
+        return {
+          blockHash,
+          blockNumber,
+          submissionHash
+        };
+      }, { logger, timeBudgetLimit: 2e3 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
+    }
+  );
+  worker.on("failed", (job, err) => {
+    logger.error(`[eth-monitor] job ${job?.id} failed: ${err.message}`);
+    if (job === void 0) return;
+    const attemptsAllowed = job.opts.attempts ?? 1;
+    if (job.attemptsMade < attemptsAllowed) {
+      bridgeFlowMetrics.recordAttemptExpiration({ direction: "outbound" });
+    } else {
+      bridgeFlowMetrics.recordTerminalFailure({ direction: "outbound", reason: bucketFailureReason(err.message) });
+    }
+  });
+  worker.on("error", (err) => {
+    logger.error(`[eth-monitor] worker error: ${err.message}`);
+  });
+};
+var EthTransactionMonitor = {
+  createWorker: createWorker3,
+  name: name3,
+  queueName: queueName3
+};
+
+// src/services/queue/workers/EthTransactionPreparation.ts
+import {
+  assertEx as assertEx15,
+  hexToBigInt as hexToBigInt9,
+  spanAsync as spanAsync7
+} from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/sdk-js";
+import { isBridgeIntent as isBridgeIntent5 } from "@xyo-network/xl1-sdk";
+import { Worker as Worker4 } from "bullmq";
+import { getAddress as getAddress2 } from "ethers";
+
+// src/services/validation/validateAmountMeetsMinBridgeAmount.ts
+import { hexToBigInt as hexToBigInt4 } from "@xylabs/sdk-js";
+function validateAmountMeetsMinBridgeAmount({
+  amount,
+  minBridgeAmount
+}) {
+  return amount >= hexToBigInt4(minBridgeAmount);
+}
+
+// src/services/validation/validateBridgeEstimateExact.ts
+import { hexToBigInt as hexToBigInt5, isUndefined } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
+
+// src/services/util/generateBridgeEstimate.ts
+import { generateBridgeEstimate as generateBridgeEstimateShared } from "@xyo-network/chain-bridge-shared";
+var generateBridgeEstimate = async (srcAddress, srcAmount, destAddress, config, nonceOverride) => {
+  const settings = await getBridgeSettings(config);
+  return generateBridgeEstimateShared(srcAddress, srcAmount, destAddress, settings, nonceOverride);
+};
 
 // src/services/validation/validateBridgeEstimateExact.ts
-var validateBridgeEstimateExact = /* @__PURE__ */ __name(async (intent, transfer, config) => {
-  const { srcAddress, srcAmount, destAddress } = intent;
+var validateBridgeEstimateExact = async (intent, transfer, config) => {
+  const {
+    srcAddress,
+    srcAmount,
+    destAddress
+  } = intent;
   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);
@@ -529,72 +944,65 @@ var validateBridgeEstimateExact = /* @__PURE__ */ __name(async (intent, transfer
   const { epoch: actualTransferEpoch, ...actualTransferStatic } = transfer;
   if (await PayloadBuilder5.dataHash(expectedTransferStatic) !== await PayloadBuilder5.dataHash(actualTransferStatic)) return false;
   return true;
-}, "validateBridgeEstimateExact");
+};
 
 // src/services/validation/validateBridgeTransaction.ts
 import { asAddress as asAddress4 } from "@xylabs/sdk-js";
-import { addressesContains, BoundWitnessValidator, payloadHashesContainsAll, payloadSchemasContainsAll } from "@xyo-network/boundwitness-validator";
+import {
+  addressesContains,
+  BoundWitnessValidator,
+  payloadHashesContainsAll,
+  payloadSchemasContainsAll
+} from "@xyo-network/boundwitness-validator";
 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) => {
+import { BridgeIntentSchema, TransferSchema } from "@xyo-network/xl1-sdk";
+var validateBridgeTransaction = 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, [
-    BridgeIntentSchema3,
-    TransferSchema
-  ])) return false;
-  const hashes = await PayloadBuilder6.hashes([
-    intent,
-    transfer
-  ]);
+  if (!payloadSchemasContainsAll(signedTxBw, [BridgeIntentSchema, TransferSchema])) return false;
+  const hashes = await PayloadBuilder6.hashes([intent, transfer]);
   if (!payloadHashesContainsAll(signedTxBw, hashes)) return false;
   const errors = await new BoundWitnessValidator(signedTxBw).validate();
   if (errors.length > 0) return false;
   const sender = asAddress4(srcAddress, true);
   if (!addressesContains(signedTxBw, sender)) return false;
   return true;
-}, "validateBridgeTransaction");
+};
 
 // 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 = assertEx9(allPayloads.find(isBridgeIntent2), () => "No bridge intent found");
+import { assertEx as assertEx10, hexToBigInt as hexToBigInt6 } from "@xylabs/sdk-js";
+import { isBridgeIntent as isBridgeIntent3 } from "@xyo-network/xl1-sdk";
+var validateSufficientLiquiditySourceAllowance = async (tx, offChainPayloads, bridgeableToken, bridge, logger) => {
+  const allPayloads = [...tx[1], ...offChainPayloads];
+  const bridgeIntent = assertEx10(allPayloads.find(isBridgeIntent3), () => "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);
   await logger?.log(`Remaining allowance: ${remainingAllowance.toString()}`);
   return remainingAllowance >= amount;
-}, "validateSufficientLiquiditySourceAllowance");
+};
 
 // 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 = assertEx10(allPayloads.find(isBridgeIntent3), () => "No bridge intent found");
+import { assertEx as assertEx11, hexToBigInt as hexToBigInt7 } from "@xylabs/sdk-js";
+import { isBridgeIntent as isBridgeIntent4 } from "@xyo-network/xl1-sdk";
+var validateSufficientLiquiditySourceBalance = async (tx, offChainPayloads, bridgeableToken, bridge, logger) => {
+  const allPayloads = [...tx[1], ...offChainPayloads];
+  const bridgeIntent = assertEx11(allPayloads.find(isBridgeIntent4), () => "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/services/validation/validateSufficientRunnerEthBalanceForGas.ts
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx12 } 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 = assertEx11(wallet.provider, () => "Wallet provider is not defined");
+var validateSufficientRunnerEthBalanceForGas = async (preparedTx, wallet, logger, bufferBps = DEFAULT_GAS_BUFFER_BPS) => {
+  const provider = assertEx12(wallet.provider, () => "Wallet provider is not defined");
   const feeData = await provider.getFeeData();
   const perGas = feeData.maxFeePerGas ?? feeData.gasPrice;
   if (perGas == null) {
@@ -610,91 +1018,112 @@ var validateSufficientRunnerEthBalanceForGas = /* @__PURE__ */ __name(async (pre
   const baseRequired = estGas * perGas + txValue;
   const required = baseRequired * (10000n + bufferBps) / 10000n;
   const balance = await provider.getBalance(await wallet.getAddress());
-  await logger?.log(`[gas] runner=${await wallet.getAddress()} balance=${balance.toString()} estGas=${estGas.toString()} perGas=${perGas.toString()} value=${txValue.toString()} requiredWithBuffer=${required.toString()} bufferBps=${bufferBps.toString()}`);
+  await logger?.log(
+    `[gas] runner=${await wallet.getAddress()} balance=${balance.toString()} estGas=${estGas.toString()} perGas=${perGas.toString()} value=${txValue.toString()} requiredWithBuffer=${required.toString()} bufferBps=${bufferBps.toString()}`
+  );
   return balance >= required;
-}, "validateSufficientRunnerEthBalanceForGas");
+};
 
 // src/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");
+import { assertEx as assertEx13 } from "@xylabs/sdk-js";
+import { AttoXL1ConvertFactor } from "@xyo-network/xl1-sdk";
+var RESERVE_FEE_BUFFER = 1n * AttoXL1ConvertFactor.xl1;
+async function validateSufficientXl1ReserveBalance({
+  amount,
+  bridgeAccount,
+  gateway,
+  logger
+}) {
+  const viewer = assertEx13(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;
+  const required = amount + RESERVE_FEE_BUFFER;
+  await logger?.log(
+    `XL1 reserve account ${bridgeAccount.address} balance: ${balance.toString()}; required: ${required.toString()} (amount=${amount.toString()} + buffer=${RESERVE_FEE_BUFFER.toString()})`
+  );
+  return balance >= required;
 }
-__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 = assertEx13(gateway.connection.viewer, () => "Gateway connection does not have a viewer");
-  const { srcAddress, srcAmount, destAddress } = bridgeIntent;
+import {
+  asAddress as asAddress5,
+  assertEx as assertEx14,
+  hexToBigInt as hexToBigInt8
+} from "@xylabs/sdk-js";
+var validateSufficientXL1SourceAddressBalance = async (bridgeIntent, gateway, config, logger) => {
+  const viewer = assertEx14(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 + 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/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 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)) {
-      throw new Error("Liquidity source does not have sufficient allowance for the bridge to execute the transaction");
-    }
-    await job.log(`[${hash}] validated liquiditySource has sufficient allowance`);
-    await job.log(`[${hash}] validating liquiditySource has sufficient balance`);
-    if (!await validateSufficientLiquiditySourceBalance(tx, offChainPayloads, bridgeableToken, bridge, job)) {
-      throw new Error("Liquidity source does not have sufficient balance for the bridge to execute the transaction");
-    }
-    await job.log(`[${hash}] validated liquiditySource has sufficient balance`);
-    await job.log(`[${hash}] building ETH transaction`);
-    const allPayloads = [
-      ...tx[1],
-      ...offChainPayloads
-    ];
-    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 = 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`);
-    if (!await validateSufficientRunnerEthBalanceForGas(preparedTx, wallet, job)) {
-      throw new Error("Transaction runner does not have sufficient ETH to cover estimated gas (with buffer)");
+var createWorker4 = (connection2, telemetry2, services) => {
+  const bridge = assertEx15(services?.bridge, () => "bridge service not provided");
+  const bridgeableToken = assertEx15(services?.bridgeableToken, () => "bridgeableToken service not provided");
+  const stateMap = assertEx15(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const wallet = assertEx15(services?.wallet, () => "wallet service not provided");
+  const logger = assertEx15(services?.logger, () => "logger service not provided");
+  const worker = new Worker4(
+    queueName4,
+    async (job) => {
+      return await spanAsync7("bridge:worker:eth-tx-prepare", async () => {
+        const { tx, offChainPayloads } = job.data;
+        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)) {
+          throw new Error("Liquidity source does not have sufficient allowance for the bridge to execute the transaction");
+        }
+        await job.log(`[${hash}] validated liquiditySource has sufficient allowance`);
+        await job.log(`[${hash}] validating liquiditySource has sufficient balance`);
+        if (!await validateSufficientLiquiditySourceBalance(tx, offChainPayloads, bridgeableToken, bridge, job)) {
+          throw new Error("Liquidity source does not have sufficient balance for the bridge to execute the transaction");
+        }
+        await job.log(`[${hash}] validated liquiditySource has sufficient balance`);
+        await job.log(`[${hash}] building ETH transaction`);
+        const allPayloads = [...tx[1], ...offChainPayloads];
+        const bridgeIntent = assertEx15(allPayloads.find(isBridgeIntent5), () => "No bridge intent found");
+        const amount = hexToBigInt9(bridgeIntent.destAmount);
+        const srcAddress = getAddress2(bridgeIntent.srcAddress);
+        const destAddress = getAddress2(bridgeIntent.destAddress);
+        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`);
+        if (!await validateSufficientRunnerEthBalanceForGas(preparedTx, wallet, job)) {
+          throw new Error("Transaction runner does not have sufficient ETH to cover estimated gas (with buffer)");
+        }
+        await job.log(`[${hash}] validated tx runner has sufficient ETH for gas`);
+        await job.log(`[${hash}] storing ETH preparedTx`);
+        await stateMap.set(hash, { preparedTx });
+        await job.log(`[${hash}] stored ETH preparedTx`);
+        await job.log(`[${hash}] prepared ETH transaction`);
+        return {};
+      }, { logger, timeBudgetLimit: 1e3 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    await job.log(`[${hash}] validated tx runner has sufficient ETH for gas`);
-    await job.log(`[${hash}] storing ETH preparedTx`);
-    await stateMap.set(hash, {
-      preparedTx
-    });
-    await job.log(`[${hash}] stored ETH preparedTx`);
-    await job.log(`[${hash}] prepared ETH transaction`);
-    return {};
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
-    console.error(`[${name4}] Job ${job?.id} failed:`, err.message);
+    logger.error(`[eth-prep] job ${job?.id} failed: ${err.message}`);
   });
   worker.on("error", (err) => {
-    console.error(`[${name4}] Worker error:`, err);
+    logger.error(`[eth-prep] worker error: ${err.message}`);
   });
-}, "createWorker");
+};
 var EthTransactionPreparation = {
   createWorker: createWorker4,
   name: name4,
@@ -702,45 +1131,52 @@ var EthTransactionPreparation = {
 };
 
 // src/services/queue/workers/EthTransactionSubmission.ts
-import { assertEx as assertEx15, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import {
+  assertEx as assertEx16,
+  isDefined as isDefined7,
+  spanAsync as spanAsync8
+} 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 PayloadBuilder8.hash(tx[0]);
-    const state = assertEx15(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined7(existingSubmissionHash)) {
-      await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
-      return {
-        submissionHash: existingSubmissionHash
-      };
+var createWorker5 = (connection2, telemetry2, services) => {
+  const bridge = assertEx16(services?.bridge, () => "bridge service not provided");
+  const wallet = assertEx16(services?.wallet, () => "wallet service not provided");
+  const stateMap = assertEx16(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const logger = assertEx16(services?.logger, () => "logger service not provided");
+  const worker = new Worker5(
+    queueName5,
+    async (job) => {
+      return await spanAsync8("bridge:worker:eth-tx-submit", async () => {
+        const { tx, offChainPayloads } = job.data;
+        const hash = await PayloadBuilder8.hash(tx[0]);
+        const state = assertEx16(await stateMap.get(hash), () => `[${hash}] state not found`);
+        const { submissionHash: existingSubmissionHash } = state;
+        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 = assertEx16(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 };
+      }, { logger, timeBudgetLimit: 5e3 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      concurrency: 1,
+      prefix
     }
-    await job.log(`[${hash}] Submitting ETH tx`);
-    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
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    concurrency: 1,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
-    console.error(`[${name5}] Job ${job?.id} failed:`, err.message);
+    logger.error(`[eth-submit] job ${job?.id} failed: ${err.message}`);
   });
   worker.on("error", (err) => {
-    console.error(`[${name5}] Worker error:`, err);
+    logger.error(`[eth-submit] worker error: ${err.message}`);
   });
-}, "createWorker");
+};
 var EthTransactionSubmission = {
   createWorker: createWorker5,
   name: name5,
@@ -748,48 +1184,55 @@ var EthTransactionSubmission = {
 };
 
 // src/services/queue/workers/EthTransactionSubmissionStorage.ts
-import { assertEx as assertEx16, isDefined as isDefined8 } from "@xylabs/sdk-js";
+import {
+  assertEx as assertEx17,
+  isDefined as isDefined8,
+  spanAsync as spanAsync9
+} 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 PayloadBuilder9.hash(tx[0]);
-    const state = assertEx16(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined8(existingSubmissionHash)) {
-      await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`);
-      return {
-        submissionHash: existingSubmissionHash
-      };
+var createWorker6 = (connection2, telemetry2, services) => {
+  const stateMap = assertEx17(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const logger = assertEx17(services?.logger, () => "logger service not provided");
+  const worker = new Worker6(
+    queueName6,
+    async (job) => {
+      return await spanAsync9("bridge:worker:eth-tx-store-submission", async () => {
+        const { tx } = job.data;
+        const hash = await PayloadBuilder9.hash(tx[0]);
+        const state = assertEx17(await stateMap.get(hash), () => `[${hash}] state not found`);
+        const { submissionHash: existingSubmissionHash } = state;
+        if (isDefined8(existingSubmissionHash)) {
+          await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`);
+          return { submissionHash: existingSubmissionHash };
+        }
+        const childrenValues = await job.getChildrenValues();
+        const jobKey = `${prefix}:${EthTransactionSubmission.queueName}:${hash}`;
+        const childValues = childrenValues?.[jobKey];
+        const submissionHash = childValues?.submissionHash;
+        const resolvedSubmissionHash = assertEx17(submissionHash, () => `[${hash}] child submissionHash not found in children values`);
+        await job.log(`[${hash}] Storing ETH submissionHash`);
+        state.submissionHash = resolvedSubmissionHash;
+        await stateMap.set(hash, state);
+        await job.log(`[${hash}] Stored ETH submissionHash`);
+        return { submissionHash: resolvedSubmissionHash };
+      }, { logger, timeBudgetLimit: 500 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    const childrenValues = await job.getChildrenValues();
-    const jobKey = `${prefix}:${EthTransactionSubmission.queueName}:${hash}`;
-    const childValues = childrenValues?.[jobKey];
-    const submissionHash = childValues?.submissionHash;
-    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);
-    await job.log(`[${hash}] Stored ETH submissionHash`);
-    return {
-      submissionHash: resolvedSubmissionHash
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
-    console.error(`[${name6}] Job ${job?.id} failed:`, err.message);
+    logger.error(`[eth-submit-store] job ${job?.id} failed: ${err.message}`);
   });
   worker.on("error", (err) => {
-    console.error(`[${name6}] Worker error:`, err);
+    logger.error(`[eth-submit-store] worker error: ${err.message}`);
   });
-}, "createWorker");
+};
 var EthTransactionSubmissionStorage = {
   createWorker: createWorker6,
   name: name6,
@@ -797,23 +1240,58 @@ var EthTransactionSubmissionStorage = {
 };
 
 // src/services/queue/workers/Xl1ReserveTxFulfillment.ts
-import { assertEx as assertEx17, delay, isDefined as isDefined9, isNull as isNull2 } from "@xylabs/sdk-js";
+import {
+  assertEx as assertEx18,
+  delay,
+  hexToBigInt as hexToBigInt10,
+  isDefined as isDefined9,
+  isNull as isNull2,
+  spanAsync as spanAsync10
+} 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";
+import { UnrecoverableError as UnrecoverableError2, 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 markFulfilled(ctx, attempt) {
+  const {
+    bridgeFlowMetrics,
+    fulfillmentMap,
+    identity,
+    state,
+    xl1TokenAddress
+  } = ctx;
+  state.fulfilled = attempt;
+  state.currentAttempt = void 0;
+  const intent = assertEx18(state.acceptedIntent, () => `[${identity}] acceptedIntent missing on fulfillment \u2014 Stage 1 did not snapshot`);
+  state.acceptedDestinationObservation = buildAcceptedDestinationObservation(intent, attempt.txHash);
+  await fulfillmentMap.set(identity, state);
+  const observedAt = state.canonical?.observedAt;
+  const latencySeconds = observedAt === void 0 ? void 0 : (attempt.submittedAt - observedAt) / 1e3;
+  const acceptedFees = state.acceptedFees;
+  const feeAmount = acceptedFees === void 0 ? 0n : hexToBigInt10(acceptedFees.feeFixed) + hexToBigInt10(acceptedFees.feeVariable);
+  bridgeFlowMetrics.recordSuccess({
+    direction: "inbound",
+    feeAmount,
+    latencySeconds,
+    token: xl1TokenAddress
+  });
+}
 async function tryResumeCurrentAttempt(ctx) {
-  const { fulfillmentMap, identity, job, state, viewer } = ctx;
-  const attempt = assertEx17(state.currentAttempt, () => "tryResumeCurrentAttempt called without currentAttempt");
+  const {
+    fulfillmentMap,
+    identity,
+    job,
+    state,
+    viewer
+  } = ctx;
+  const attempt = assertEx18(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 markFulfilled(ctx, attempt);
     await job.log(`[${identity}] tx ${attempt.txHash} included on resume`);
     return;
   }
@@ -825,19 +1303,35 @@ async function tryResumeCurrentAttempt(ctx) {
     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 {
+    account,
+    bridgeId,
+    config,
+    contractAddress,
+    evmChainId,
+    fulfillmentMap,
+    gateway,
+    identity,
+    job,
+    state,
+    viewer,
+    xl1ChainId,
+    xl1TokenAddress
+  } = ctx;
+  const canonical = assertEx18(state.canonical, () => `[${identity}] buildAndSubmitFreshAttempt requires canonical`);
+  const acceptedFees = assertEx18(state.acceptedFees, () => `[${identity}] acceptedFees missing \u2014 Stage 1 did not snapshot`);
+  const feesAmount = hexToBigInt10(acceptedFees.feeFixed) + hexToBigInt10(acceptedFees.feeVariable);
+  const { feesAddress } = await getTransferAddresses(config);
   const sufficient = await validateSufficientXl1ReserveBalance({
     amount: canonical.amount,
     bridgeAccount: account,
     gateway
   });
   if (!sufficient) {
-    const msg = `[${identity}] XL1 reserve below required ${canonical.amount.toString()}; will retry`;
+    const msg = `[${identity}] XL1 reserve below required ${canonical.amount.toString()}; terminal \u2014 refill and retry`;
     await job.log(msg);
-    throw new Error(msg);
+    throw new UnrecoverableError2(msg);
   }
   const head = await viewer.currentBlockNumber();
   const nbf = asXL1BlockNumber(head, true);
@@ -853,6 +1347,8 @@ async function buildAndSubmitFreshAttempt(ctx) {
     evmTokenAddress: canonical.destToken,
     evmTxHash: canonical.evmTxHash,
     exp,
+    feesAddress,
+    feesAmount,
     nbf,
     xl1ChainId,
     xl1TokenAddress
@@ -866,18 +1362,24 @@ async function buildAndSubmitFreshAttempt(ctx) {
   };
   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}`);
+  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");
+  const {
+    bridgeFlowMetrics,
+    fulfillmentMap,
+    identity,
+    job,
+    state,
+    viewer
+  } = ctx;
+  const attempt = assertEx18(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 markFulfilled(ctx, attempt);
       await job.log(`[${identity}] tx ${attempt.txHash} included`);
       return;
     }
@@ -886,6 +1388,7 @@ async function pollUntilIncludedOrExpired(ctx) {
       state.previousAttempts.push(attempt);
       state.currentAttempt = void 0;
       await fulfillmentMap.set(identity, state);
+      bridgeFlowMetrics.recordAttemptExpiration({ direction: "inbound" });
       const msg = `[${identity}] attempt ${state.previousAttempts.length} expired (head=${head}, exp=${attempt.exp})`;
       await job.log(msg);
       throw new Error(msg);
@@ -893,72 +1396,89 @@ async function pollUntilIncludedOrExpired(ctx) {
     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;
+var createWorker7 = (connection2, telemetry2, services) => {
+  const svc = assertEx18(services, () => "services not provided");
+  const {
+    account,
+    bridgeFlowMetrics,
+    bridgeFulfillmentMap,
+    config,
+    gateway,
+    logger
+  } = svc;
+  const worker = new Worker7(
+    queueName7,
+    async (job) => {
+      await spanAsync10("bridge:worker:eth-to-xl1-fulfill", async () => {
+        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 = assertEx18(initialState, () => `[${identity}] no fulfillment state \u2014 Stage 1 did not run`);
+        const canonical = assertEx18(state.canonical, () => `[${identity}] canonical missing \u2014 Stage 1 did not write canonical`);
+        const minBridgeAmount = getMinBridgeAmount(config);
+        if (!validateAmountMeetsMinBridgeAmount({ amount: canonical.amount, minBridgeAmount })) {
+          await job.log(`[${identity}] amount ${canonical.amount} below minBridgeAmount ${minBridgeAmount}; terminal`);
+          throw new UnrecoverableError2(`[${identity}] below_min_bridge_amount: amount=${canonical.amount} minBridgeAmount=${minBridgeAmount}`);
+        }
+        const viewer = assertEx18(gateway.connection.viewer, () => `[${identity}] gateway viewer not available`);
+        const ctx = {
+          bridgeFlowMetrics,
+          fulfillmentMap: bridgeFulfillmentMap,
+          identity,
+          job,
+          state,
+          viewer,
+          xl1TokenAddress
+        };
+        if (state.currentAttempt) {
+          await tryResumeCurrentAttempt(ctx);
+          if (state.fulfilled) return;
+        }
+        if (!state.currentAttempt) {
+          await buildAndSubmitFreshAttempt({
+            ...ctx,
+            account,
+            bridgeId: BigInt(bridgeId),
+            config,
+            contractAddress,
+            evmChainId,
+            gateway,
+            xl1ChainId,
+            xl1TokenAddress
+          });
+        }
+        await pollUntilIncludedOrExpired(ctx);
+      }, { logger });
+    },
+    {
+      concurrency: CONCURRENCY,
+      connection: connection2,
+      prefix,
+      telemetry: telemetry2
     }
-    if (!state.currentAttempt) {
-      await buildAndSubmitFreshAttempt({
-        ...ctx,
-        account,
-        bridgeId: BigInt(bridgeId),
-        contractAddress,
-        evmChainId,
-        gateway,
-        xl1ChainId,
-        xl1TokenAddress
-      });
+  );
+  worker.on("failed", (job, err) => {
+    logger.error(`[xl1-fulfill] job ${job?.id} failed: ${err.message}`);
+    if (job === void 0) return;
+    const attemptsAllowed = job.opts.attempts ?? 1;
+    if (job.attemptsMade >= attemptsAllowed) {
+      bridgeFlowMetrics.recordTerminalFailure({ direction: "inbound", reason: bucketFailureReason(err.message) });
     }
-    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);
+    logger.error(`[xl1-fulfill] worker error: ${err.message}`);
   });
-}, "createWorker");
+};
 var Xl1ReserveTxFulfillment = {
   createWorker: createWorker7,
   name: name7,
@@ -966,26 +1486,34 @@ var Xl1ReserveTxFulfillment = {
 };
 
 // src/services/queue/workers/Xl1ToEthBridgeParent.ts
+import { assertEx as assertEx19, spanAsync as spanAsync11 } from "@xylabs/sdk-js";
 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 {};
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+var createWorker8 = (connection2, telemetry2, services) => {
+  const logger = assertEx19(services?.logger, () => "logger service not provided");
+  const worker = new Worker8(
+    queueName8,
+    async (job) => {
+      return await spanAsync11("bridge:worker:xl1-to-eth-bridge", async () => {
+        await job.log(`[${job.name}] start`);
+        await job.log(`[${job.name}] done`);
+        return {};
+      }, { logger, timeBudgetLimit: 5e3 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
+    }
+  );
   worker.on("failed", (job, err) => {
-    console.error(`[${name8}] Job ${job?.id} failed:`, err.message);
+    logger.error(`[xl1-to-eth-parent] job ${job?.id} failed: ${err.message}`);
   });
   worker.on("error", (err) => {
-    console.error(`[${name8}] Worker error:`, err);
+    logger.error(`[xl1-to-eth-parent] worker error: ${err.message}`);
   });
-}, "createWorker");
+};
 var Xl1ToEthBridgeParent = {
   createWorker: createWorker8,
   name: name8,
@@ -993,48 +1521,60 @@ var Xl1ToEthBridgeParent = {
 };
 
 // src/services/queue/workers/Xl1TransactionMonitor.ts
-import { assertEx as assertEx18, isDefined as isDefined10, isNull as isNull3 } from "@xylabs/sdk-js";
+import {
+  assertEx as assertEx20,
+  isDefined as isDefined10,
+  isNull as isNull3,
+  spanAsync as spanAsync12
+} from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
-import { UnrecoverableError as UnrecoverableError2, Worker as Worker9 } from "bullmq";
+import { UnrecoverableError as UnrecoverableError3, 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 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 (isDefined10(foundTx) && !isNull3(foundTx)) {
-      await job.log(`[${hash}] Found transaction on chain`);
-      const submissionHash2 = await PayloadBuilder11.hash(foundTx[0]);
-      return {
-        submissionHash: submissionHash2
-      };
-    }
-    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 UnrecoverableError2(`[${hash}] Transaction expired and will never be included`);
+var createWorker9 = (connection2, telemetry2, services) => {
+  const gateway = assertEx20(services?.gateway, () => "gateway service not provided");
+  const stateMap = assertEx20(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const viewer = assertEx20(gateway.connection.viewer, () => "viewer not defined on gateway");
+  const logger = assertEx20(services?.logger, () => "logger service not provided");
+  const worker = new Worker9(
+    queueName9,
+    async (job) => {
+      return await spanAsync12("bridge:worker:xl1-tx-monitor", async () => {
+        const { tx } = job.data;
+        const hash = await PayloadBuilder11.hash(tx[0]);
+        const state = assertEx20(await stateMap.get(hash), () => `[${hash}] state not found`);
+        const submissionHash = assertEx20(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 (isDefined10(foundTx) && !isNull3(foundTx)) {
+          await job.log(`[${hash}] Found transaction on chain`);
+          const submissionHash2 = await PayloadBuilder11.hash(foundTx[0]);
+          return { submissionHash: submissionHash2 };
+        }
+        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 UnrecoverableError3(`[${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`);
+      }, { logger, timeBudgetLimit: 2e3 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    await job.log(`[${hash}] Transaction not yet included, retrying later`);
-    throw new Error(`[${hash}] Transaction not yet included`);
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
-    console.error(`[${name9}] Job ${job?.id} failed:`, err.message);
+    logger.error(`[xl1-monitor] job ${job?.id} failed: ${err.message}`);
   });
   worker.on("error", (err) => {
-    console.error(`[${name9}] Worker error:`, err);
+    logger.error(`[xl1-monitor] worker error: ${err.message}`);
   });
-}, "createWorker");
+};
 var Xl1TransactionMonitor = {
   createWorker: createWorker9,
   name: name9,
@@ -1042,40 +1582,42 @@ var Xl1TransactionMonitor = {
 };
 
 // src/services/queue/workers/Xl1TransactionPreparation.ts
-import { assertEx as assertEx19 } from "@xylabs/sdk-js";
+import { assertEx as assertEx21, spanAsync as spanAsync13 } 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 PayloadBuilder12.hash(tx[0]);
-    await job.log(`[${hash}] preparing XL1 transaction`);
-    const preparedTx = tx;
-    await job.log(`[${hash}] storing XL1 preparedTx`);
-    await stateMap.set(hash, {
-      offChainPayloads,
-      preparedTx
-    });
-    await job.log(`[${hash}] stored XL1 preparedTx`);
-    await job.log(`[${hash}] prepared XL1 transaction`);
-    return {
-      preparedTx
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+var createWorker10 = (connection2, telemetry2, services) => {
+  const stateMap = assertEx21(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const logger = assertEx21(services?.logger, () => "logger service not provided");
+  const worker = new Worker10(
+    queueName10,
+    async (job) => {
+      return await spanAsync13("bridge:worker:xl1-tx-prepare", async () => {
+        const { tx, offChainPayloads = [] } = job.data;
+        const hash = await PayloadBuilder12.hash(tx[0]);
+        await job.log(`[${hash}] preparing XL1 transaction`);
+        const preparedTx = tx;
+        await job.log(`[${hash}] storing XL1 preparedTx`);
+        await stateMap.set(hash, { offChainPayloads, preparedTx });
+        await job.log(`[${hash}] stored XL1 preparedTx`);
+        await job.log(`[${hash}] prepared XL1 transaction`);
+        return { preparedTx };
+      }, { logger, timeBudgetLimit: 1e3 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
+    }
+  );
   worker.on("failed", (job, err) => {
-    console.error(`[${name10}] Job ${job?.id} failed:`, err.message);
+    logger.error(`[xl1-prep] job ${job?.id} failed: ${err.message}`);
   });
   worker.on("error", (err) => {
-    console.error(`[${name10}] Worker error:`, err);
+    logger.error(`[xl1-prep] worker error: ${err.message}`);
   });
-}, "createWorker");
+};
 var Xl1TransactionPreparation = {
   createWorker: createWorker10,
   name: name10,
@@ -1083,44 +1625,55 @@ var Xl1TransactionPreparation = {
 };
 
 // src/services/queue/workers/Xl1TransactionSubmission.ts
-import { assertEx as assertEx20, isDefined as isDefined11 } from "@xylabs/sdk-js";
+import {
+  assertEx as assertEx22,
+  isDefined as isDefined11,
+  spanAsync as spanAsync14
+} 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 PayloadBuilder13.hash(tx[0]);
-    const state = assertEx20(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const { preparedTx, offChainPayloads = [], submissionHash: existingSubmissionHash } = state;
-    if (isDefined11(existingSubmissionHash)) {
-      await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
-      return {
-        submissionHash: existingSubmissionHash
-      };
+var createWorker11 = (connection2, telemetry2, services) => {
+  const gateway = assertEx22(services?.gateway, () => "gateway service not provided");
+  const stateMap = assertEx22(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const logger = assertEx22(services?.logger, () => "logger service not provided");
+  const worker = new Worker11(
+    queueName11,
+    async (job) => {
+      return await spanAsync14("bridge:worker:xl1-tx-submit", async () => {
+        const { tx } = job.data;
+        const hash = await PayloadBuilder13.hash(tx[0]);
+        const state = assertEx22(await stateMap.get(hash), () => `[${hash}] state not found`);
+        const {
+          preparedTx,
+          offChainPayloads = [],
+          submissionHash: existingSubmissionHash
+        } = state;
+        if (isDefined11(existingSubmissionHash)) {
+          await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
+          return { submissionHash: existingSubmissionHash };
+        }
+        const txToSubmit = assertEx22(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`);
+        return { submissionHash };
+      }, { logger, timeBudgetLimit: 5e3 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    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`);
-    return {
-      submissionHash
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
-    console.error(`[${name11}] Job ${job?.id} failed:`, err.message);
+    logger.error(`[xl1-submit] job ${job?.id} failed: ${err.message}`);
   });
   worker.on("error", (err) => {
-    console.error(`[${name11}] Worker error:`, err);
+    logger.error(`[xl1-submit] worker error: ${err.message}`);
   });
-}, "createWorker");
+};
 var Xl1TransactionSubmission = {
   createWorker: createWorker11,
   name: name11,
@@ -1128,48 +1681,55 @@ var Xl1TransactionSubmission = {
 };
 
 // src/services/queue/workers/Xl1TransactionSubmissionStorage.ts
-import { assertEx as assertEx21, isDefined as isDefined12 } from "@xylabs/sdk-js";
+import {
+  assertEx as assertEx23,
+  isDefined as isDefined12,
+  spanAsync as spanAsync15
+} 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 PayloadBuilder14.hash(tx[0]);
-    const state = assertEx21(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined12(existingSubmissionHash)) {
-      await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`);
-      return {
-        submissionHash: existingSubmissionHash
-      };
+var createWorker12 = (connection2, telemetry2, services) => {
+  const stateMap = assertEx23(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  const logger = assertEx23(services?.logger, () => "logger service not provided");
+  const worker = new Worker12(
+    queueName12,
+    async (job) => {
+      return await spanAsync15("bridge:worker:xl1-tx-store-submission", async () => {
+        const { tx } = job.data;
+        const hash = await PayloadBuilder14.hash(tx[0]);
+        const state = assertEx23(await stateMap.get(hash), () => `[${hash}] state not found`);
+        const { submissionHash: existingSubmissionHash } = state;
+        if (isDefined12(existingSubmissionHash)) {
+          await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`);
+          return { submissionHash: existingSubmissionHash };
+        }
+        const childrenValues = await job.getChildrenValues();
+        const jobKey = `${prefix}:${Xl1TransactionSubmission.queueName}:${hash}`;
+        const childValues = childrenValues?.[jobKey];
+        const submissionHash = childValues?.submissionHash;
+        const resolvedSubmissionHash = assertEx23(submissionHash, () => `[${hash}] child submissionHash not found in children values`);
+        await job.log(`[${hash}] Storing XL1 submissionHash`);
+        state.submissionHash = resolvedSubmissionHash;
+        await stateMap.set(hash, state);
+        await job.log(`[${hash}] Stored XL1 submissionHash`);
+        return { submissionHash: resolvedSubmissionHash };
+      }, { logger, timeBudgetLimit: 500 });
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    const childrenValues = await job.getChildrenValues();
-    const jobKey = `${prefix}:${Xl1TransactionSubmission.queueName}:${hash}`;
-    const childValues = childrenValues?.[jobKey];
-    const submissionHash = childValues?.submissionHash;
-    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);
-    await job.log(`[${hash}] Stored XL1 submissionHash`);
-    return {
-      submissionHash: resolvedSubmissionHash
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
-    console.error(`[${name12}] Job ${job?.id} failed:`, err.message);
+    logger.error(`[xl1-submit-store] job ${job?.id} failed: ${err.message}`);
   });
   worker.on("error", (err) => {
-    console.error(`[${name12}] Worker error:`, err);
+    logger.error(`[xl1-submit-store] worker error: ${err.message}`);
   });
-}, "createWorker");
+};
 var Xl1TransactionSubmissionStorage = {
   createWorker: createWorker12,
   name: name12,
@@ -1177,26 +1737,26 @@ var Xl1TransactionSubmissionStorage = {
 };
 
 // src/services/queue/workers/createWorkers.ts
-var createWorkers = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+var createWorkers = (connection2, telemetry2, services) => {
   EthEventVerification.createWorker(connection2, telemetry2, services);
-  EthToXl1BridgeParent.createWorker(connection2, telemetry2);
+  EthToXl1BridgeParent.createWorker(connection2, telemetry2, services);
   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);
+  Xl1ToEthBridgeParent.createWorker(connection2, telemetry2, services);
   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
+import { buildBridgeIdentity } from "@xyo-network/chain-bridge-shared";
 function getJobIdForEthToXl1BridgeJob(context) {
-  return `evm:${context.evmChainId.toLowerCase()}:${context.contractAddress.toLowerCase()}:${context.bridgeId.toString()}`;
+  return buildBridgeIdentity(context);
 }
-__name(getJobIdForEthToXl1BridgeJob, "getJobIdForEthToXl1BridgeJob");
 
 // src/services/queue/flows/createEthToXl1BridgeJob/createEthToXl1BridgeJob.ts
 var STAGE_2_RETRY = {
@@ -1206,10 +1766,8 @@ var STAGE_2_RETRY = {
     type: "fixed"
   }
 };
-var STAGE_1_RETRY = {
-  attempts: 1
-};
-var createEthToXl1BridgeJob = /* @__PURE__ */ __name(async (flowProducer2, context) => {
+var STAGE_1_RETRY = { attempts: 1 };
+var createEthToXl1BridgeJob = async (flowProducer2, context) => {
   const jobId = getJobIdForEthToXl1BridgeJob(context);
   const identity = jobId;
   const stageJobData = {
@@ -1224,175 +1782,121 @@ var createEthToXl1BridgeJob = /* @__PURE__ */ __name(async (flowProducer2, conte
     name: EthToXl1BridgeParent.name,
     queueName: EthToXl1BridgeParent.queueName,
     data: stageJobData,
-    opts: {
-      jobId
-    },
+    opts: { jobId },
     children: [
       {
         name: Xl1ReserveTxFulfillment.name,
         queueName: Xl1ReserveTxFulfillment.queueName,
         data: stageJobData,
-        opts: {
-          jobId,
-          ...STAGE_2_RETRY
-        },
+        opts: { jobId, ...STAGE_2_RETRY },
         children: [
           {
             name: EthEventVerification.name,
             queueName: EthEventVerification.queueName,
             data: stageJobData,
-            opts: {
-              jobId,
-              ...STAGE_1_RETRY
-            }
+            opts: { jobId, ...STAGE_1_RETRY }
           }
         ]
       }
     ]
   });
-}, "createEthToXl1BridgeJob");
+};
 
 // src/services/queue/flows/createXl1ToEthBridgeJob/getJobIdForXl1ToEthBridgeJob.ts
 import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/sdk-js";
-var getJobIdForXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (tx) => {
+var getJobIdForXl1ToEthBridgeJob = async (tx) => {
   const jobId = await PayloadBuilder15.hash(tx[0]);
   return jobId;
-}, "getJobIdForXl1ToEthBridgeJob");
+};
 
 // src/services/queue/flows/createXl1ToEthBridgeJob/createXl1ToEthBridgeJob.ts
-var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx, offChainPayloads = []) => {
+var createXl1ToEthBridgeJob = async (flowProducer2, tx, offChainPayloads = []) => {
   const jobId = await getJobIdForXl1ToEthBridgeJob(tx);
   const flow = await flowProducer2.add({
     // Step 0 (runs first as parent job)
     name: Xl1ToEthBridgeParent.name,
     queueName: Xl1ToEthBridgeParent.queueName,
-    data: {
-      tx,
-      offChainPayloads
-    },
-    opts: {
-      jobId
-    },
+    data: { tx, offChainPayloads },
+    opts: { jobId },
     children: [
       {
         // Step 8
         name: EthTransactionMonitor.name,
         queueName: EthTransactionMonitor.queueName,
-        data: {
-          tx
-        },
+        data: { tx },
         opts: {
           jobId,
           attempts: 60,
-          backoff: {
-            type: "fixed",
-            delay: 5e3
-          }
+          backoff: { type: "fixed", delay: 5e3 }
         },
         children: [
           {
             // Step 7
             name: EthTransactionSubmissionStorage.name,
             queueName: EthTransactionSubmissionStorage.queueName,
-            data: {
-              tx
-            },
+            data: { tx },
             opts: {
               jobId,
               attempts: 60,
-              backoff: {
-                type: "fixed",
-                delay: 5e3
-              }
+              backoff: { type: "fixed", delay: 5e3 }
             },
             children: [
               {
                 // Step 6
                 name: EthTransactionSubmission.name,
                 queueName: EthTransactionSubmission.queueName,
-                data: {
-                  tx,
-                  offChainPayloads
-                },
-                opts: {
-                  jobId
-                },
+                data: { tx, offChainPayloads },
+                opts: { jobId },
                 children: [
                   {
                     // Step 5
                     name: EthTransactionPreparation.name,
                     queueName: EthTransactionPreparation.queueName,
-                    data: {
-                      tx,
-                      offChainPayloads
-                    },
+                    data: { tx, offChainPayloads },
                     opts: {
                       jobId,
                       attempts: 60,
-                      backoff: {
-                        type: "fixed",
-                        delay: 5e3
-                      }
+                      backoff: { type: "fixed", delay: 5e3 }
                     },
                     children: [
                       {
                         // Step 4
                         name: Xl1TransactionMonitor.name,
                         queueName: Xl1TransactionMonitor.queueName,
-                        data: {
-                          tx
-                        },
+                        data: { tx },
                         opts: {
                           jobId,
                           attempts: 60,
-                          backoff: {
-                            type: "fixed",
-                            delay: 5e3
-                          }
+                          backoff: { type: "fixed", delay: 5e3 }
                         },
                         children: [
                           {
                             // Step 3
                             name: Xl1TransactionSubmissionStorage.name,
                             queueName: Xl1TransactionSubmissionStorage.queueName,
-                            data: {
-                              tx
-                            },
+                            data: { tx },
                             opts: {
                               jobId,
                               attempts: 60,
-                              backoff: {
-                                type: "fixed",
-                                delay: 5e3
-                              }
+                              backoff: { type: "fixed", delay: 5e3 }
                             },
                             children: [
                               {
                                 // Step 2
                                 name: Xl1TransactionSubmission.name,
                                 queueName: Xl1TransactionSubmission.queueName,
-                                data: {
-                                  tx
-                                },
-                                opts: {
-                                  jobId
-                                },
+                                data: { tx },
+                                opts: { jobId },
                                 children: [
                                   {
                                     // Step 1 (runs first as deepest child)
                                     name: Xl1TransactionPreparation.name,
                                     queueName: Xl1TransactionPreparation.queueName,
-                                    data: {
-                                      tx,
-                                      offChainPayloads
-                                    },
+                                    data: { tx, offChainPayloads },
                                     opts: {
                                       jobId,
                                       attempts: 60,
-                                      backoff: {
-                                        type: "fixed",
-                                        delay: 5e3
-                                      }
+                                      backoff: { type: "fixed", delay: 5e3 }
                                     }
                                   }
                                 ]
@@ -1412,44 +1916,41 @@ var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx, o
     ]
   });
   return flow;
-}, "createXl1ToEthBridgeJob");
+};
 
 // src/services/queue/flows/createXl1ToEthBridgeJob/getXl1ToEthBridgeJob.ts
-var getXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) => {
+var getXl1ToEthBridgeJob = async (flowProducer2, tx) => {
   const id = await getJobIdForXl1ToEthBridgeJob(tx);
-  const flow = await flowProducer2.getFlow({
-    queueName: Xl1ToEthBridgeParent.queueName,
-    id
-  });
+  const flow = await flowProducer2.getFlow({ queueName: Xl1ToEthBridgeParent.queueName, id });
   return flow;
-}, "getXl1ToEthBridgeJob");
+};
 
 // src/services/queue/getEthToXl1Queues.ts
 import { Queue } from "bullmq";
 var ethToXl1Queues;
-var getEthToXl1Queues = /* @__PURE__ */ __name((config) => {
+var getEthToXl1Queues = (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
-    })
+    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([
+var getStatusQueueJobs = async (queues, jobId) => {
+  const [
+    ethTransactionMonitorJob,
+    ethTransactionPreparationJob,
+    ethTransactionSubmissionJob,
+    xl1ToEthBridgeParentJob,
+    xl1TransactionMonitorJob,
+    xl1TransactionPreparationJob,
+    xl1TransactionSubmissionJob,
+    xl1TransactionSubmissionStorageJob
+  ] = await Promise.all([
     queues.ethTransactionMonitor.getJob(jobId),
     queues.ethTransactionPreparation.getJob(jobId),
     queues.ethTransactionSubmission.getJob(jobId),
@@ -1469,54 +1970,137 @@ var getStatusQueueJobs = /* @__PURE__ */ __name(async (queues, jobId) => {
     xl1TransactionSubmissionStorageJob,
     xl1TransactionSubmissionJob
   };
-}, "getStatusQueueJobs");
+};
 
 // src/services/queue/getXl1ToEthQueues.ts
 import { Queue as Queue2 } from "bullmq";
 var xl1ToEthQueues;
-var getXl1ToEthQueues = /* @__PURE__ */ __name((config) => {
+var getXl1ToEthQueues = (config) => {
   if (xl1ToEthQueues) return xl1ToEthQueues;
   const connection2 = getConnection(config);
   xl1ToEthQueues = {
-    ethTransactionMonitor: new Queue2(EthTransactionMonitor.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    ethTransactionPreparation: new Queue2(EthTransactionPreparation.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    ethTransactionSubmission: new Queue2(EthTransactionSubmission.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1ToEthBridgeParent: new Queue2(Xl1ToEthBridgeParent.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1TransactionMonitor: new Queue2(Xl1TransactionMonitor.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1TransactionPreparation: new Queue2(Xl1TransactionPreparation.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1TransactionSubmission: new Queue2(Xl1TransactionSubmission.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1TransactionSubmissionStorage: new Queue2(Xl1TransactionSubmissionStorage.queueName, {
-      connection: connection2,
-      prefix
-    })
+    ethTransactionMonitor: new Queue2(EthTransactionMonitor.queueName, { connection: connection2, prefix }),
+    ethTransactionPreparation: new Queue2(EthTransactionPreparation.queueName, { connection: connection2, prefix }),
+    ethTransactionSubmission: new Queue2(EthTransactionSubmission.queueName, { connection: connection2, prefix }),
+    xl1ToEthBridgeParent: new Queue2(Xl1ToEthBridgeParent.queueName, { connection: connection2, prefix }),
+    xl1TransactionMonitor: new Queue2(Xl1TransactionMonitor.queueName, { connection: connection2, prefix }),
+    xl1TransactionPreparation: new Queue2(Xl1TransactionPreparation.queueName, { connection: connection2, prefix }),
+    xl1TransactionSubmission: new Queue2(Xl1TransactionSubmission.queueName, { connection: connection2, prefix }),
+    xl1TransactionSubmissionStorage: new Queue2(Xl1TransactionSubmissionStorage.queueName, { connection: connection2, prefix })
   };
   return xl1ToEthQueues;
-}, "getXl1ToEthQueues");
+};
+
+// src/services/queue/retryFailedJobs.ts
+var DEFAULT_LIMIT = 100;
+function hasAnyFilter(filters) {
+  return filters.bridgeIds !== void 0 && filters.bridgeIds.length > 0 || filters.since !== void 0 || filters.until !== void 0 || filters.reasonContains !== void 0 || filters.srcAddress !== void 0;
+}
+var AVAILABLE_BULK_FILTERS = [
+  "bridgeIds",
+  "since",
+  "until",
+  "reasonContains",
+  "srcAddress"
+];
+async function isFilterMatch(job, id, filters, srcAddressLookup) {
+  const {
+    bridgeIds,
+    reasonContains,
+    since,
+    srcAddress,
+    until
+  } = filters;
+  if (bridgeIds !== void 0 && !bridgeIds.includes(id)) return false;
+  if (since !== void 0 || until !== void 0) {
+    const finishedOn = job.finishedOn;
+    if (finishedOn === void 0) return false;
+    if (since !== void 0 && finishedOn < since) return false;
+    if (until !== void 0 && finishedOn > until) return false;
+  }
+  if (reasonContains !== void 0 && !(job.failedReason ?? "").includes(reasonContains)) {
+    return false;
+  }
+  if (srcAddress !== void 0) {
+    if (srcAddressLookup === void 0) return false;
+    const found = await srcAddressLookup(id);
+    if (found === void 0 || found.toLowerCase() !== srcAddress.toLowerCase()) return false;
+  }
+  return true;
+}
+async function retryFailedJobs(opts) {
+  const {
+    filters,
+    queue,
+    srcAddressLookup
+  } = opts;
+  const { dryRun = false, limit = DEFAULT_LIMIT } = filters;
+  const failedJobs = await queue.getFailed(0, Math.max(limit - 1, 0));
+  const retried = [];
+  const skipped = [];
+  for (const job of failedJobs) {
+    const id = job.id;
+    if (id === void 0) continue;
+    const matches = await isFilterMatch(job, id, filters, srcAddressLookup);
+    if (!matches) {
+      skipped.push({ id, reason: "filter-mismatch" });
+      continue;
+    }
+    const state = await job.getState();
+    if (state !== "failed") {
+      skipped.push({ id, reason: "not-in-failed-state" });
+      continue;
+    }
+    if (!dryRun) await job.retry();
+    retried.push({ failedReason: job.failedReason, id });
+  }
+  const total = retried.length + skipped.length;
+  return {
+    counts: {
+      retried: retried.length,
+      skipped: skipped.length,
+      total
+    },
+    retried,
+    skipped
+  };
+}
+
+// src/services/queue/retrySingleFailedJob.ts
+async function retrySingleFailedJob(opts) {
+  const {
+    dryRun = false,
+    jobId,
+    queue
+  } = opts;
+  const job = await queue.getJob(jobId);
+  if (job === void 0) {
+    return { bridgeId: jobId, status: "not-found" };
+  }
+  const state = await job.getState();
+  if (state !== "failed") {
+    return { bridgeId: jobId, status: "not-in-failed-state" };
+  }
+  const failedReason = job.failedReason;
+  if (!dryRun) {
+    await job.retry();
+  }
+  return {
+    bridgeId: jobId,
+    failedReason,
+    status: "retried"
+  };
+}
 
 // src/services/queue/scanner/createEnqueueEthToXl1Bridge.ts
 function createEnqueueEthToXl1Bridge(options2) {
-  const { evmChainId, evmContractAddress, flowProducer: flowProducer2, xl1ChainId, xl1TokenAddress } = options2;
+  const {
+    evmChainId,
+    evmContractAddress,
+    flowProducer: flowProducer2,
+    xl1ChainId,
+    xl1TokenAddress
+  } = options2;
   return async (bridgeId, jobLog) => {
     await createEthToXl1BridgeJob(flowProducer2, {
       bridgeId,
@@ -1528,7 +2112,6 @@ function createEnqueueEthToXl1Bridge(options2) {
     await jobLog?.(`[bridge-scanner] bridgeId ${bridgeId} enqueued`);
   };
 }
-__name(createEnqueueEthToXl1Bridge, "createEnqueueEthToXl1Bridge");
 
 // src/services/queue/scanner/EvmBridgeScanner.ts
 import { isUndefined as isUndefined2 } from "@xylabs/sdk-js";
@@ -1537,22 +2120,33 @@ import { isUndefined as isUndefined2 } from "@xylabs/sdk-js";
 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 {
+    bridge,
+    bridgeAddress,
+    chainId,
+    confirmationDepth,
+    cursors,
+    deployBlock,
+    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 blockTag = await resolveEvmBlockTagAtDepth(provider, confirmationDepth, deployBlock);
+      const confirmedHigh = await bridge.nextBridgeToId({ blockTag });
       const cursor = await cursors.get(cursorKey);
       const lastProcessedId = isUndefined2(cursor) ? 0n : BigInt(cursor.lastProcessedId);
+      const priorProcessedBlock = isUndefined2(cursor?.lastProcessedBlock) ? deployBlock : Number(cursor.lastProcessedBlock);
+      const nextProcessedBlock = typeof blockTag === "number" ? Math.max(priorProcessedBlock, blockTag) : priorProcessedBlock;
       if (confirmedHigh <= lastProcessedId) {
+        if (nextProcessedBlock !== priorProcessedBlock || isUndefined2(cursor)) {
+          await cursors.set(cursorKey, { lastProcessedBlock: nextProcessedBlock.toString(), lastProcessedId: lastProcessedId.toString() });
+        }
         return {
           confirmedHigh,
           enqueued: 0,
@@ -1564,9 +2158,7 @@ function createEvmBridgeScanner(options2) {
         await enqueue(id, jobLog);
         enqueued++;
       }
-      await cursors.set(cursorKey, {
-        lastProcessedId: confirmedHigh.toString()
-      });
+      await cursors.set(cursorKey, { lastProcessedBlock: nextProcessedBlock.toString(), lastProcessedId: confirmedHigh.toString() });
       return {
         confirmedHigh,
         enqueued,
@@ -1575,16 +2167,21 @@ function createEvmBridgeScanner(options2) {
     }
   };
 }
-__name(createEvmBridgeScanner, "createEvmBridgeScanner");
 
 // src/services/queue/scanner/EvmBridgeScannerRunner.ts
+import { spanAsync as spanAsync16 } from "@xylabs/sdk-js";
 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;
+  const {
+    connection: connection2,
+    intervalMs,
+    logger,
+    scanner,
+    telemetry: telemetry2
+  } = options2;
   let queue;
   let worker;
   return {
@@ -1595,27 +2192,27 @@ function createEvmBridgeScannerRunner(options2) {
         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()}`);
+        await spanAsync16("bridge:scanner:tick", async () => {
+          await job.log("[scanner] tick start");
+          const result = await scanner.scan({ jobLog: (msg) => job.log(msg) });
+          await job.log(
+            `[scanner] tick complete: enqueued=${result.enqueued} confirmedHigh=${result.confirmedHigh.toString()} lastProcessedId=${result.lastProcessedId.toString()}`
+          );
+        }, { logger, timeBudgetLimit: 2e3 });
       }, {
         connection: connection2,
         prefix,
         telemetry: telemetry2
       });
       worker.on("failed", (job, err) => {
-        logger.error(`[scanner] tick ${job?.id} failed:`, err.message);
+        logger.error(`[scanner] tick ${job?.id} failed: ${err.message}`);
       });
       worker.on("error", (err) => {
-        logger.error("[scanner] worker error:", err);
+        logger.error(`[scanner] worker error: ${err.message}`);
       });
       await queue.add(REPEATABLE_JOB_NAME, {}, {
         jobId: REPEATABLE_JOB_ID,
-        repeat: {
-          every: intervalMs
-        }
+        repeat: { every: intervalMs }
       });
     },
     async stop() {
@@ -1626,11 +2223,16 @@ function createEvmBridgeScannerRunner(options2) {
     }
   };
 }
-__name(createEvmBridgeScannerRunner, "createEvmBridgeScannerRunner");
 
 // src/services/queue/scanner/buildEvmBridgeScannerRunner.ts
 function buildEvmBridgeScannerRunner(options2) {
-  const { config, connection: connection2, flowProducer: flowProducer2, logger, services, telemetry: telemetry2 } = options2;
+  const {
+    config,
+    connection: connection2,
+    flowProducer: flowProducer2,
+    services,
+    telemetry: telemetry2
+  } = options2;
   const evmChainId = getRemoteChainId(config);
   const evmContractAddress = config.remoteBridgeContractAddress;
   const xl1ChainId = getXl1ChainId(config);
@@ -1649,111 +2251,106 @@ function buildEvmBridgeScannerRunner(options2) {
     chainId: evmChainId,
     confirmationDepth: services.remoteConfirmationDepth,
     cursors: services.evmBridgeCursorMap,
+    deployBlock: services.evmBridgeDeployBlock,
     enqueue,
     provider: services.provider
   });
   return createEvmBridgeScannerRunner({
     connection: connection2,
     intervalMs,
-    logger,
+    logger: services.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(() => {
+var options = { enableMetrics: true };
+var getTelemetry = () => {
   if (isDefined13(telemetry)) return telemetry;
   telemetry = new BullMQOtel(options);
   return telemetry;
-}, "getTelemetry");
+};
 
 // src/server/addFlowProducer.ts
-var addFlowProducer = /* @__PURE__ */ __name((app, config) => {
+var addFlowProducer = (app, config) => {
   const connection2 = getConnection(config);
   const telemetry2 = getTelemetry();
   const flowProducer2 = getFlowProducer(connection2, telemetry2);
   app.flowProducer = flowProducer2;
   return app;
-}, "addFlowProducer");
+};
 
 // src/server/instrumentation.ts
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
 import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
 import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
-var addInstrumentation = /* @__PURE__ */ __name(() => {
-  const instrumentations = [
-    new HttpInstrumentation(),
-    new ExpressInstrumentation()
-  ];
-  registerInstrumentations({
-    instrumentations
-  });
-}, "addInstrumentation");
+var addInstrumentation = () => {
+  const instrumentations = [new HttpInstrumentation(), new ExpressInstrumentation()];
+  registerInstrumentations({ instrumentations });
+};
 
 // src/server/routes/livez/get.ts
 import { setRawResponseFormat } from "@xylabs/express";
 import { ReasonPhrases } from "http-status-codes";
 var message = ReasonPhrases.OK;
-var handler = /* @__PURE__ */ __name((_req, res) => {
+var handler = (_req, res) => {
   setRawResponseFormat(res);
-  res.status(200).send({
-    message
-  });
-}, "handler");
+  res.status(200).send({ message });
+};
 var getLivez = handler;
 
 // src/server/routes/readyz/get.ts
 import { setRawResponseFormat as setRawResponseFormat2 } from "@xylabs/express";
 import { ReasonPhrases as ReasonPhrases2 } from "http-status-codes";
 var message2 = ReasonPhrases2.OK;
-var handler2 = /* @__PURE__ */ __name((_req, res) => {
+var handler2 = (_req, res) => {
   setRawResponseFormat2(res);
-  res.status(200).send({
-    message: message2
-  });
-}, "handler");
+  res.status(200).send({ message: message2 });
+};
 var getReadyz = handler2;
 
 // src/server/routes/startupz/get.ts
 import { setRawResponseFormat as setRawResponseFormat3 } from "@xylabs/express";
 import { ReasonPhrases as ReasonPhrases3 } from "http-status-codes";
 var message3 = ReasonPhrases3.OK;
-var handler3 = /* @__PURE__ */ __name((_req, res) => {
+var handler3 = (_req, res) => {
   setRawResponseFormat3(res);
-  res.status(200).send({
-    message: message3
-  });
-}, "handler");
+  res.status(200).send({ message: message3 });
+};
 var getStartupz = handler3;
 
 // src/server/routes/addProbeRoutes.ts
-var addProbeRoutes = /* @__PURE__ */ __name((app) => {
+var addProbeRoutes = (app) => {
   app.get("/livez", getLivez);
   app.get("/readyz", getReadyz);
   app.get("/startupz", getStartupz);
-}, "addProbeRoutes");
+};
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts
 import { requestHandlerValidator } from "@xylabs/express";
-import { BridgeSettingsZod } from "@xyo-network/chain-orchestration";
-var BridgeConfigResponseZod = BridgeSettingsZod;
-var validateRequest = requestHandlerValidator({
-  response: BridgeConfigResponseZod
-});
-var makeBridgeConfigRoute = /* @__PURE__ */ __name((config) => {
+import { BridgeConfigResponseZod } from "@xyo-network/chain-bridge-shared";
+var validateRequest = requestHandlerValidator({ response: BridgeConfigResponseZod });
+var makeBridgeConfigRoute = (config) => {
   return {
     method: "get",
     path: "/bridge/chains/:chainId/config",
     handlers: validateRequest(async (_, res) => {
-      const { escrowAddress, feeFixed, feeRateBasisPoints, feesAddress, maxBridgeAmount, minBridgeAmount, remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
+      const {
+        escrowAddress,
+        feeFixed,
+        feeRateBasisPoints,
+        feesAddress,
+        maxBridgeAmount,
+        minBridgeAmount,
+        remoteChainId,
+        remoteTokenAddress,
+        xl1ChainId,
+        xl1TokenAddress
+      } = await getBridgeSettings(config);
       const sanitizedConfig = {
         escrowAddress,
         feeFixed,
@@ -1769,95 +2366,199 @@ var makeBridgeConfigRoute = /* @__PURE__ */ __name((config) => {
       res.json(sanitizedConfig);
     })
   };
-}, "makeBridgeConfigRoute");
+};
 
-// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
+// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteEstimate.ts
 import { requestHandlerValidator as requestHandlerValidator2 } from "@xylabs/express";
-import { isDefined as isDefined14, toHex as toHex4 } from "@xylabs/sdk-js";
-import { PayloadZodStrictOfSchema } from "@xyo-network/sdk-js";
-import { BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema, BridgeIntentFieldsZod, BridgeIntentSchema as BridgeIntentSchema4, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema as BridgeSourceObservationSchema2 } from "@xyo-network/xl1-sdk";
-import { z } from "zod";
+import {
+  assertEx as assertEx24,
+  hexToBigInt as hexToBigInt11,
+  toAddress as toAddress2
+} from "@xylabs/sdk-js";
+import {
+  BridgeFromRemoteEstimateBodyZod,
+  BridgeFromRemoteEstimateResponseZod,
+  buildEthToXl1BridgePayloads as buildEthToXl1BridgePayloads3,
+  calculateBridgeFees as calculateBridgeFees3
+} from "@xyo-network/chain-bridge-shared";
+import { buildUnsignedTransaction, toXL1BlockNumber } from "@xyo-network/xl1-sdk";
+import { z as z2 } from "zod/mini";
 
 // src/server/routes/bridge/routeDefinitions/pathParams/ChainIdPathParam.ts
-import { asHex as asHex3, HexZod, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
-var getRemoteChainIdZod = /* @__PURE__ */ __name((config) => {
+import {
+  asHex as asHex3,
+  HexZod,
+  isDefined as isDefined14
+} from "@xylabs/sdk-js";
+import { z } from "zod/mini";
+var getRemoteChainIdZod = (config) => {
   const remoteChainId = getRemoteChainId(config);
-  return HexZod.superRefine((val, ctx) => {
+  return HexZod.check(z.refine((val) => {
     const chainId = asHex3(val);
-    if (isUndefined3(chainId)) {
-      ctx.addIssue("Not a valid chain id");
-      return;
-    }
-    if (chainId !== remoteChainId) {
-      ctx.addIssue(`Only ${remoteChainId} is supported`);
-    }
+    return isDefined14(chainId) && chainId === remoteChainId;
+  }, { error: `Only ${remoteChainId} is supported` }));
+};
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteEstimate.ts
+var makeBridgeFromRemoteEstimateRoute = (config) => {
+  const params = z2.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator2({
+    params,
+    body: BridgeFromRemoteEstimateBodyZod,
+    response: BridgeFromRemoteEstimateResponseZod
   });
-}, "getRemoteChainIdZod");
+  return {
+    method: "post",
+    path: "/bridge/chains/:chainId/bridgeFromRemote/estimate",
+    handlers: validateRequest2(async (req, res) => {
+      const services = req.app.services;
+      const {
+        account,
+        bridge,
+        gateway
+      } = services;
+      const {
+        srcAddress,
+        srcAmount,
+        destAddress
+      } = req.body;
+      const { maxBridgeAmount, minBridgeAmount } = await getBridgeSettings(config);
+      if (hexToBigInt11(srcAmount) < hexToBigInt11(minBridgeAmount) || hexToBigInt11(srcAmount) > hexToBigInt11(maxBridgeAmount)) {
+        res.status(400).send();
+        return;
+      }
+      const fees = calculateBridgeFees3(srcAmount, getFeeStructure(config));
+      const feesAmount = hexToBigInt11(fees.feeFixed) + hexToBigInt11(fees.feeVariable);
+      const { feesAddress } = await getTransferAddresses(config);
+      const currentNextId = await bridge.nextBridgeToId({ blockTag: "latest" });
+      const projectedBridgeId = currentNextId + 1n;
+      const xl1ChainId = getXl1ChainId(config);
+      const xl1TokenAddress = getXl1TokenAddress(config);
+      const evmChainId = config.remoteChainId;
+      const evmContractAddress = config.remoteBridgeContractAddress;
+      const evmTokenAddress = getRemoteTokenAddress(config);
+      const viewer = assertEx24(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);
+      const { intent, transfer } = buildEthToXl1BridgePayloads3({
+        amount: hexToBigInt11(srcAmount),
+        bridgeAccountAddress: account.address,
+        bridgeId: projectedBridgeId,
+        destAddress: toAddress2(destAddress),
+        evmChainId,
+        evmContractAddress,
+        evmSrcAddress: toAddress2(srcAddress),
+        evmTokenAddress,
+        feesAddress,
+        feesAmount,
+        xl1ChainId,
+        xl1TokenAddress
+      });
+      const [txBw] = await buildUnsignedTransaction(xl1ChainId, [transfer], [intent], nbf, exp, account.address);
+      res.json([txBw, intent, transfer]);
+    })
+  };
+};
 
-// 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
+// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteRetry.ts
+import { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
+import { BridgeRetryBodyZod, BridgeRetryResponseZod } from "@xyo-network/chain-bridge-shared";
+import { z as z3 } from "zod/mini";
+var makeBridgeFromRemoteRetryRoute = (config) => {
+  const params = z3.object({
+    chainId: getRemoteChainIdZod(config),
+    nonce: z3.string().check(z3.regex(/^\d+$/, { error: "nonce must be a non-negative integer (the bridge contract's id)" }))
+  });
+  const validateRequest2 = requestHandlerValidator3({
+    params,
+    body: BridgeRetryBodyZod,
+    response: BridgeRetryResponseZod
   });
-  const intent = {
-    schema: BridgeIntentSchema4,
-    ...intentFields
+  return {
+    method: "post",
+    path: "/bridge/chains/:chainId/bridgeFromRemote/retry/:nonce",
+    handlers: validateRequest2(async (req, res) => {
+      const bridgeId = BigInt(req.params.nonce);
+      const identity = getJobIdForEthToXl1BridgeJob({
+        bridgeId,
+        contractAddress: config.remoteBridgeContractAddress,
+        evmChainId: config.remoteChainId
+      });
+      const queues = getEthToXl1Queues(config);
+      const result = await retrySingleFailedJob({
+        dryRun: req.body.dryRun,
+        jobId: identity,
+        queue: queues.xl1ReserveTxFulfillment
+      });
+      if (result.status === "retried" && !req.body.dryRun) {
+        req.app.services.bridgeFlowMetrics.recordRetried({ direction: "inbound", trigger: "api_singular" });
+      }
+      const httpStatus = result.status === "not-found" ? 404 : 200;
+      res.status(httpStatus).json(result);
+    })
   };
-  const sourceFields = BridgeSourceObservationFieldsZod.parse({
-    ...intentFields,
-    srcConfirmation: canonical.evmTxHash
+};
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteRetryFailed.ts
+import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
+import { BridgeRetryFailedBodyZod, BridgeRetryFailedResponseZod } from "@xyo-network/chain-bridge-shared";
+import { StatusCodes } from "http-status-codes";
+import { z as z4 } from "zod/mini";
+var makeBridgeFromRemoteRetryFailedRoute = (config) => {
+  const params = z4.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator4({
+    params,
+    body: BridgeRetryFailedBodyZod,
+    response: BridgeRetryFailedResponseZod
   });
-  const source = {
-    schema: BridgeSourceObservationSchema2,
-    ...sourceFields
+  return {
+    method: "post",
+    path: "/bridge/chains/:chainId/bridgeFromRemote/retryFailed",
+    handlers: validateRequest2(async (req, res) => {
+      const filters = req.body;
+      if (!hasAnyFilter(filters)) {
+        const err = new Error(
+          `At least one filter is required to prevent accidental retry-everything. Available filters: ${AVAILABLE_BULK_FILTERS.join(", ")}.`
+        );
+        err.name = "Bad Request";
+        err.statusCode = StatusCodes.BAD_REQUEST;
+        throw err;
+      }
+      const services = req.app.services;
+      const queues = getEthToXl1Queues(config);
+      const srcAddressLookup = async (jobId) => {
+        const state = await services.bridgeFulfillmentMap.get(jobId);
+        return state?.canonical?.srcAddress;
+      };
+      const result = await retryFailedJobs({
+        filters,
+        queue: queues.xl1ReserveTxFulfillment,
+        srcAddressLookup
+      });
+      if (!filters.dryRun && result.counts.retried > 0) {
+        services.bridgeFlowMetrics.recordRetried({
+          count: result.counts.retried,
+          direction: "inbound",
+          trigger: "api_bulk"
+        });
+      }
+      res.json(result);
+    })
   };
-  return [
-    intent,
-    source
-  ];
-}
-__name(buildIntentAndSource, "buildIntentAndSource");
-var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
-  const params = z.object({
+};
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
+import { requestHandlerValidator as requestHandlerValidator5 } from "@xylabs/express";
+import { assertEx as assertEx25, isDefined as isDefined15 } from "@xylabs/sdk-js";
+import { BridgeFromRemoteStatusResponseZod } from "@xyo-network/chain-bridge-shared";
+import { z as z5 } from "zod/mini";
+var makeBridgeFromRemoteStatusRoute = (config) => {
+  const params = z5.object({
     chainId: getRemoteChainIdZod(config),
-    nonce: z.string().regex(/^\d+$/, "nonce must be a non-negative integer (the bridge contract's id)")
-  });
-  const validateRequest2 = requestHandlerValidator2({
-    params,
-    response: BridgeFromRemoteStatusResponseZod
+    nonce: z5.string().check(z5.regex(/^\d+$/, { error: "nonce must be a non-negative integer (the bridge contract's id)" }))
   });
+  const validateRequest2 = requestHandlerValidator5({ params, response: BridgeFromRemoteStatusResponseZod });
   return {
     method: "get",
     path: "/bridge/chains/:chainId/bridgeFromRemote/status/:nonce",
@@ -1872,56 +2573,77 @@ var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
       });
       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);
+        if (!isDefined15(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,
-        ...destinationFields
-      };
-      res.json([
-        intent,
-        source,
-        destination
-      ]);
+      const intent = assertEx25(state.acceptedIntent, () => `[${identity}] acceptedIntent missing despite canonical \u2014 stale state`);
+      const source = assertEx25(state.acceptedSourceObservation, () => `[${identity}] acceptedSourceObservation missing despite canonical \u2014 stale state`);
+      if (!state.fulfilled) return res.json([intent, source]);
+      const destination = assertEx25(state.acceptedDestinationObservation, () => `[${identity}] acceptedDestinationObservation missing despite fulfilled \u2014 stale state`);
+      res.json([intent, source, destination]);
     })
   };
-}, "makeBridgeFromRemoteStatusRoute");
+};
 
-// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
-import { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
-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(BridgeIntentSchema5).extend(BridgeIntentFieldsZod2.shape),
-  TransferZod
-]);
-var BridgeToRemoteResponseZod = PayloadZodStrictOfSchema2(BridgeSourceObservationSchema3).extend(BridgeSourceObservationFieldsZod2.shape);
-var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
-  const params = z2.object({
-    chainId: getRemoteChainIdZod(config)
+// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatusByTx.ts
+import { requestHandlerValidator as requestHandlerValidator6 } from "@xylabs/express";
+import { assertEx as assertEx26 } from "@xylabs/sdk-js";
+import { BridgeFromRemoteStatusResponseZod as BridgeFromRemoteStatusResponseZod2 } from "@xyo-network/chain-bridge-shared";
+import { z as z6 } from "zod/mini";
+async function lookupBridgeFromRemoteStatusByTx(map, evmTxHash) {
+  const needle = evmTxHash.toLowerCase();
+  for await (const [, state] of map) {
+    const canonicalHash = state.canonical?.evmTxHash;
+    if (canonicalHash === void 0) continue;
+    if (canonicalHash.toLowerCase() !== needle) continue;
+    const intent = assertEx26(
+      state.acceptedIntent,
+      () => `[${state.identity}] acceptedIntent missing despite canonical \u2014 stale state`
+    );
+    const source = assertEx26(
+      state.acceptedSourceObservation,
+      () => `[${state.identity}] acceptedSourceObservation missing despite canonical \u2014 stale state`
+    );
+    if (!state.fulfilled) return [intent, source];
+    const destination = assertEx26(
+      state.acceptedDestinationObservation,
+      () => `[${state.identity}] acceptedDestinationObservation missing despite fulfilled \u2014 stale state`
+    );
+    return [intent, source, destination];
+  }
+  return null;
+}
+var makeBridgeFromRemoteStatusByTxRoute = (config) => {
+  const params = z6.object({
+    chainId: getRemoteChainIdZod(config),
+    evmTxHash: z6.string().check(z6.regex(/^0x[0-9a-fA-F]{64}$/, { error: "evmTxHash must be a 0x-prefixed 32-byte hex string" }))
   });
-  const validateRequest2 = requestHandlerValidator3({
+  const validateRequest2 = requestHandlerValidator6({ params, response: BridgeFromRemoteStatusResponseZod2 });
+  return {
+    method: "get",
+    path: "/bridge/chains/:chainId/bridgeFromRemote/status/byTx/:evmTxHash",
+    handlers: validateRequest2(async (req, res) => {
+      const services = req.app.services;
+      const result = await lookupBridgeFromRemoteStatusByTx(services.bridgeFulfillmentMap, req.params.evmTxHash);
+      if (result === null) return res.sendStatus(404);
+      res.json(result);
+    })
+  };
+};
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
+import { requestHandlerValidator as requestHandlerValidator7 } from "@xylabs/express";
+import { isDefined as isDefined16 } from "@xylabs/sdk-js";
+import { BridgeToRemoteBodyZod, BridgeToRemoteResponseZod } from "@xyo-network/chain-bridge-shared";
+import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/sdk-js";
+import { BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod2, BridgeSourceObservationSchema as BridgeSourceObservationSchema3 } from "@xyo-network/xl1-sdk";
+import { z as z7 } from "zod/mini";
+var makeBridgeToRemoteRoute = (config) => {
+  const params = z7.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator7({
     params,
     body: BridgeToRemoteBodyZod,
     response: BridgeToRemoteResponseZod
@@ -1948,56 +2670,38 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
         res.status(400).send();
         return;
       }
-      const singedHydratedTransaction = [
-        signedTxBw,
-        [
-          transfer
-        ]
-      ];
+      const singedHydratedTransaction = [signedTxBw, [transfer]];
       const existingFlow = await getXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction);
-      if (isDefined15(existingFlow)) {
+      if (isDefined16(existingFlow)) {
         res.status(200).send();
         return;
       }
-      await createXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction, [
-        bridgeIntent
-      ]);
+      await createXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction, [bridgeIntent]);
       const srcConfirmation = await PayloadBuilder16.hash(signedTxBw);
-      const bridgeCommonFieldsZod = z2.object({}).extend(BridgeSourceObservationFieldsZod2.shape);
+      const bridgeCommonFieldsZod = z7.object(BridgeSourceObservationFieldsZod2.shape);
       const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent);
-      const bridgeObservationFields = {
-        ...bridgeCommonFields,
-        srcConfirmation
-      };
-      const bridgeObservation = new PayloadBuilder16({
-        schema: BridgeSourceObservationSchema3
-      }).fields(bridgeObservationFields).build();
+      const bridgeObservationFields = { ...bridgeCommonFields, srcConfirmation };
+      const bridgeObservation = new PayloadBuilder16(
+        { schema: BridgeSourceObservationSchema3 }
+      ).fields(bridgeObservationFields).build();
       res.status(202).json(bridgeObservation);
     })
   };
-}, "makeBridgeToRemoteRoute");
+};
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
-import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
-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 BridgeIntentFieldsZod3, BridgeIntentSchema as BridgeIntentSchema6, buildUnsignedTransaction, toXL1BlockNumber, TransactionBoundWitnessZod, TransferZod as TransferZod2 } from "@xyo-network/xl1-sdk";
-import { z as z3 } from "zod";
-var BridgeToRemoteEstimateBodyZod = BridgeIntentFieldsZod3.pick({
-  destAddress: true,
-  srcAddress: true,
-  srcAmount: true
-});
-var BridgeToRemoteEstimateResponseZod = z3.tuple([
-  TransactionBoundWitnessZod,
-  PayloadZodStrictOfSchema3(BridgeIntentSchema6).extend(BridgeIntentFieldsZod3.shape),
-  TransferZod2
-]);
-var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) => {
-  const params = z3.object({
-    chainId: getRemoteChainIdZod(config)
-  });
-  const validateRequest2 = requestHandlerValidator4({
+import { requestHandlerValidator as requestHandlerValidator8 } from "@xylabs/express";
+import {
+  assertEx as assertEx27,
+  hexToBigInt as hexToBigInt12,
+  toAddress as toAddress3
+} from "@xylabs/sdk-js";
+import { BridgeToRemoteEstimateBodyZod, BridgeToRemoteEstimateResponseZod } from "@xyo-network/chain-bridge-shared";
+import { buildUnsignedTransaction as buildUnsignedTransaction2, toXL1BlockNumber as toXL1BlockNumber2 } from "@xyo-network/xl1-sdk";
+import { z as z8 } from "zod/mini";
+var makeBridgeToRemoteEstimateRoute = (config, gateway) => {
+  const params = z8.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator8({
     params,
     body: BridgeToRemoteEstimateBodyZod,
     response: BridgeToRemoteEstimateResponseZod
@@ -2007,53 +2711,46 @@ var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) =
     path: "/bridge/chains/:chainId/bridgeToRemote/estimate",
     handlers: validateRequest2(async (req, res) => {
       const xl1ChainId = getXl1ChainId(config);
-      const { srcAddress, srcAmount, destAddress } = req.body;
+      const {
+        srcAddress,
+        srcAmount,
+        destAddress
+      } = req.body;
       const { maxBridgeAmount, minBridgeAmount } = await getBridgeSettings(config);
-      if (hexToBigInt10(srcAmount) < hexToBigInt10(minBridgeAmount) || hexToBigInt10(srcAmount) > hexToBigInt10(maxBridgeAmount)) {
+      if (hexToBigInt12(srcAmount) < hexToBigInt12(minBridgeAmount) || hexToBigInt12(srcAmount) > hexToBigInt12(maxBridgeAmount)) {
         res.status(400).send();
         return;
       }
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
       const sender = toAddress3(srcAddress);
-      const viewer = assertEx22(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const viewer = assertEx27(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);
-      const [txBw] = await buildUnsignedTransaction(xl1ChainId, [
-        transfer
-      ], [
-        bridgeIntent
-      ], nbf, exp, sender);
-      res.json([
-        txBw,
-        bridgeIntent,
-        transfer
-      ]);
+      const nbf = toXL1BlockNumber2(currentBlockNumber, true);
+      const exp = toXL1BlockNumber2(currentBlockNumber + 1e3, true);
+      const [txBw] = await buildUnsignedTransaction2(xl1ChainId, [transfer], [bridgeIntent], nbf, exp, sender);
+      res.json([txBw, bridgeIntent, transfer]);
     })
   };
-}, "makeBridgeToRemoteEstimateRoute");
+};
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteMaxEstimate.ts
-import { requestHandlerValidator as requestHandlerValidator5 } from "@xylabs/express";
-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 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 = BridgeIntentFieldsZod4.pick({
-  destAddress: true,
-  srcAddress: true,
-  srcAmount: true
-});
-var BridgeToRemoteMaxEstimateResponseZod = z4.tuple([
-  TransactionBoundWitnessZod2,
-  PayloadZodStrictOfSchema4(BridgeIntentSchema7).extend(BridgeIntentFieldsZod4.shape),
-  TransferZod3
-]);
-var makeBridgeToRemoteMaxEstimateRoute = /* @__PURE__ */ __name((config, gateway) => {
-  const params = z4.object({
-    chainId: getRemoteChainIdZod(config)
-  });
-  const validateRequest2 = requestHandlerValidator5({
+import { requestHandlerValidator as requestHandlerValidator9 } from "@xylabs/express";
+import {
+  assertEx as assertEx28,
+  hexToBigInt as hexToBigInt13,
+  toAddress as toAddress4,
+  toHex as toHex4
+} from "@xylabs/sdk-js";
+import {
+  BridgeToRemoteMaxEstimateBodyZod,
+  BridgeToRemoteMaxEstimateResponseZod,
+  calculateMaxBridgeAmount
+} from "@xyo-network/chain-bridge-shared";
+import { buildUnsignedTransaction as buildUnsignedTransaction3, toXL1BlockNumber as toXL1BlockNumber3 } from "@xyo-network/xl1-sdk";
+import { z as z9 } from "zod/mini";
+var makeBridgeToRemoteMaxEstimateRoute = (config, gateway) => {
+  const params = z9.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator9({
     params,
     body: BridgeToRemoteMaxEstimateBodyZod,
     response: BridgeToRemoteMaxEstimateResponseZod
@@ -2062,66 +2759,135 @@ var makeBridgeToRemoteMaxEstimateRoute = /* @__PURE__ */ __name((config, gateway
     method: "post",
     path: "/bridge/chains/:chainId/bridgeToRemote/maxEstimate",
     handlers: validateRequest2(async (req, res) => {
-      const { feeFixed, feeRateBasisPoints, maxBridgeAmount: configMax, xl1ChainId } = await getBridgeSettings(config);
-      const { srcAddress, srcAmount: balance, destAddress } = req.body;
-      const balanceMax = calculateMaxBridgeAmount(balance, {
+      const {
         feeFixed,
-        feeRateBasisPoints
-      });
-      const maxBridgeAmount = toHex5(hexToBigInt11(balanceMax) < hexToBigInt11(configMax) ? balanceMax : configMax);
+        feeRateBasisPoints,
+        maxBridgeAmount: configMax,
+        xl1ChainId
+      } = await getBridgeSettings(config);
+      const {
+        srcAddress,
+        srcAmount: balance,
+        destAddress
+      } = req.body;
+      const balanceMax = calculateMaxBridgeAmount(balance, { feeFixed, feeRateBasisPoints });
+      const maxBridgeAmount = toHex4(hexToBigInt13(balanceMax) < hexToBigInt13(configMax) ? balanceMax : configMax);
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, maxBridgeAmount, destAddress, config);
       const sender = toAddress4(srcAddress);
-      const viewer = assertEx23(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const viewer = assertEx28(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);
-      const [txBw] = await buildUnsignedTransaction2(xl1ChainId, [
-        transfer
-      ], [
-        bridgeIntent
-      ], nbf, exp, sender);
-      res.json([
-        txBw,
-        bridgeIntent,
-        transfer
-      ]);
+      const nbf = toXL1BlockNumber3(currentBlockNumber, true);
+      const exp = toXL1BlockNumber3(currentBlockNumber + 1e3, true);
+      const [txBw] = await buildUnsignedTransaction3(xl1ChainId, [transfer], [bridgeIntent], nbf, exp, sender);
+      res.json([txBw, bridgeIntent, transfer]);
     })
   };
-}, "makeBridgeToRemoteMaxEstimateRoute");
+};
 
-// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteStatus.ts
-import { requestHandlerValidator as requestHandlerValidator6 } from "@xylabs/express";
-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 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([
-    BridgeIntentResponseZod2
-  ]),
-  z5.tuple([
-    BridgeIntentResponseZod2,
-    BridgeSourceResponseZod2
-  ]),
-  z5.tuple([
-    BridgeIntentResponseZod2,
-    BridgeSourceResponseZod2,
-    BridgeDestinationResponseZod2
-  ])
-]);
-var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
-  const params = z5.object({
+// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteRetry.ts
+import { requestHandlerValidator as requestHandlerValidator10 } from "@xylabs/express";
+import { BridgeRetryBodyZod as BridgeRetryBodyZod2, BridgeRetryResponseZod as BridgeRetryResponseZod2 } from "@xyo-network/chain-bridge-shared";
+import { z as z10 } from "zod/mini";
+var makeBridgeToRemoteRetryRoute = (config) => {
+  const params = z10.object({
     chainId: getRemoteChainIdZod(config),
-    nonce: z5.string().nonempty()
+    nonce: z10.string().check(z10.minLength(1))
   });
-  const validateRequest2 = requestHandlerValidator6({
+  const validateRequest2 = requestHandlerValidator10({
+    params,
+    body: BridgeRetryBodyZod2,
+    response: BridgeRetryResponseZod2
+  });
+  return {
+    method: "post",
+    path: "/bridge/chains/:chainId/bridgeToRemote/retry/:nonce",
+    handlers: validateRequest2(async (req, res) => {
+      const jobId = req.params.nonce;
+      const queues = getXl1ToEthQueues(config);
+      const result = await retrySingleFailedJob({
+        dryRun: req.body.dryRun,
+        jobId,
+        queue: queues.ethTransactionMonitor
+      });
+      if (result.status === "retried" && !req.body.dryRun) {
+        req.app.services.bridgeFlowMetrics.recordRetried({ direction: "outbound", trigger: "api_singular" });
+      }
+      const httpStatus = result.status === "not-found" ? 404 : 200;
+      res.status(httpStatus).json(result);
+    })
+  };
+};
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteRetryFailed.ts
+import { requestHandlerValidator as requestHandlerValidator11 } from "@xylabs/express";
+import { BridgeRetryFailedBodyZod as BridgeRetryFailedBodyZod2, BridgeRetryFailedResponseZod as BridgeRetryFailedResponseZod2 } from "@xyo-network/chain-bridge-shared";
+import { isBridgeIntent as isBridgeIntent6 } from "@xyo-network/xl1-sdk";
+import { StatusCodes as StatusCodes2 } from "http-status-codes";
+import { z as z11 } from "zod/mini";
+var makeBridgeToRemoteRetryFailedRoute = (config) => {
+  const params = z11.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator11({
     params,
-    response: BridgeToRemoteStatusResponseZod
+    body: BridgeRetryFailedBodyZod2,
+    response: BridgeRetryFailedResponseZod2
+  });
+  return {
+    method: "post",
+    path: "/bridge/chains/:chainId/bridgeToRemote/retryFailed",
+    handlers: validateRequest2(async (req, res) => {
+      const filters = req.body;
+      if (!hasAnyFilter(filters)) {
+        const err = new Error(
+          `At least one filter is required to prevent accidental retry-everything. Available filters: ${AVAILABLE_BULK_FILTERS.join(", ")}.`
+        );
+        err.name = "Bad Request";
+        err.statusCode = StatusCodes2.BAD_REQUEST;
+        throw err;
+      }
+      const queues = getXl1ToEthQueues(config);
+      const srcAddressLookup = async (jobId) => {
+        const job = await queues.ethTransactionMonitor.getJob(jobId);
+        const data = job?.data;
+        const bridgeIntent = data?.tx[1].find(isBridgeIntent6);
+        return bridgeIntent?.srcAddress;
+      };
+      const result = await retryFailedJobs({
+        filters,
+        queue: queues.ethTransactionMonitor,
+        srcAddressLookup
+      });
+      if (!filters.dryRun && result.counts.retried > 0) {
+        req.app.services.bridgeFlowMetrics.recordRetried({
+          count: result.counts.retried,
+          direction: "outbound",
+          trigger: "api_bulk"
+        });
+      }
+      res.json(result);
+    })
+  };
+};
+
+// src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteStatus.ts
+import { requestHandlerValidator as requestHandlerValidator12 } from "@xylabs/express";
+import { asHex as asHex4, isDefined as isDefined17 } from "@xylabs/sdk-js";
+import { BridgeToRemoteStatusResponseZod } from "@xyo-network/chain-bridge-shared";
+import { PayloadBuilder as PayloadBuilder17 } from "@xyo-network/sdk-js";
+import {
+  asBridgeIntent,
+  BridgeDestinationObservationFieldsZod as BridgeDestinationObservationFieldsZod2,
+  BridgeDestinationObservationSchema as BridgeDestinationObservationSchema2,
+  BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod3,
+  BridgeSourceObservationSchema as BridgeSourceObservationSchema4,
+  isBridgeIntent as isBridgeIntent7
+} from "@xyo-network/xl1-sdk";
+import { z as z12 } from "zod/mini";
+var makeBridgeToRemoteStatusRoute = (config) => {
+  const params = z12.object({
+    chainId: getRemoteChainIdZod(config),
+    nonce: z12.string().check(z12.minLength(1))
   });
+  const validateRequest2 = requestHandlerValidator12({ params, response: BridgeToRemoteStatusResponseZod });
   return {
     method: "get",
     path: "/bridge/chains/:chainId/bridgeToRemote/status/:nonce",
@@ -2132,18 +2898,15 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
       const statusQueueJobs = await getStatusQueueJobs(queues, jobId);
       const { tx, offChainPayloads = [] } = statusQueueJobs.xl1ToEthBridgeParentJob?.data ?? {};
       if (!tx) return res.sendStatus(404);
-      const allPayloads = [
-        ...tx[1],
-        ...offChainPayloads
-      ];
-      const bridgeIntent = allPayloads.find(isBridgeIntent5);
+      const allPayloads = [...tx[1], ...offChainPayloads];
+      const bridgeIntent = allPayloads.find(isBridgeIntent7);
       if (!bridgeIntent) return res.sendStatus(404);
       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 (isDefined16(srcConfirmation)) {
+        if (isDefined17(srcConfirmation)) {
           const schema = BridgeSourceObservationSchema4;
           const bridgeSourceObservationFields = BridgeSourceObservationFieldsZod3.parse(bridgeIntent);
           const observation = {
@@ -2158,7 +2921,7 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
       const ethMonitorState = ethTransactionMonitorJob ? await ethTransactionMonitorJob.getState() : void 0;
       if (ethMonitorState === "completed") {
         const destConfirmation = asHex4(ethTransactionMonitorJob?.returnvalue?.submissionHash);
-        if (isDefined16(destConfirmation)) {
+        if (isDefined17(destConfirmation)) {
           const schema = BridgeDestinationObservationSchema2;
           const bridgeDestinationObservationFields = BridgeDestinationObservationFieldsZod2.parse(bridgeIntent);
           const observation = {
@@ -2172,36 +2935,42 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
       res.json(result);
     })
   };
-}, "makeBridgeToRemoteStatusRoute");
+};
 
 // src/server/routes/bridge/routeDefinitions/getRouteDefinitions.ts
-var getRouteDefinitions = /* @__PURE__ */ __name((config, gateway) => {
+var getRouteDefinitions = (config, gateway) => {
   return [
     makeBridgeConfigRoute(config),
     makeBridgeToRemoteEstimateRoute(config, gateway),
     makeBridgeToRemoteMaxEstimateRoute(config, gateway),
     makeBridgeToRemoteRoute(config),
+    makeBridgeToRemoteRetryRoute(config),
+    makeBridgeToRemoteRetryFailedRoute(config),
     makeBridgeToRemoteStatusRoute(config),
-    makeBridgeFromRemoteStatusRoute(config)
+    makeBridgeFromRemoteEstimateRoute(config),
+    makeBridgeFromRemoteRetryRoute(config),
+    makeBridgeFromRemoteRetryFailedRoute(config),
+    makeBridgeFromRemoteStatusRoute(config),
+    makeBridgeFromRemoteStatusByTxRoute(config)
   ];
-}, "getRouteDefinitions");
+};
 
 // src/server/routes/bridge/addBridgeRoutes.ts
-var addBridgeRoutes = /* @__PURE__ */ __name((app, config, gateway) => {
+var addBridgeRoutes = (app, config, gateway) => {
   const routeDefinitions = getRouteDefinitions(config, gateway);
   for (const definition of routeDefinitions) {
     app[definition.method](definition.path, definition.handlers);
   }
-}, "addBridgeRoutes");
+};
 
 // src/server/routes/addRoutes.ts
-var addRoutes = /* @__PURE__ */ __name((app, config, gateway) => {
+var addRoutes = (app, config, gateway) => {
   addProbeRoutes(app);
   addBridgeRoutes(app, config, gateway);
-}, "addRoutes");
+};
 
 // src/server/app.ts
-var getApp = /* @__PURE__ */ __name((config, gateway) => {
+var getApp = (config, gateway) => {
   addInstrumentation();
   const app = express();
   sharedMiddleware(app);
@@ -2209,22 +2978,28 @@ var getApp = /* @__PURE__ */ __name((config, gateway) => {
   addRoutes(app, config, gateway);
   app.use(standardErrors);
   return app;
-}, "getApp");
+};
 
 // src/services/getServices.ts
-import { assertEx as assertEx24 } from "@xylabs/sdk-js";
+import { assertEx as assertEx29 } 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";
+import { getAddress as getAddress3, Wallet } from "ethers";
 
 // src/services/getIterableMap.ts
 import { BaseMongoSdk } from "@xylabs/mongo";
 import { MongoMap } from "@xyo-network/chain-protocol-driver-mongodb";
 import { hasMongoConfig, mapToMapType } from "@xyo-network/xl1-sdk";
-var getIterableMap = /* @__PURE__ */ __name(async (config, collection) => {
+var getIterableMap = async (config, collection) => {
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig(mongoConfig)) {
-    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const {
+      connectionString: dbConnectionString,
+      database: dbName,
+      domain: dbDomain,
+      password: dbPassword,
+      username: dbUserName
+    } = mongoConfig;
     const payloadSdkConfig = {
       dbConnectionString,
       dbDomain,
@@ -2232,237 +3007,98 @@ var getIterableMap = /* @__PURE__ */ __name(async (config, collection) => {
       dbPassword,
       dbUserName
     };
-    const sdkBalanceSummaryMap = new BaseMongoSdk({
-      ...payloadSdkConfig,
-      collection
-    });
+    const sdkBalanceSummaryMap = new BaseMongoSdk({ ...payloadSdkConfig, collection });
     const result = await MongoMap.create({
       sdk: sdkBalanceSummaryMap,
-      getCache: {
-        enabled: true,
-        maxEntries: 5e3
-      }
+      getCache: { enabled: true, maxEntries: 5e3 }
     });
     return result;
   } else {
     return mapToMapType(/* @__PURE__ */ new Map());
   }
-}, "getIterableMap");
+};
 
 // src/services/getServices.ts
-var getServices = /* @__PURE__ */ __name(async (context, gateway) => {
+var getServices = async (context, gateway, logger, meter) => {
   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 {
+    remoteBridgeContractAddress,
+    remoteChainWalletPrivateKey,
+    remoteTokenAddress,
+    accountPath
+  } = config;
   const account = await resolveWalletForActor2(config.name, accountPath);
   const wallet = new Wallet(remoteChainWalletPrivateKey, provider);
-  const bridgeableToken = BridgeableToken__factory.connect(getAddress2(remoteTokenAddress), wallet);
-  const bridge = LiquidityPoolBridge__factory.connect(getAddress2(remoteBridgeContractAddress), wallet);
+  const bridgeableToken = BridgeableToken__factory.connect(getAddress3(remoteTokenAddress), wallet);
+  const bridge = LiquidityPoolBridge__factory.connect(getAddress3(remoteBridgeContractAddress), wallet);
   const bridgeOwner = await bridge.owner();
-  assertEx24(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
+  assertEx29(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
   const remoteConfirmationDepth = getRemoteConfirmationDepth(config);
+  const evmBridgeDeployBlock = await resolveDeployBlock({
+    configuredDeployBlock: config.remoteBridgeContractDeployBlock,
+    contractAddress: remoteBridgeContractAddress,
+    provider
+  });
+  const bridgeFlowMetrics = createBridgeFlowMetrics({
+    meter,
+    remoteChainId: config.remoteChainId
+  });
   return {
     account,
     bridge,
+    bridgeFlowMetrics,
     bridgeableToken,
     bridgeFulfillmentMap,
+    config,
     ethTxStateMap,
     evmBridgeCursorMap,
+    evmBridgeDeployBlock,
     gateway,
+    logger,
     provider,
     remoteConfirmationDepth,
     wallet,
     xl1TxStateMap
   };
-}, "getServices");
+};
 
 // src/server/addWorkers.ts
-var addWorkers = /* @__PURE__ */ __name((config, services) => {
+var addWorkers = (config, services) => {
   const connection2 = getConnection(config);
   const telemetry2 = getTelemetry();
   createWorkers(connection2, telemetry2, services);
-}, "addWorkers");
+};
 
 // src/server/server.ts
 var hostname = "::";
-var getServer = /* @__PURE__ */ __name(async (context, gateway) => {
-  const { logger, config } = context;
+var getServer = async (context, gateway, logger, meter) => {
+  const { config } = context;
   const { port } = config;
   const app = getApp(config, gateway);
-  const services = await getServices(context, gateway);
+  const services = await getServices(context, gateway, logger, meter);
   app.services = services;
   addWorkers(config, services);
   const server = await new Promise((resolve, reject) => {
     const srv = app.listen(port, hostname, () => {
-      logger?.log(`[Bridge] Server listening at http://${hostname}:${port}`);
+      logger.log(`[Bridge] Server listening at http://${hostname}:${port}`);
       resolve(srv);
     });
     srv.once("error", reject);
   });
   server.setTimeout(2e4);
-  return {
-    server,
-    services
-  };
-}, "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");
+  return { server, services };
+};
 
 // 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;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
 var BridgeActor = class extends ActorV3 {
-  static {
-    __name(this, "BridgeActor");
-  }
-  static needs = {
-    required: [
-      XyoGatewayRunnerMoniker,
-      XyoViewerMoniker
-    ]
-  };
   _gatewayRunner;
   _balanceMonitor;
+  _inFlightPoller;
   _queueMetrics;
   _scannerRunner;
   server;
@@ -2483,15 +3119,17 @@ var BridgeActor = class extends ActorV3 {
     await this._scannerRunner?.stop();
     this._scannerRunner = void 0;
     this._balanceMonitor?.stop();
+    this._inFlightPoller?.stop();
     this._queueMetrics?.stop();
     this._balanceMonitor = void 0;
+    this._inFlightPoller = void 0;
     this._queueMetrics = void 0;
     this.stopServer();
   }
   async startServer() {
     const context = asBridgeConfigContext(this.context, true);
     const config = context.config;
-    const { server, services } = await getServer(context, this._gatewayRunner);
+    const { server, services } = await getServer(context, this._gatewayRunner, this.logger, this.meter);
     this.server = server;
     const connection2 = getConnection(config);
     const telemetry2 = getTelemetry();
@@ -2500,7 +3138,6 @@ var BridgeActor = class extends ActorV3 {
       config,
       connection: connection2,
       flowProducer: flowProducer2,
-      logger: this.logger,
       services,
       telemetry: telemetry2
     });
@@ -2513,6 +3150,7 @@ var BridgeActor = class extends ActorV3 {
         gateway: services.gateway,
         meter: this.meter,
         provider: services.provider,
+        remoteChainId: config.remoteChainId,
         wallet: services.wallet
       });
       this._balanceMonitor.start();
@@ -2522,9 +3160,16 @@ var BridgeActor = class extends ActorV3 {
       };
       this._queueMetrics = createQueueMetrics({
         meter: this.meter,
-        queues
+        queues,
+        remoteChainId: config.remoteChainId
       });
       this._queueMetrics.start();
+      this._inFlightPoller = createInFlightPoller({
+        bridgeFulfillmentMap: services.bridgeFulfillmentMap,
+        meter: this.meter,
+        remoteChainId: config.remoteChainId
+      });
+      this._inFlightPoller.start();
     }
   }
   stopServer() {
@@ -2532,7 +3177,13 @@ var BridgeActor = class extends ActorV3 {
     this.server = void 0;
   }
 };
-BridgeActor = _ts_decorate([
+__publicField(BridgeActor, "needs", {
+  required: [
+    XyoGatewayRunnerMoniker,
+    XyoViewerMoniker
+  ]
+});
+BridgeActor = __decorateClass([
   creatable()
 ], BridgeActor);
 
@@ -2542,7 +3193,7 @@ 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) => {
+var getBridgeActor = async (config, locator) => {
   const account = await initActorWallet({
     config,
     logger: locator.context.logger,
@@ -2554,17 +3205,15 @@ var getBridgeActor = /* @__PURE__ */ __name(async (config, locator) => {
     config,
     locator
   });
-}, "getBridgeActor");
-var runBridge = /* @__PURE__ */ __name(async (config, orchestrator, locator) => {
+};
+var runBridge = async (config, orchestrator, locator) => {
   const bridge = await getBridgeActor(config, locator);
-  const actors = [
-    bridge
-  ].filter(exists);
+  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) {
@@ -2572,22 +3221,22 @@ function bridgeCommand(getConfiguration, getLocatorsFromConfig) {
     command: "bridge",
     deprecated: 'Use "start bridge" instead',
     describe: "Run a XL1 Bridge Node",
-    handler: /* @__PURE__ */ __name(async () => {
+    handler: async () => {
       const configuration = getConfiguration();
-      const { locators, orchestrator } = await getLocatorsFromConfig([
-        "bridge"
-      ], configuration);
+      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,
+  bucketFailureReason,
   createBalanceMonitor,
+  createBridgeFlowMetrics,
+  createInFlightPoller,
   createQueueMetrics,
   getBridgeActor,
   runBridge
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map