@xyo-network/chain-bridge 1.23.2 → 2.0.0

package/dist/node/index.mjs

@@ -57,14 +57,475 @@ var getFlowProducer = (connection2, telemetry2) => {
 };
 
 // src/services/queue/workers/EthEventVerification.ts
-import { assertEx as assertEx3, 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/buildEthToXl1BridgePayloads.ts
-import { assertEx, toHex } from "@xylabs/sdk-js";
+// 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";
+}
+
+// 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 {
+    start() {
+      void poll();
+      timer = setInterval(() => void poll(), intervalMs);
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
+
+// src/telemetry/createBridgeFlowMetrics.ts
+function createBridgeFlowMetrics(config) {
+  const { meter, remoteChainId } = config;
+  if (meter === void 0) {
+    const noop = () => {
+    };
+    return {
+      recordAttemptExpiration: noop,
+      recordRetried: noop,
+      recordSuccess: noop,
+      recordTerminalFailure: noop
+    };
+  }
+  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/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/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 } from "@xylabs/sdk-js";
+var asChainId = (value) => {
+  const chainId = asHex(value);
+  return chainId;
+};
+
+// src/services/evm/asToken.ts
+import { asAddress } from "@xylabs/sdk-js";
+var asToken = (value) => {
+  const token = asAddress(value);
+  return token;
+};
+
+// src/services/evm/getBridgeEscrowAddress.ts
+import { asAddress as asAddress2, assertEx } from "@xylabs/sdk-js";
+var tryGetBridgeEscrowAddress = (config) => {
+  const address = asAddress2(config.escrowAddress);
+  return address;
+};
+
+// src/services/evm/getBridgeFeesAddress.ts
+import { asAddress as asAddress3, assertEx as assertEx2 } from "@xylabs/sdk-js";
+var tryGetBridgeFeesAddress = (config) => {
+  const address = asAddress3(config.feesAddress);
+  return address;
+};
+
+// src/services/evm/getFeeStructure.ts
+var getFeeStructure = (config) => {
+  const { feeFixed, feeRateBasisPoints } = config;
+  return { feeFixed, feeRateBasisPoints };
+};
+
+// src/services/evm/getMaxBridgeAmount.ts
+var getMaxBridgeAmount = (config) => {
+  const { maxBridgeAmount } = config;
+  return maxBridgeAmount;
+};
+
+// src/services/evm/getMinBridgeAmount.ts
+var getMinBridgeAmount = (config) => {
+  const { minBridgeAmount } = config;
+  return minBridgeAmount;
+};
+
+// src/services/evm/getRemoteChainId.ts
+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;
+};
+
+// src/services/evm/getRemoteTokenAddress.ts
+import { assertEx as assertEx4 } from "@xylabs/sdk-js";
+var getRemoteTokenAddress = (config) => {
+  const token = asToken(config.remoteTokenAddress);
+  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 = 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;
+};
+
+// src/services/evm/getTransferAddresses.ts
+var getTransferAddresses = async (config) => {
+  const escrowAddress = tryGetBridgeEscrowAddress(config) ?? (await getBridgeWalletAccount(config)).address;
+  const feesAddress = tryGetBridgeFeesAddress(config) ?? (await getBridgeWalletAccount(config)).address;
+  return { escrowAddress, feesAddress };
+};
+
+// src/services/evm/getXl1ChainId.ts
+import { assertEx as assertEx5, isDefined as isDefined4 } from "@xylabs/sdk-js";
+var getXl1ChainId = (config) => {
+  const xl1ChainId = config.xl1ChainId;
+  if (isDefined4(xl1ChainId)) {
+    return assertEx5(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
+  }
+  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 = (config) => {
+  const token = asToken(config.xl1TokenAddress);
+  if (isDefined5(token)) return token;
+  return getXl1ChainId(config);
+};
+
+// src/services/evm/getBridgeSettings.ts
+var getBridgeSettings = async (config) => {
+  const { feeFixed, feeRateBasisPoints } = getFeeStructure(config);
+  const { feesAddress, escrowAddress } = await getTransferAddresses(config);
+  const maxBridgeAmount = getMaxBridgeAmount(config);
+  const minBridgeAmount = getMinBridgeAmount(config);
+  const remoteChainId = getRemoteChainId(config);
+  const remoteTokenAddress = getRemoteTokenAddress(config);
+  const xl1TokenAddress = getXl1TokenAddress(config);
+  const xl1ChainId = getXl1ChainId(config);
+  return {
+    feeFixed,
+    feeRateBasisPoints,
+    feesAddress,
+    escrowAddress,
+    maxBridgeAmount,
+    minBridgeAmount,
+    remoteChainId,
+    remoteTokenAddress,
+    xl1TokenAddress,
+    xl1ChainId
+  };
+};
+
+// src/services/evm/getRemoteConfirmationDepth.ts
+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 = /* @__PURE__ */ new Map([
+  [HARDHAT_CHAIN_ID, 0],
+  [ETHEREUM_MAINNET_CHAIN_ID, 32]
+]);
+function getRemoteConfirmationDepth(config) {
+  if (isDefined6(config.remoteConfirmationDepth)) return config.remoteConfirmationDepth;
+  const chainId = toHex(getRemoteChainId(config));
+  return DEFAULT_CONFIRMATION_DEPTH_BY_CHAIN_ID.get(chainId) ?? FALLBACK_CONFIRMATION_DEPTH;
+}
+
+// src/services/evm/getScannerIntervalMs.ts
+function getScannerIntervalMs(config) {
+  return config.scannerIntervalMs;
+}
+
+// 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 { BridgeIntentSchema, createTransferPayload } from "@xyo-network/xl1-sdk";
-function buildEthToXl1BridgePayloads(options2) {
+import {
+  BridgeDestinationObservationFieldsZod,
+  BridgeDestinationObservationSchema,
+  BridgeSourceObservationFieldsZod,
+  BridgeSourceObservationSchema
+} from "@xyo-network/xl1-sdk";
+function buildAcceptedSnapshot(options2) {
   const {
     amount,
     bridgeAccountAddress,
@@ -74,36 +535,53 @@ function buildEthToXl1BridgePayloads(options2) {
     evmContractAddress,
     evmSrcAddress,
     evmTokenAddress,
+    evmTxHash,
+    feeFixed,
+    feeRateBasisPoints,
     feesAddress,
-    feesAmount,
     xl1ChainId,
     xl1TokenAddress
   } = options2;
-  assertEx(amount >= feesAmount, () => `buildEthToXl1BridgePayloads: amount (${amount}) < feesAmount (${feesAmount})`);
-  const destAmount = amount - feesAmount;
-  const srcAmountHex = toHex(amount);
-  const destAmountHex = toHex(destAmount);
-  const nonce = `evm-${evmChainId.toLowerCase()}-${evmContractAddress.toLowerCase()}-${bridgeId.toString()}`;
-  const transfers = feesAmount === 0n || destAddress === feesAddress ? { [destAddress]: amount } : { [destAddress]: destAmount, [feesAddress]: feesAmount };
-  const transfer = createTransferPayload(bridgeAccountAddress, transfers);
-  const intent = new PayloadBuilder({ schema: BridgeIntentSchema }).fields({
-    dest: xl1ChainId,
+  const acceptedFees = calculateBridgeFees(toHex2(amount), { feeFixed, feeRateBasisPoints });
+  const feesAmount = hexToBigInt(acceptedFees.feeFixed) + hexToBigInt(acceptedFees.feeVariable);
+  const { intent: acceptedIntent } = buildEthToXl1BridgePayloads({
+    amount,
+    bridgeAccountAddress,
+    bridgeId,
     destAddress,
-    destAmount: destAmountHex,
-    destToken: xl1TokenAddress,
-    nonce,
-    src: evmChainId,
-    srcAddress: evmSrcAddress,
-    srcAmount: srcAmountHex,
-    srcToken: evmTokenAddress
-  }).build();
-  return { intent, transfer };
+    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
+  };
+}
+function buildAcceptedDestinationObservation(intent, destConfirmation) {
+  const fields = BridgeDestinationObservationFieldsZod.parse({
+    ...intent,
+    destConfirmation
+  });
+  return new PayloadBuilder({ schema: BridgeDestinationObservationSchema }).fields(fields).build();
 }
 
 // src/services/queue/workers/util/buildEthToXl1ReserveTx.ts
-import { toHex as toHex2 } from "@xylabs/sdk-js";
+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, buildTransaction } from "@xyo-network/xl1-sdk";
+import { BridgeSourceObservationSchema as BridgeSourceObservationSchema2, buildTransaction } from "@xyo-network/xl1-sdk";
 async function buildEthToXl1ReserveTx(options2) {
   const {
     amount,
@@ -122,7 +600,7 @@ async function buildEthToXl1ReserveTx(options2) {
     xl1ChainId,
     xl1TokenAddress
   } = options2;
-  const { intent, transfer } = buildEthToXl1BridgePayloads({
+  const { intent, transfer } = buildEthToXl1BridgePayloads2({
     amount,
     bridgeAccountAddress: bridgeAccount.address,
     bridgeId,
@@ -136,9 +614,9 @@ async function buildEthToXl1ReserveTx(options2) {
     xl1ChainId,
     xl1TokenAddress
   });
-  const destAmountHex = toHex2(amount - feesAmount);
-  const srcAmountHex = toHex2(amount);
-  const sourceObservation = new PayloadBuilder2({ schema: BridgeSourceObservationSchema }).fields({
+  const destAmountHex = toHex3(amount - feesAmount);
+  const srcAmountHex = toHex3(amount);
+  const sourceObservation = new PayloadBuilder2({ schema: BridgeSourceObservationSchema2 }).fields({
     dest: xl1ChainId,
     destAddress,
     destAmount: destAmountHex,
@@ -160,29 +638,29 @@ async function buildEthToXl1ReserveTx(options2) {
 }
 
 // src/services/queue/workers/util/resolveEvmBlockTagAtDepth.ts
-async function resolveEvmBlockTagAtDepth(provider, depth) {
+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, 0);
+  return Math.max(head - depth, deployBlock);
 }
 
 // src/services/queue/workers/util/submitEthTransaction.ts
 import {
-  assertEx as assertEx2,
-  hexToBigInt,
+  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 = assertEx2(tx[0], () => "No corresponding XL1 transaction found");
+  const xl1Transaction = assertEx6(tx[0], () => "No corresponding XL1 transaction found");
   const allPayloads = [...tx[1], ...offChainPayloads];
-  const bridgeIntent = assertEx2(allPayloads.find(isBridgeIntent), () => "No bridge intent found");
+  const bridgeIntent = assertEx6(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 PayloadBuilder3.hash(xl1Transaction));
+  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;
@@ -195,16 +673,16 @@ var submitXl1Transaction = async (preparedTx, offChain = [], gateway) => {
 };
 
 // src/services/queue/workers/util/verifyEthBridgeEvent.ts
-import { asHex, toAddress } from "@xylabs/sdk-js";
+import { asHex as asHex2, toAddress } from "@xylabs/sdk-js";
 import { ZeroAddress } from "ethers";
-async function verifyEthBridgeEvent(id, bridge, provider, confirmationDepth) {
-  const blockTag = await resolveEvmBlockTagAtDepth(provider, confirmationDepth);
+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, 0, blockTag);
+  const events = await bridge.queryFilter(filter, deployBlock, blockTag);
   const event = events[0];
   if (event === void 0) {
     return null;
@@ -213,7 +691,8 @@ async function verifyEthBridgeEvent(id, bridge, provider, confirmationDepth) {
     amount: data.amount,
     destAddress: toAddress(data.destAddress),
     destToken: toAddress(data.destToken),
-    evmTxHash: asHex(event.transactionHash, true),
+    evmTxHash: asHex2(event.transactionHash, true),
+    observedAt: Date.now(),
     srcAddress: toAddress(data.srcAddress)
   };
 }
@@ -222,41 +701,63 @@ async function verifyEthBridgeEvent(id, bridge, provider, confirmationDepth) {
 var name = "Verify ETH Bridge Event at Depth";
 var queueName = "eth-event-verify";
 var createWorker = (connection2, telemetry2, services) => {
-  const svc = assertEx3(services, () => "services not provided");
+  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) => {
-      const { bridgeId, identity } = job.data;
-      const id = BigInt(bridgeId);
-      const existing = await bridgeFulfillmentMap.get(identity);
-      if (existing?.canonical) {
-        await job.log(`[${identity}] canonical already set; verification skipped`);
-        return;
-      }
-      const state = existing ?? { identity, previousAttempts: [] };
-      if (state.failed) state.failed = void 0;
-      await job.log(`[${identity}] verifying BridgedToRemote(${id}) at depth ${remoteConfirmationDepth}`);
-      const data = await verifyEthBridgeEvent(id, bridge, provider, remoteConfirmationDepth);
-      if (isNull(data)) {
-        state.failed = {
-          at: Date.now(),
-          reason: "non-canonical at confirmation depth \u2014 orphaned by reorg or never reached canonical state"
-        };
+      await 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}] 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}`
-      );
+        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,
@@ -265,10 +766,15 @@ var createWorker = (connection2, telemetry2, services) => {
     }
   );
   worker.on("failed", (job, err) => {
-    console.error(`[${name}] Job ${job?.id} failed:`, err.message);
+    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) => {
-    console.error(`[${name}] Worker error:`, err);
+    logger.error(`[eth-verify] worker error: ${err.message}`);
   });
 };
 var EthEventVerification = {
@@ -278,62 +784,20 @@ var EthEventVerification = {
 };
 
 // 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) => {
+var createWorker2 = (connection2, telemetry2, services) => {
+  const logger = assertEx8(services?.logger, () => "logger service not provided");
   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);
-  });
-};
-var EthToXl1BridgeParent = {
-  createWorker: createWorker2,
-  name: name2,
-  queueName: queueName2
-};
-
-// src/services/queue/workers/EthTransactionMonitor.ts
-import { assertEx as assertEx4 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
-import { Worker as Worker3 } from "bullmq";
-var name3 = "Monitor Submitted ETH Transaction";
-var queueName3 = "eth-tx-monitor";
-var createWorker3 = (connection2, telemetry2, services) => {
-  const provider = assertEx4(services?.provider, () => "provider service not provided");
-  const stateMap = assertEx4(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
-  const worker = new Worker3(
-    queueName3,
-    async (job) => {
-      const { tx } = job.data;
-      const hash = await PayloadBuilder4.hash(tx[0]);
-      const state = assertEx4(await stateMap.get(hash), () => "State not found");
-      const submissionHash = assertEx4(state?.submissionHash, () => "submissionHash not found");
-      const receipt = assertEx4(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
-      };
+      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,
@@ -342,252 +806,124 @@ var createWorker3 = (connection2, telemetry2, services) => {
     }
   );
   worker.on("failed", (job, err) => {
-    console.error(`[${name3}] Job ${job?.id} failed:`, err.message);
+    logger.error(`[eth-to-xl1-parent] job ${job?.id} failed: ${err.message}`);
   });
   worker.on("error", (err) => {
-    console.error(`[${name3}] Worker error:`, err);
+    logger.error(`[eth-to-xl1-parent] worker error: ${err.message}`);
   });
 };
-var EthTransactionMonitor = {
-  createWorker: createWorker3,
-  name: name3,
-  queueName: queueName3
-};
-
-// src/services/queue/workers/EthTransactionPreparation.ts
-import { assertEx as assertEx15, hexToBigInt as hexToBigInt10 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder8 } 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/services/validation/validateAmountMeetsMinBridgeAmount.ts
-import { hexToBigInt as hexToBigInt2 } from "@xylabs/sdk-js";
-function validateAmountMeetsMinBridgeAmount({
-  amount,
-  minBridgeAmount
-}) {
-  return amount >= hexToBigInt2(minBridgeAmount);
-}
-
-// src/services/validation/validateBridgeEstimateExact.ts
-import { hexToBigInt as hexToBigInt6, isUndefined } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/sdk-js";
-
-// src/services/evm/asChainId.ts
-import { asHex as asHex2 } from "@xylabs/sdk-js";
-var asChainId = (value) => {
-  const chainId = asHex2(value);
-  return chainId;
-};
-
-// src/services/evm/asToken.ts
-import { asAddress } from "@xylabs/sdk-js";
-var asToken = (value) => {
-  const token = asAddress(value);
-  return token;
-};
-
-// src/services/evm/getBridgeEscrowAddress.ts
-import { asAddress as asAddress2, assertEx as assertEx5 } from "@xylabs/sdk-js";
-var tryGetBridgeEscrowAddress = (config) => {
-  const address = asAddress2(config.escrowAddress);
-  return address;
-};
-
-// src/services/evm/getBridgeFeesAddress.ts
-import { asAddress as asAddress3, assertEx as assertEx6 } from "@xylabs/sdk-js";
-var tryGetBridgeFeesAddress = (config) => {
-  const address = asAddress3(config.feesAddress);
-  return address;
-};
-
-// src/services/evm/getFeeStructure.ts
-var getFeeStructure = (config) => {
-  const { feeFixed, feeRateBasisPoints } = config;
-  return { feeFixed, feeRateBasisPoints };
-};
-
-// src/services/evm/getMaxBridgeAmount.ts
-var getMaxBridgeAmount = (config) => {
-  const { maxBridgeAmount } = config;
-  return maxBridgeAmount;
-};
-
-// src/services/evm/getMinBridgeAmount.ts
-var getMinBridgeAmount = (config) => {
-  const { minBridgeAmount } = config;
-  return minBridgeAmount;
-};
-
-// src/services/evm/getRemoteChainId.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
-var getRemoteChainId = (config) => {
-  const remoteChainId = assertEx7(asChainId(config.remoteChainId), () => "Invalid remote chain ID in config");
-  return remoteChainId;
-};
-
-// src/services/evm/getRemoteTokenAddress.ts
-import { assertEx as assertEx8 } from "@xylabs/sdk-js";
-var getRemoteTokenAddress = (config) => {
-  const token = asToken(config.remoteTokenAddress);
-  return assertEx8(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 = 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;
-};
-
-// src/services/evm/getTransferAddresses.ts
-var getTransferAddresses = async (config) => {
-  const escrowAddress = tryGetBridgeEscrowAddress(config) ?? (await getBridgeWalletAccount(config)).address;
-  const feesAddress = tryGetBridgeFeesAddress(config) ?? (await getBridgeWalletAccount(config)).address;
-  return { escrowAddress, feesAddress };
-};
-
-// src/services/evm/getXl1ChainId.ts
-import { assertEx as assertEx9, isDefined as isDefined4 } from "@xylabs/sdk-js";
-var getXl1ChainId = (config) => {
-  const xl1ChainId = config.xl1ChainId;
-  if (isDefined4(xl1ChainId)) {
-    return assertEx9(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
-  }
-  return assertEx9(asChainId(config.chain.id), () => "Invalid chain.id in config");
-};
-
-// src/services/evm/getXl1TokenAddress.ts
-import { isDefined as isDefined5 } from "@xylabs/sdk-js";
-var getXl1TokenAddress = (config) => {
-  const token = asToken(config.xl1TokenAddress);
-  if (isDefined5(token)) return token;
-  return getXl1ChainId(config);
-};
+var EthToXl1BridgeParent = {
+  createWorker: createWorker2,
+  name: name2,
+  queueName: queueName2
+};
 
-// src/services/evm/getBridgeSettings.ts
-var getBridgeSettings = async (config) => {
-  const { feeFixed, feeRateBasisPoints } = getFeeStructure(config);
-  const { feesAddress, escrowAddress } = await getTransferAddresses(config);
-  const maxBridgeAmount = getMaxBridgeAmount(config);
-  const minBridgeAmount = getMinBridgeAmount(config);
-  const remoteChainId = getRemoteChainId(config);
-  const remoteTokenAddress = getRemoteTokenAddress(config);
-  const xl1TokenAddress = getXl1TokenAddress(config);
-  const xl1ChainId = getXl1ChainId(config);
-  return {
-    feeFixed,
-    feeRateBasisPoints,
-    feesAddress,
-    escrowAddress,
-    maxBridgeAmount,
-    minBridgeAmount,
-    remoteChainId,
-    remoteTokenAddress,
-    xl1TokenAddress,
-    xl1ChainId
-  };
+// 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/evm/getRemoteConfirmationDepth.ts
-import { isDefined as isDefined6, toHex as toHex3 } from "@xylabs/sdk-js";
-var HARDHAT_CHAIN_ID = toHex3("0x7a69");
-var ETHEREUM_MAINNET_CHAIN_ID = toHex3("0x1");
-var FALLBACK_CONFIRMATION_DEPTH = 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 = toHex3(getRemoteChainId(config));
-  return DEFAULT_CONFIRMATION_DEPTH_BY_CHAIN_ID.get(chainId) ?? FALLBACK_CONFIRMATION_DEPTH;
-}
+// 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/evm/getScannerIntervalMs.ts
-function getScannerIntervalMs(config) {
-  return config.scannerIntervalMs;
+// src/services/validation/validateAmountMeetsMinBridgeAmount.ts
+import { hexToBigInt as hexToBigInt4 } from "@xylabs/sdk-js";
+function validateAmountMeetsMinBridgeAmount({
+  amount,
+  minBridgeAmount
+}) {
+  return amount >= hexToBigInt4(minBridgeAmount);
 }
 
-// src/services/util/calculateBridgeFees.ts
-import { hexToBigInt as hexToBigInt3, toHex as toHex4 } from "@xylabs/sdk-js";
-var calculateBridgeFees = (srcAmount, feeStructure) => {
-  const { feeFixed, feeRateBasisPoints } = feeStructure;
-  const srcAmountBigInt = hexToBigInt3(srcAmount);
-  const feeVariableBigInt = srcAmountBigInt * BigInt(feeRateBasisPoints) / 10000n;
-  const feeVariable = toHex4(feeVariableBigInt);
-  return {
-    feeFixed,
-    feeVariable,
-    srcAmount
-  };
-};
-
-// src/services/util/calculateMaxBridgeAmount.ts
-import { hexToBigInt as hexToBigInt4, toHex as toHex5 } from "@xylabs/sdk-js";
-var calculateMaxBridgeAmount = (balance, feeStructure) => {
-  const { feeFixed, feeRateBasisPoints } = feeStructure;
-  const balanceBigInt = hexToBigInt4(balance);
-  const feeFixedBigInt = hexToBigInt4(feeFixed);
-  if (balanceBigInt <= feeFixedBigInt) return toHex5(0n);
-  const maxAmount = (balanceBigInt - feeFixedBigInt) * 10000n / (10000n + BigInt(feeRateBasisPoints));
-  return toHex5(maxAmount);
-};
-
-// src/services/util/createBridgeTransfer.ts
-import { hexToBigInt as hexToBigInt5 } from "@xylabs/sdk-js";
-import { createTransferPayload as createTransferPayload2 } from "@xyo-network/xl1-sdk";
-var createBridgeTransfer = (sender, srcAmount, escrowAddress, feesAddress, context) => {
-  const { feeFixed, feeVariable } = context;
-  const escrowAmount = hexToBigInt5(srcAmount);
-  const feesAmount = hexToBigInt5(feeFixed) + hexToBigInt5(feeVariable);
-  const transfers = escrowAddress === feesAddress ? { [feesAddress]: escrowAmount + feesAmount } : { [escrowAddress]: escrowAmount, [feesAddress]: feesAmount };
-  const transfer = createTransferPayload2(sender, transfers, context);
-  return transfer;
-};
+// 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 { toAddress as toAddress2 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
-import { BridgeIntentSchema as BridgeIntentSchema2 } from "@xyo-network/xl1-sdk";
-import { v4 } from "uuid";
+import { generateBridgeEstimate as generateBridgeEstimateShared } from "@xyo-network/chain-bridge-shared";
 var generateBridgeEstimate = async (srcAddress, srcAmount, destAddress, config, nonceOverride) => {
-  const {
-    escrowAddress,
-    feeFixed,
-    feeRateBasisPoints,
-    feesAddress,
-    remoteChainId,
-    remoteTokenAddress,
-    xl1ChainId,
-    xl1TokenAddress
-  } = await getBridgeSettings(config);
-  const sender = toAddress2(srcAddress);
-  const fees = calculateBridgeFees(srcAmount, { feeFixed, feeRateBasisPoints });
-  const nonce = nonceOverride ?? v4();
-  const bridgeIntentFields = {
-    // Source
-    src: xl1ChainId,
-    srcAddress: sender,
-    srcAmount,
-    srcToken: xl1TokenAddress,
-    // Destination
-    dest: remoteChainId,
-    destAddress,
-    destAmount: srcAmount,
-    // This is a 1:1 bridge. Fees are handled at the transfer level, not the bridge intent level.
-    destToken: remoteTokenAddress,
-    nonce
-  };
-  const bridgeIntent = new PayloadBuilder5({ schema: BridgeIntentSchema2 }).fields(bridgeIntentFields).build();
-  const transfer = createBridgeTransfer(sender, srcAmount, escrowAddress, feesAddress, fees);
-  return [bridgeIntent, transfer];
+  const settings = await getBridgeSettings(config);
+  return generateBridgeEstimateShared(srcAddress, srcAmount, destAddress, settings, nonceOverride);
 };
 
 // src/services/validation/validateBridgeEstimateExact.ts
@@ -597,16 +933,16 @@ var validateBridgeEstimateExact = async (intent, transfer, config) => {
     srcAmount,
     destAddress
   } = intent;
-  if (hexToBigInt6(srcAmount) < hexToBigInt6(getMinBridgeAmount(config))) return false;
-  if (hexToBigInt6(srcAmount) > hexToBigInt6(getMaxBridgeAmount(config))) return false;
+  if (hexToBigInt5(srcAmount) < hexToBigInt5(getMinBridgeAmount(config))) return false;
+  if (hexToBigInt5(srcAmount) > hexToBigInt5(getMaxBridgeAmount(config))) return false;
   const [calculatedIntent, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
   if (isUndefined(calculatedIntent) || isUndefined(calculatedTransfer)) return false;
   const { nonce: expectedIntentNonce, ...expectedIntentStatic } = calculatedIntent;
   const { nonce: actualIntentNonce, ...actualIntentStatic } = intent;
-  if (await PayloadBuilder6.dataHash(expectedIntentStatic) !== await PayloadBuilder6.dataHash(actualIntentStatic)) return false;
+  if (await PayloadBuilder5.dataHash(expectedIntentStatic) !== await PayloadBuilder5.dataHash(actualIntentStatic)) return false;
   const { epoch: expectedTransferEpoch, ...expectedTransferStatic } = calculatedTransfer;
   const { epoch: actualTransferEpoch, ...actualTransferStatic } = transfer;
-  if (await PayloadBuilder6.dataHash(expectedTransferStatic) !== await PayloadBuilder6.dataHash(actualTransferStatic)) return false;
+  if (await PayloadBuilder5.dataHash(expectedTransferStatic) !== await PayloadBuilder5.dataHash(actualTransferStatic)) return false;
   return true;
 };
 
@@ -618,15 +954,15 @@ import {
   payloadHashesContainsAll,
   payloadSchemasContainsAll
 } from "@xyo-network/boundwitness-validator";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/sdk-js";
-import { BridgeIntentSchema as BridgeIntentSchema3, TransferSchema } from "@xyo-network/xl1-sdk";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/sdk-js";
+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 PayloadBuilder7.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;
@@ -636,12 +972,12 @@ var validateBridgeTransaction = async (signedTxBw, intent, transfer, config) =>
 };
 
 // src/services/validation/validateSufficientLiquiditySourceAllowance.ts
-import { assertEx as assertEx10, hexToBigInt as hexToBigInt7 } from "@xylabs/sdk-js";
-import { isBridgeIntent as isBridgeIntent2 } from "@xyo-network/xl1-sdk";
+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(isBridgeIntent2), () => "No bridge intent found");
-  const amount = hexToBigInt7(bridgeIntent.destAmount);
+  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);
@@ -650,12 +986,12 @@ var validateSufficientLiquiditySourceAllowance = async (tx, offChainPayloads, br
 };
 
 // src/services/validation/validateSufficientLiquiditySourceBalance.ts
-import { assertEx as assertEx11, hexToBigInt as hexToBigInt8 } from "@xylabs/sdk-js";
-import { isBridgeIntent as isBridgeIntent3 } from "@xyo-network/xl1-sdk";
+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(isBridgeIntent3), () => "No bridge intent found");
-  const amount = hexToBigInt8(bridgeIntent.destAmount);
+  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()}`);
@@ -690,6 +1026,8 @@ var validateSufficientRunnerEthBalanceForGas = async (preparedTx, wallet, logger
 
 // src/services/validation/validateSufficientXl1ReserveBalance.ts
 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,
@@ -698,15 +1036,18 @@ async function validateSufficientXl1ReserveBalance({
 }) {
   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;
 }
 
 // src/services/validation/validateSufficientXL1SourceAddressBalance.ts
 import {
   asAddress as asAddress5,
   assertEx as assertEx14,
-  hexToBigInt as hexToBigInt9
+  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");
@@ -717,7 +1058,7 @@ var validateSufficientXL1SourceAddressBalance = async (bridgeIntent, gateway, co
   } = 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 + hexToBigInt9(transfer), 0n);
+  const totalAmount = Object.values(calculatedTransfer.transfers).reduce((acc, transfer) => acc + hexToBigInt8(transfer), 0n);
   const accountBalance = await viewer.account.balance.accountBalance(srcAddressBranded);
   await logger?.log(`Account balance for ${srcAddressBranded}: ${accountBalance.toString()}`);
   return accountBalance >= totalAmount;
@@ -731,41 +1072,44 @@ var createWorker4 = (connection2, telemetry2, services) => {
   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) => {
-      const { tx, offChainPayloads } = job.data;
-      const hash = await PayloadBuilder8.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(isBridgeIntent4), () => "No bridge intent found");
-      const amount = hexToBigInt10(bridgeIntent.destAmount);
-      const srcAddress = getAddress(bridgeIntent.srcAddress);
-      const destAddress = getAddress(bridgeIntent.destAddress);
-      const nonce = hexToBigInt10(await PayloadBuilder8.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 {};
+      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,
@@ -774,10 +1118,10 @@ var createWorker4 = (connection2, telemetry2, services) => {
     }
   );
   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}`);
   });
 };
 var EthTransactionPreparation = {
@@ -787,8 +1131,12 @@ var EthTransactionPreparation = {
 };
 
 // src/services/queue/workers/EthTransactionSubmission.ts
-import { assertEx as assertEx16, isDefined as isDefined7 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/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";
@@ -796,21 +1144,24 @@ 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) => {
-      const { tx, offChainPayloads } = 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 (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 };
+      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,
@@ -820,10 +1171,10 @@ var createWorker5 = (connection2, telemetry2, services) => {
     }
   );
   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}`);
   });
 };
 var EthTransactionSubmission = {
@@ -833,34 +1184,41 @@ var EthTransactionSubmission = {
 };
 
 // src/services/queue/workers/EthTransactionSubmissionStorage.ts
-import { assertEx as assertEx17, isDefined as isDefined8 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/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 = (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) => {
-      const { tx } = job.data;
-      const hash = await PayloadBuilder10.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 };
+      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,
@@ -869,10 +1227,10 @@ var createWorker6 = (connection2, telemetry2, services) => {
     }
   );
   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}`);
   });
 };
 var EthTransactionSubmissionStorage = {
@@ -885,19 +1243,43 @@ var EthTransactionSubmissionStorage = {
 import {
   assertEx as assertEx18,
   delay,
-  hexToBigInt as hexToBigInt11,
+  hexToBigInt as hexToBigInt10,
   isDefined as isDefined9,
   isNull as isNull2,
-  toHex as toHex6
+  spanAsync as spanAsync10
 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/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,
@@ -909,9 +1291,7 @@ async function tryResumeCurrentAttempt(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;
   }
@@ -939,9 +1319,9 @@ async function buildAndSubmitFreshAttempt(ctx) {
     xl1ChainId,
     xl1TokenAddress
   } = ctx;
-  const canonical = assertEx18(state.canonical, () => "buildAndSubmitFreshAttempt requires canonical");
-  const fees = calculateBridgeFees(toHex6(canonical.amount), getFeeStructure(config));
-  const feesAmount = hexToBigInt11(fees.feeFixed) + hexToBigInt11(fees.feeVariable);
+  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,
@@ -949,9 +1329,9 @@ async function buildAndSubmitFreshAttempt(ctx) {
     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);
@@ -973,7 +1353,7 @@ async function buildAndSubmitFreshAttempt(ctx) {
     xl1ChainId,
     xl1TokenAddress
   });
-  const txHash = await PayloadBuilder11.hash(tx[0]);
+  const txHash = await PayloadBuilder10.hash(tx[0]);
   state.currentAttempt = {
     exp: head + EXP_BLOCKS_AHEAD,
     nbf: head,
@@ -988,6 +1368,7 @@ async function buildAndSubmitFreshAttempt(ctx) {
 }
 async function pollUntilIncludedOrExpired(ctx) {
   const {
+    bridgeFlowMetrics,
     fulfillmentMap,
     identity,
     job,
@@ -998,9 +1379,7 @@ async function pollUntilIncludedOrExpired(ctx) {
   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;
     }
@@ -1009,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);
@@ -1020,68 +1400,65 @@ var createWorker7 = (connection2, telemetry2, services) => {
   const svc = assertEx18(services, () => "services not provided");
   const {
     account,
+    bridgeFlowMetrics,
     bridgeFulfillmentMap,
     config,
-    gateway
+    gateway,
+    logger
   } = 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 = 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`);
-      if (state.failed) {
-        state.failed = void 0;
-        await bridgeFulfillmentMap.set(identity, state);
-      }
-      const minBridgeAmount = getMinBridgeAmount(config);
-      if (!validateAmountMeetsMinBridgeAmount({ amount: canonical.amount, minBridgeAmount })) {
-        state.failed = {
-          at: Date.now(),
-          reason: `below_min_bridge_amount: amount=${canonical.amount} minBridgeAmount=${minBridgeAmount}`
-        };
-        await bridgeFulfillmentMap.set(identity, state);
-        await job.log(`[${identity}] amount ${canonical.amount} below minBridgeAmount ${minBridgeAmount}; terminal`);
-        return;
-      }
-      const viewer = assertEx18(gateway.connection.viewer, () => `[${identity}] gateway viewer not available`);
-      const ctx = {
-        fulfillmentMap: bridgeFulfillmentMap,
-        identity,
-        job,
-        state,
-        viewer
-      };
-      if (state.currentAttempt) {
-        await tryResumeCurrentAttempt(ctx);
-        if (state.fulfilled) return;
-      }
-      if (!state.currentAttempt) {
-        await buildAndSubmitFreshAttempt({
-          ...ctx,
-          account,
-          bridgeId: BigInt(bridgeId),
-          config,
+      await spanAsync10("bridge:worker:eth-to-xl1-fulfill", async () => {
+        const {
+          bridgeId,
           contractAddress,
           evmChainId,
-          gateway,
+          identity,
           xl1ChainId,
           xl1TokenAddress
-        });
-      }
-      await pollUntilIncludedOrExpired(ctx);
+        } = 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,
@@ -1090,22 +1467,16 @@ var createWorker7 = (connection2, telemetry2, services) => {
       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("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) });
+    }
   });
   worker.on("error", (err) => {
-    console.error(`[${name7}] Worker error:`, err);
+    logger.error(`[xl1-fulfill] worker error: ${err.message}`);
   });
 };
 var Xl1ReserveTxFulfillment = {
@@ -1115,16 +1486,20 @@ 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 = (connection2, telemetry2) => {
+var createWorker8 = (connection2, telemetry2, services) => {
+  const logger = assertEx19(services?.logger, () => "logger service not provided");
   const worker = new Worker8(
     queueName8,
     async (job) => {
-      await job.log(`[${job.name}] start`);
-      await job.log(`[${job.name}] done`);
-      return {};
+      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,
@@ -1133,10 +1508,10 @@ var createWorker8 = (connection2, telemetry2) => {
     }
   );
   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}`);
   });
 };
 var Xl1ToEthBridgeParent = {
@@ -1147,41 +1522,45 @@ var Xl1ToEthBridgeParent = {
 
 // src/services/queue/workers/Xl1TransactionMonitor.ts
 import {
-  assertEx as assertEx19,
+  assertEx as assertEx20,
   isDefined as isDefined10,
-  isNull as isNull3
+  isNull as isNull3,
+  spanAsync as spanAsync12
 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/sdk-js";
-import { UnrecoverableError as UnrecoverableError2, Worker as Worker9 } from "bullmq";
+import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
+import { UnrecoverableError as UnrecoverableError3, Worker as Worker9 } from "bullmq";
 var name9 = "Monitor Submitted XL1 Transaction";
 var queueName9 = "xl1-tx-monitor";
 var createWorker9 = (connection2, telemetry2, services) => {
-  const gateway = assertEx19(services?.gateway, () => "gateway service not provided");
-  const stateMap = assertEx19(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
-  const viewer = assertEx19(gateway.connection.viewer, () => "viewer not defined on gateway");
+  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) => {
-      const { tx } = job.data;
-      const hash = await PayloadBuilder12.hash(tx[0]);
-      const state = assertEx19(await stateMap.get(hash), () => `[${hash}] state not found`);
-      const submissionHash = assertEx19(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 PayloadBuilder12.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`);
-      }
-      await job.log(`[${hash}] Transaction not yet included, retrying later`);
-      throw new Error(`[${hash}] Transaction not yet included`);
+      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,
@@ -1190,10 +1569,10 @@ var createWorker9 = (connection2, telemetry2, services) => {
     }
   );
   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}`);
   });
 };
 var Xl1TransactionMonitor = {
@@ -1203,25 +1582,28 @@ var Xl1TransactionMonitor = {
 };
 
 // src/services/queue/workers/Xl1TransactionPreparation.ts
-import { assertEx as assertEx20 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/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 = (connection2, telemetry2, services) => {
-  const stateMap = assertEx20(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  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) => {
-      const { tx, offChainPayloads = [] } = job.data;
-      const hash = await PayloadBuilder13.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 };
+      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,
@@ -1230,10 +1612,10 @@ var createWorker10 = (connection2, telemetry2, services) => {
     }
   );
   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}`);
   });
 };
 var Xl1TransactionPreparation = {
@@ -1243,34 +1625,41 @@ var Xl1TransactionPreparation = {
 };
 
 // src/services/queue/workers/Xl1TransactionSubmission.ts
-import { assertEx as assertEx21, isDefined as isDefined11 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/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 = (connection2, telemetry2, services) => {
-  const gateway = assertEx21(services?.gateway, () => "gateway service not provided");
-  const stateMap = assertEx21(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  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) => {
-      const { tx } = job.data;
-      const hash = await PayloadBuilder14.hash(tx[0]);
-      const state = assertEx21(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 = assertEx21(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 };
+      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,
@@ -1279,10 +1668,10 @@ var createWorker11 = (connection2, telemetry2, services) => {
     }
   );
   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}`);
   });
 };
 var Xl1TransactionSubmission = {
@@ -1292,34 +1681,41 @@ var Xl1TransactionSubmission = {
 };
 
 // src/services/queue/workers/Xl1TransactionSubmissionStorage.ts
-import { assertEx as assertEx22, isDefined as isDefined12 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/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 = (connection2, telemetry2, services) => {
-  const stateMap = assertEx22(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
+  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) => {
-      const { tx } = job.data;
-      const hash = await PayloadBuilder15.hash(tx[0]);
-      const state = assertEx22(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 = assertEx22(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 };
+      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,
@@ -1328,10 +1724,10 @@ var createWorker12 = (connection2, telemetry2, services) => {
     }
   );
   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}`);
   });
 };
 var Xl1TransactionSubmissionStorage = {
@@ -1343,13 +1739,13 @@ var Xl1TransactionSubmissionStorage = {
 // src/services/queue/workers/createWorkers.ts
 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);
@@ -1357,8 +1753,9 @@ var createWorkers = (connection2, telemetry2, services) => {
 };
 
 // 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);
 }
 
 // src/services/queue/flows/createEthToXl1BridgeJob/createEthToXl1BridgeJob.ts
@@ -1406,9 +1803,9 @@ var createEthToXl1BridgeJob = async (flowProducer2, context) => {
 };
 
 // src/services/queue/flows/createXl1ToEthBridgeJob/getJobIdForXl1ToEthBridgeJob.ts
-import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/sdk-js";
 var getJobIdForXl1ToEthBridgeJob = async (tx) => {
-  const jobId = await PayloadBuilder16.hash(tx[0]);
+  const jobId = await PayloadBuilder15.hash(tx[0]);
   return jobId;
 };
 
@@ -1594,6 +1991,107 @@ var getXl1ToEthQueues = (config) => {
   return xl1ToEthQueues;
 };
 
+// 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 {
@@ -1631,6 +2129,7 @@ function createEvmBridgeScanner(options2) {
     chainId,
     confirmationDepth,
     cursors,
+    deployBlock,
     enqueue,
     provider
   } = options2;
@@ -1638,11 +2137,16 @@ function createEvmBridgeScanner(options2) {
   return {
     async scan(options3) {
       const jobLog = options3?.jobLog;
-      const blockTag = await resolveEvmBlockTagAtDepth(provider, confirmationDepth);
+      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,
@@ -1654,7 +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,
@@ -1665,6 +2169,7 @@ function createEvmBridgeScanner(options2) {
 }
 
 // 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";
@@ -1673,10 +2178,10 @@ function createEvmBridgeScannerRunner(options2) {
   const {
     connection: connection2,
     intervalMs,
+    logger,
     scanner,
     telemetry: telemetry2
   } = options2;
-  const logger = options2.logger ?? console;
   let queue;
   let worker;
   return {
@@ -1687,21 +2192,23 @@ function createEvmBridgeScannerRunner(options2) {
         telemetry: telemetry2
       });
       worker = new Worker13(QUEUE_NAME, async (job) => {
-        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()}`
-        );
+        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,
@@ -1723,7 +2230,6 @@ function buildEvmBridgeScannerRunner(options2) {
     config,
     connection: connection2,
     flowProducer: flowProducer2,
-    logger,
     services,
     telemetry: telemetry2
   } = options2;
@@ -1745,13 +2251,14 @@ 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
   });
@@ -1825,8 +2332,7 @@ var addProbeRoutes = (app) => {
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts
 import { requestHandlerValidator } from "@xylabs/express";
-import { BridgeSettingsZod } from "@xyo-network/chain-orchestration";
-var BridgeConfigResponseZod = BridgeSettingsZod;
+import { BridgeConfigResponseZod } from "@xyo-network/chain-bridge-shared";
 var validateRequest = requestHandlerValidator({ response: BridgeConfigResponseZod });
 var makeBridgeConfigRoute = (config) => {
   return {
@@ -1865,54 +2371,37 @@ var makeBridgeConfigRoute = (config) => {
 // src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteEstimate.ts
 import { requestHandlerValidator as requestHandlerValidator2 } from "@xylabs/express";
 import {
-  assertEx as assertEx23,
-  hexToBigInt as hexToBigInt12,
-  toAddress as toAddress3
+  assertEx as assertEx24,
+  hexToBigInt as hexToBigInt11,
+  toAddress as toAddress2
 } from "@xylabs/sdk-js";
-import { PayloadZodStrictOfSchema } from "@xyo-network/sdk-js";
 import {
-  BridgeIntentFieldsZod,
-  BridgeIntentSchema as BridgeIntentSchema4,
-  buildUnsignedTransaction,
-  toXL1BlockNumber,
-  TransactionBoundWitnessZod,
-  TransferZod
-} from "@xyo-network/xl1-sdk";
-import { z } from "zod";
+  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
+  isDefined as isDefined14
 } from "@xylabs/sdk-js";
+import { z } from "zod/mini";
 var getRemoteChainIdZod = (config) => {
   const remoteChainId = getRemoteChainId(config);
-  return HexZod.superRefine((val, ctx) => {
-    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 HexZod.check(z.refine((val) => {
+    const chainId = asHex3(val);
+    return isDefined14(chainId) && chainId === remoteChainId;
+  }, { error: `Only ${remoteChainId} is supported` }));
 };
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteEstimate.ts
-var BridgeFromRemoteEstimateBodyZod = BridgeIntentFieldsZod.pick({
-  destAddress: true,
-  srcAddress: true,
-  srcAmount: true
-});
-var BridgeFromRemoteEstimateResponseZod = z.tuple([
-  TransactionBoundWitnessZod,
-  PayloadZodStrictOfSchema(BridgeIntentSchema4).extend(BridgeIntentFieldsZod.shape),
-  TransferZod
-]);
 var makeBridgeFromRemoteEstimateRoute = (config) => {
-  const params = z.object({ chainId: getRemoteChainIdZod(config) });
+  const params = z2.object({ chainId: getRemoteChainIdZod(config) });
   const validateRequest2 = requestHandlerValidator2({
     params,
     body: BridgeFromRemoteEstimateBodyZod,
@@ -1934,12 +2423,12 @@ var makeBridgeFromRemoteEstimateRoute = (config) => {
         destAddress
       } = req.body;
       const { maxBridgeAmount, minBridgeAmount } = await getBridgeSettings(config);
-      if (hexToBigInt12(srcAmount) < hexToBigInt12(minBridgeAmount) || hexToBigInt12(srcAmount) > hexToBigInt12(maxBridgeAmount)) {
+      if (hexToBigInt11(srcAmount) < hexToBigInt11(minBridgeAmount) || hexToBigInt11(srcAmount) > hexToBigInt11(maxBridgeAmount)) {
         res.status(400).send();
         return;
       }
-      const fees = calculateBridgeFees(srcAmount, getFeeStructure(config));
-      const feesAmount = hexToBigInt12(fees.feeFixed) + hexToBigInt12(fees.feeVariable);
+      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;
@@ -1948,18 +2437,18 @@ var makeBridgeFromRemoteEstimateRoute = (config) => {
       const evmChainId = config.remoteChainId;
       const evmContractAddress = config.remoteBridgeContractAddress;
       const evmTokenAddress = getRemoteTokenAddress(config);
-      const viewer = assertEx23(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      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 } = buildEthToXl1BridgePayloads({
-        amount: hexToBigInt12(srcAmount),
+      const { intent, transfer } = buildEthToXl1BridgePayloads3({
+        amount: hexToBigInt11(srcAmount),
         bridgeAccountAddress: account.address,
         bridgeId: projectedBridgeId,
-        destAddress: toAddress3(destAddress),
+        destAddress: toAddress2(destAddress),
         evmChainId,
         evmContractAddress,
-        evmSrcAddress: toAddress3(srcAddress),
+        evmSrcAddress: toAddress2(srcAddress),
         evmTokenAddress,
         feesAddress,
         feesAmount,
@@ -1972,71 +2461,104 @@ var makeBridgeFromRemoteEstimateRoute = (config) => {
   };
 };
 
-// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
+// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteRetry.ts
 import { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
-import {
-  hexToBigInt as hexToBigInt13,
-  isDefined as isDefined14,
-  toHex as toHex7
-} from "@xylabs/sdk-js";
-import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/sdk-js";
-import {
-  BridgeDestinationObservationFieldsZod,
-  BridgeDestinationObservationSchema,
-  BridgeIntentFieldsZod as BridgeIntentFieldsZod2,
-  BridgeIntentSchema as BridgeIntentSchema5,
-  BridgeSourceObservationFieldsZod,
-  BridgeSourceObservationSchema as BridgeSourceObservationSchema2
-} from "@xyo-network/xl1-sdk";
-import { z as z2 } from "zod";
-var BridgeIntentResponseZod = PayloadZodStrictOfSchema2(BridgeIntentSchema5).extend(BridgeIntentFieldsZod2.shape);
-var BridgeSourceResponseZod = PayloadZodStrictOfSchema2(BridgeSourceObservationSchema2).extend(BridgeSourceObservationFieldsZod.shape);
-var BridgeDestinationResponseZod = PayloadZodStrictOfSchema2(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape);
-var BridgeFromRemoteStatusResponseZod = z2.union([
-  z2.tuple([]),
-  z2.tuple([BridgeIntentResponseZod]),
-  z2.tuple([BridgeIntentResponseZod, BridgeSourceResponseZod]),
-  z2.tuple([BridgeIntentResponseZod, BridgeSourceResponseZod, BridgeDestinationResponseZod])
-]);
-function buildIntentAndSource(ctx) {
-  const {
-    canonical,
-    config,
-    nonce
-  } = ctx;
-  const srcAmountHex = toHex7(canonical.amount);
-  const fees = calculateBridgeFees(srcAmountHex, getFeeStructure(config));
-  const feesAmount = hexToBigInt13(fees.feeFixed) + hexToBigInt13(fees.feeVariable);
-  const destAmountHex = toHex7(canonical.amount - feesAmount);
-  const xl1ChainId = getXl1ChainId(config);
-  const xl1TokenAddress = getXl1TokenAddress(config);
-  const evmChainId = config.remoteChainId;
-  const evmTokenAddress = getRemoteTokenAddress(config);
-  const intentFields = BridgeIntentFieldsZod2.parse({
-    dest: xl1ChainId,
-    destAddress: canonical.destAddress,
-    destAmount: destAmountHex,
-    destToken: xl1TokenAddress,
-    nonce,
-    src: evmChainId,
-    srcAddress: canonical.srcAddress,
-    srcAmount: srcAmountHex,
-    srcToken: evmTokenAddress
+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 intent = { schema: BridgeIntentSchema5, ...intentFields };
-  const sourceFields = BridgeSourceObservationFieldsZod.parse({
-    ...intentFields,
-    srcConfirmation: canonical.evmTxHash
+  const validateRequest2 = requestHandlerValidator3({
+    params,
+    body: BridgeRetryBodyZod,
+    response: BridgeRetryResponseZod
   });
-  const source = { schema: BridgeSourceObservationSchema2, ...sourceFields };
-  return [intent, source];
-}
+  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);
+    })
+  };
+};
+
+// 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
+  });
+  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);
+    })
+  };
+};
+
+// 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 = z2.object({
+  const params = z5.object({
     chainId: getRemoteChainIdZod(config),
-    nonce: z2.string().regex(/^\d+$/, "nonce must be a non-negative integer (the bridge contract's id)")
+    nonce: z5.string().check(z5.regex(/^\d+$/, { error: "nonce must be a non-negative integer (the bridge contract's id)" }))
   });
-  const validateRequest2 = requestHandlerValidator3({ params, response: BridgeFromRemoteStatusResponseZod });
+  const validateRequest2 = requestHandlerValidator5({ params, response: BridgeFromRemoteStatusResponseZod });
   return {
     method: "get",
     path: "/bridge/chains/:chainId/bridgeFromRemote/status/:nonce",
@@ -2051,55 +2573,77 @@ var makeBridgeFromRemoteStatusRoute = (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
-      });
+      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 destinationFields = BridgeDestinationObservationFieldsZod.parse({
-        ...intent,
-        destConfirmation: state.fulfilled.txHash
-      });
-      const destination = { schema: BridgeDestinationObservationSchema, ...destinationFields };
+      const destination = assertEx25(state.acceptedDestinationObservation, () => `[${identity}] acceptedDestinationObservation missing despite fulfilled \u2014 stale state`);
       res.json([intent, source, destination]);
     })
   };
 };
 
+// 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 = 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 requestHandlerValidator4 } from "@xylabs/express";
-import { isDefined as isDefined15 } from "@xylabs/sdk-js";
-import {
-  PayloadBuilder as PayloadBuilder17,
-  PayloadZodLooseOfSchema,
-  PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3
-} from "@xyo-network/sdk-js";
-import {
-  BridgeIntentFieldsZod as BridgeIntentFieldsZod3,
-  BridgeIntentSchema as BridgeIntentSchema6,
-  BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod2,
-  BridgeSourceObservationSchema as BridgeSourceObservationSchema3,
-  SignedTransactionBoundWitnessZod,
-  TransferZod as TransferZod2
-} from "@xyo-network/xl1-sdk";
-import { z as z3 } from "zod";
-var BridgeToRemoteBodyZod = z3.tuple([
-  SignedTransactionBoundWitnessZod,
-  PayloadZodLooseOfSchema(BridgeIntentSchema6).extend(BridgeIntentFieldsZod3.shape),
-  TransferZod2
-]);
-var BridgeToRemoteResponseZod = PayloadZodStrictOfSchema3(BridgeSourceObservationSchema3).extend(BridgeSourceObservationFieldsZod2.shape);
+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 = z3.object({ chainId: getRemoteChainIdZod(config) });
-  const validateRequest2 = requestHandlerValidator4({
+  const params = z7.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator7({
     params,
     body: BridgeToRemoteBodyZod,
     response: BridgeToRemoteResponseZod
@@ -2128,16 +2672,16 @@ var makeBridgeToRemoteRoute = (config) => {
       }
       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]);
-      const srcConfirmation = await PayloadBuilder17.hash(signedTxBw);
-      const bridgeCommonFieldsZod = z3.object({}).extend(BridgeSourceObservationFieldsZod2.shape);
+      const srcConfirmation = await PayloadBuilder16.hash(signedTxBw);
+      const bridgeCommonFieldsZod = z7.object(BridgeSourceObservationFieldsZod2.shape);
       const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent);
       const bridgeObservationFields = { ...bridgeCommonFields, srcConfirmation };
-      const bridgeObservation = new PayloadBuilder17(
+      const bridgeObservation = new PayloadBuilder16(
         { schema: BridgeSourceObservationSchema3 }
       ).fields(bridgeObservationFields).build();
       res.status(202).json(bridgeObservation);
@@ -2146,35 +2690,18 @@ var makeBridgeToRemoteRoute = (config) => {
 };
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
-import { requestHandlerValidator as requestHandlerValidator5 } from "@xylabs/express";
+import { requestHandlerValidator as requestHandlerValidator8 } from "@xylabs/express";
 import {
-  assertEx as assertEx24,
-  hexToBigInt as hexToBigInt14,
-  toAddress as toAddress4
+  assertEx as assertEx27,
+  hexToBigInt as hexToBigInt12,
+  toAddress as toAddress3
 } 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 BridgeToRemoteEstimateBodyZod = BridgeIntentFieldsZod4.pick({
-  destAddress: true,
-  srcAddress: true,
-  srcAmount: true
-});
-var BridgeToRemoteEstimateResponseZod = z4.tuple([
-  TransactionBoundWitnessZod2,
-  PayloadZodStrictOfSchema4(BridgeIntentSchema7).extend(BridgeIntentFieldsZod4.shape),
-  TransferZod3
-]);
+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 = z4.object({ chainId: getRemoteChainIdZod(config) });
-  const validateRequest2 = requestHandlerValidator5({
+  const params = z8.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator8({
     params,
     body: BridgeToRemoteEstimateBodyZod,
     response: BridgeToRemoteEstimateResponseZod
@@ -2190,13 +2717,13 @@ var makeBridgeToRemoteEstimateRoute = (config, gateway) => {
         destAddress
       } = req.body;
       const { maxBridgeAmount, minBridgeAmount } = await getBridgeSettings(config);
-      if (hexToBigInt14(srcAmount) < hexToBigInt14(minBridgeAmount) || hexToBigInt14(srcAmount) > hexToBigInt14(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 = toAddress4(srcAddress);
-      const viewer = assertEx24(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const sender = toAddress3(srcAddress);
+      const viewer = assertEx27(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);
@@ -2207,36 +2734,23 @@ var makeBridgeToRemoteEstimateRoute = (config, gateway) => {
 };
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteMaxEstimate.ts
-import { requestHandlerValidator as requestHandlerValidator6 } from "@xylabs/express";
+import { requestHandlerValidator as requestHandlerValidator9 } from "@xylabs/express";
 import {
-  assertEx as assertEx25,
-  hexToBigInt as hexToBigInt15,
-  toAddress as toAddress5,
-  toHex as toHex8
+  assertEx as assertEx28,
+  hexToBigInt as hexToBigInt13,
+  toAddress as toAddress4,
+  toHex as toHex4
 } from "@xylabs/sdk-js";
-import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema5 } from "@xyo-network/sdk-js";
 import {
-  BridgeIntentFieldsZod as BridgeIntentFieldsZod5,
-  BridgeIntentSchema as BridgeIntentSchema8,
-  buildUnsignedTransaction as buildUnsignedTransaction3,
-  toXL1BlockNumber as toXL1BlockNumber3,
-  TransactionBoundWitnessZod as TransactionBoundWitnessZod3,
-  TransferZod as TransferZod4
-} from "@xyo-network/xl1-sdk";
-import { z as z5 } from "zod";
-var BridgeToRemoteMaxEstimateBodyZod = BridgeIntentFieldsZod5.pick({
-  destAddress: true,
-  srcAddress: true,
-  srcAmount: true
-});
-var BridgeToRemoteMaxEstimateResponseZod = z5.tuple([
-  TransactionBoundWitnessZod3,
-  PayloadZodStrictOfSchema5(BridgeIntentSchema8).extend(BridgeIntentFieldsZod5.shape),
-  TransferZod4
-]);
+  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 = z5.object({ chainId: getRemoteChainIdZod(config) });
-  const validateRequest2 = requestHandlerValidator6({
+  const params = z9.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator9({
     params,
     body: BridgeToRemoteMaxEstimateBodyZod,
     response: BridgeToRemoteMaxEstimateResponseZod
@@ -2257,10 +2771,10 @@ var makeBridgeToRemoteMaxEstimateRoute = (config, gateway) => {
         destAddress
       } = req.body;
       const balanceMax = calculateMaxBridgeAmount(balance, { feeFixed, feeRateBasisPoints });
-      const maxBridgeAmount = toHex8(hexToBigInt15(balanceMax) < hexToBigInt15(configMax) ? balanceMax : configMax);
+      const maxBridgeAmount = toHex4(hexToBigInt13(balanceMax) < hexToBigInt13(configMax) ? balanceMax : configMax);
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, maxBridgeAmount, destAddress, config);
-      const sender = toAddress5(srcAddress);
-      const viewer = assertEx25(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const sender = toAddress4(srcAddress);
+      const viewer = assertEx28(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
       const currentBlockNumber = await viewer.currentBlockNumber();
       const nbf = toXL1BlockNumber3(currentBlockNumber, true);
       const exp = toXL1BlockNumber3(currentBlockNumber + 1e3, true);
@@ -2270,36 +2784,110 @@ var makeBridgeToRemoteMaxEstimateRoute = (config, gateway) => {
   };
 };
 
+// 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: z10.string().check(z10.minLength(1))
+  });
+  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,
+    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 requestHandlerValidator7 } from "@xylabs/express";
-import { asHex as asHex4, isDefined as isDefined16 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder18, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema6 } from "@xyo-network/sdk-js";
+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,
-  BridgeIntentFieldsZod as BridgeIntentFieldsZod6,
-  BridgeIntentSchema as BridgeIntentSchema9,
   BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod3,
   BridgeSourceObservationSchema as BridgeSourceObservationSchema4,
-  isBridgeIntent as isBridgeIntent5
+  isBridgeIntent as isBridgeIntent7
 } from "@xyo-network/xl1-sdk";
-import { z as z6 } from "zod";
-var BridgeIntentResponseZod2 = PayloadZodStrictOfSchema6(BridgeIntentSchema9).extend(BridgeIntentFieldsZod6.shape);
-var BridgeSourceResponseZod2 = PayloadZodStrictOfSchema6(BridgeSourceObservationSchema4).extend(BridgeSourceObservationFieldsZod3.shape);
-var BridgeDestinationResponseZod2 = PayloadZodStrictOfSchema6(BridgeDestinationObservationSchema2).extend(BridgeDestinationObservationFieldsZod2.shape);
-var BridgeToRemoteStatusResponseZod = z6.union([
-  z6.tuple([]),
-  z6.tuple([BridgeIntentResponseZod2]),
-  z6.tuple([BridgeIntentResponseZod2, BridgeSourceResponseZod2]),
-  z6.tuple([BridgeIntentResponseZod2, BridgeSourceResponseZod2, BridgeDestinationResponseZod2])
-]);
+import { z as z12 } from "zod/mini";
 var makeBridgeToRemoteStatusRoute = (config) => {
-  const params = z6.object({
+  const params = z12.object({
     chainId: getRemoteChainIdZod(config),
-    nonce: z6.string().nonempty()
+    nonce: z12.string().check(z12.minLength(1))
   });
-  const validateRequest2 = requestHandlerValidator7({ params, response: BridgeToRemoteStatusResponseZod });
+  const validateRequest2 = requestHandlerValidator12({ params, response: BridgeToRemoteStatusResponseZod });
   return {
     method: "get",
     path: "/bridge/chains/:chainId/bridgeToRemote/status/:nonce",
@@ -2311,14 +2899,14 @@ var makeBridgeToRemoteStatusRoute = (config) => {
       const { tx, offChainPayloads = [] } = statusQueueJobs.xl1ToEthBridgeParentJob?.data ?? {};
       if (!tx) return res.sendStatus(404);
       const allPayloads = [...tx[1], ...offChainPayloads];
-      const bridgeIntent = allPayloads.find(isBridgeIntent5);
+      const bridgeIntent = allPayloads.find(isBridgeIntent7);
       if (!bridgeIntent) return res.sendStatus(404);
-      result[0] = asBridgeIntent(PayloadBuilder18.omitMeta(bridgeIntent));
+      result[0] = asBridgeIntent(PayloadBuilder17.omitMeta(bridgeIntent));
       const { xl1TransactionMonitorJob } = statusQueueJobs;
       const xl1MonitorState = xl1TransactionMonitorJob ? await xl1TransactionMonitorJob.getState() : void 0;
       if (xl1MonitorState === "completed") {
         const srcConfirmation = xl1TransactionMonitorJob?.returnvalue?.submissionHash;
-        if (isDefined16(srcConfirmation)) {
+        if (isDefined17(srcConfirmation)) {
           const schema = BridgeSourceObservationSchema4;
           const bridgeSourceObservationFields = BridgeSourceObservationFieldsZod3.parse(bridgeIntent);
           const observation = {
@@ -2333,7 +2921,7 @@ var makeBridgeToRemoteStatusRoute = (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 = {
@@ -2356,9 +2944,14 @@ var getRouteDefinitions = (config, gateway) => {
     makeBridgeToRemoteEstimateRoute(config, gateway),
     makeBridgeToRemoteMaxEstimateRoute(config, gateway),
     makeBridgeToRemoteRoute(config),
+    makeBridgeToRemoteRetryRoute(config),
+    makeBridgeToRemoteRetryFailedRoute(config),
     makeBridgeToRemoteStatusRoute(config),
     makeBridgeFromRemoteEstimateRoute(config),
-    makeBridgeFromRemoteStatusRoute(config)
+    makeBridgeFromRemoteRetryRoute(config),
+    makeBridgeFromRemoteRetryFailedRoute(config),
+    makeBridgeFromRemoteStatusRoute(config),
+    makeBridgeFromRemoteStatusByTxRoute(config)
   ];
 };
 
@@ -2388,10 +2981,10 @@ var getApp = (config, gateway) => {
 };
 
 // src/services/getServices.ts
-import { assertEx as assertEx26 } 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";
@@ -2426,7 +3019,7 @@ var getIterableMap = async (config, collection) => {
 };
 
 // src/services/getServices.ts
-var getServices = 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");
@@ -2441,20 +3034,32 @@ var getServices = async (context, gateway) => {
   } = 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();
-  assertEx26(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,
@@ -2471,16 +3076,16 @@ var addWorkers = (config, services) => {
 
 // src/server/server.ts
 var hostname = "::";
-var getServer = 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);
@@ -2489,147 +3094,11 @@ var getServer = async (context, gateway) => {
   return { server, services };
 };
 
-// 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);
-    }
-  }
-  return {
-    start() {
-      void poll();
-      timer = setInterval(() => void poll(), intervalMs);
-    },
-    stop() {
-      if (timer) {
-        clearInterval(timer);
-        timer = void 0;
-      }
-    }
-  };
-}
-
-// 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);
-      }
-    }
-  }
-  return {
-    start() {
-      void poll();
-      timer = setInterval(() => void poll(), intervalMs);
-    },
-    stop() {
-      if (timer) {
-        clearInterval(timer);
-        timer = void 0;
-      }
-    }
-  };
-}
-
 // src/BridgeActor.ts
 var BridgeActor = class extends ActorV3 {
   _gatewayRunner;
   _balanceMonitor;
+  _inFlightPoller;
   _queueMetrics;
   _scannerRunner;
   server;
@@ -2650,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();
@@ -2667,7 +3138,6 @@ var BridgeActor = class extends ActorV3 {
       config,
       connection: connection2,
       flowProducer: flowProducer2,
-      logger: this.logger,
       services,
       telemetry: telemetry2
     });
@@ -2680,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();
@@ -2689,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() {
@@ -2753,7 +3231,10 @@ function bridgeCommand(getConfiguration, getLocatorsFromConfig) {
 export {
   BridgeActor,
   bridgeCommand,
+  bucketFailureReason,
   createBalanceMonitor,
+  createBridgeFlowMetrics,
+  createInFlightPoller,
   createQueueMetrics,
   getBridgeActor,
   runBridge