@xyo-network/chain-bridge 1.22.0 → 1.23.2

package/dist/node/index.mjs

@@ -1,5 +1,15 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/BridgeActor.ts
 import { creatable } from "@xylabs/sdk-js";
@@ -16,7 +26,7 @@ import { isDefined } from "@xylabs/sdk-js";
 import { Redis } from "ioredis";
 var connection;
 var maxRetriesPerRequest = null;
-var getConnection = /* @__PURE__ */ __name((config) => {
+var getConnection = (config) => {
   if (isDefined(connection)) return connection;
   const { redisHost: host, redisPort: port } = config;
   connection = new Redis({
@@ -25,7 +35,7 @@ var getConnection = /* @__PURE__ */ __name((config) => {
     maxRetriesPerRequest
   });
   return connection;
-}, "getConnection");
+};
 
 // src/services/queue/flowProducer.ts
 import { isDefined as isDefined2 } from "@xylabs/sdk-js";
@@ -36,7 +46,7 @@ var prefix = "xl1-bridge";
 
 // src/services/queue/flowProducer.ts
 var flowProducer;
-var getFlowProducer = /* @__PURE__ */ __name((connection2, telemetry2) => {
+var getFlowProducer = (connection2, telemetry2) => {
   if (isDefined2(flowProducer)) return flowProducer;
   flowProducer = new FlowProducer({
     connection: connection2,
@@ -44,100 +54,152 @@ var getFlowProducer = /* @__PURE__ */ __name((connection2, telemetry2) => {
     prefix
   });
   return flowProducer;
-}, "getFlowProducer");
+};
 
 // src/services/queue/workers/EthEventVerification.ts
-import { assertEx as assertEx2, isNull } from "@xylabs/sdk-js";
+import { assertEx as assertEx3, isNull } from "@xylabs/sdk-js";
 import { UnrecoverableError, Worker } from "bullmq";
 
-// src/services/queue/workers/util/buildEthToXl1ReserveTx.ts
-import { toHex } from "@xylabs/sdk-js";
+// src/services/queue/workers/util/buildEthToXl1BridgePayloads.ts
+import { assertEx, toHex } from "@xylabs/sdk-js";
 import { PayloadBuilder } from "@xyo-network/sdk-js";
-import { BridgeIntentSchema, BridgeSourceObservationSchema, buildTransaction, createTransferPayload } from "@xyo-network/xl1-sdk";
-async function buildEthToXl1ReserveTx(options2) {
-  const { amount, bridgeAccount, bridgeId, destAddress, evmChainId, evmContractAddress, evmSrcAddress, evmTokenAddress, evmTxHash, exp, nbf, xl1ChainId, xl1TokenAddress } = options2;
-  const amountHex = toHex(amount);
-  const nonce = `evm:${evmChainId.toLowerCase()}:${evmContractAddress.toLowerCase()}:${bridgeId.toString()}`;
-  const transfer = createTransferPayload(bridgeAccount.address, {
-    [destAddress]: amount
-  });
-  const intent = new PayloadBuilder({
-    schema: BridgeIntentSchema
-  }).fields({
+import { BridgeIntentSchema, createTransferPayload } from "@xyo-network/xl1-sdk";
+function buildEthToXl1BridgePayloads(options2) {
+  const {
+    amount,
+    bridgeAccountAddress,
+    bridgeId,
+    destAddress,
+    evmChainId,
+    evmContractAddress,
+    evmSrcAddress,
+    evmTokenAddress,
+    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,
     destAddress,
-    destAmount: amountHex,
+    destAmount: destAmountHex,
     destToken: xl1TokenAddress,
     nonce,
     src: evmChainId,
     srcAddress: evmSrcAddress,
-    srcAmount: amountHex,
+    srcAmount: srcAmountHex,
     srcToken: evmTokenAddress
   }).build();
-  const sourceObservation = new PayloadBuilder({
-    schema: BridgeSourceObservationSchema
-  }).fields({
+  return { intent, transfer };
+}
+
+// src/services/queue/workers/util/buildEthToXl1ReserveTx.ts
+import { toHex as toHex2 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import { BridgeSourceObservationSchema, buildTransaction } from "@xyo-network/xl1-sdk";
+async function buildEthToXl1ReserveTx(options2) {
+  const {
+    amount,
+    bridgeAccount,
+    bridgeId,
+    destAddress,
+    evmChainId,
+    evmContractAddress,
+    evmSrcAddress,
+    evmTokenAddress,
+    evmTxHash,
+    exp,
+    feesAddress,
+    feesAmount,
+    nbf,
+    xl1ChainId,
+    xl1TokenAddress
+  } = options2;
+  const { intent, transfer } = buildEthToXl1BridgePayloads({
+    amount,
+    bridgeAccountAddress: bridgeAccount.address,
+    bridgeId,
+    destAddress,
+    evmChainId,
+    evmContractAddress,
+    evmSrcAddress,
+    evmTokenAddress,
+    feesAddress,
+    feesAmount,
+    xl1ChainId,
+    xl1TokenAddress
+  });
+  const destAmountHex = toHex2(amount - feesAmount);
+  const srcAmountHex = toHex2(amount);
+  const sourceObservation = new PayloadBuilder2({ schema: BridgeSourceObservationSchema }).fields({
     dest: xl1ChainId,
     destAddress,
-    destAmount: amountHex,
+    destAmount: destAmountHex,
     destToken: xl1TokenAddress,
     src: evmChainId,
     srcAddress: evmSrcAddress,
-    srcAmount: amountHex,
+    srcAmount: srcAmountHex,
     srcConfirmation: evmTxHash,
     srcToken: evmTokenAddress
   }).build();
-  return buildTransaction(xl1ChainId, [
-    transfer
-  ], [
-    intent,
-    sourceObservation
-  ], bridgeAccount, nbf, exp);
+  return buildTransaction(
+    xl1ChainId,
+    [transfer],
+    [intent, sourceObservation],
+    bridgeAccount,
+    nbf,
+    exp
+  );
 }
-__name(buildEthToXl1ReserveTx, "buildEthToXl1ReserveTx");
 
 // src/services/queue/workers/util/resolveEvmBlockTagAtDepth.ts
 async function resolveEvmBlockTagAtDepth(provider, depth) {
   if (depth === "finalized") return "finalized";
+  if (depth === 0) return "latest";
   const head = await provider.getBlockNumber();
   return Math.max(head - depth, 0);
 }
-__name(resolveEvmBlockTagAtDepth, "resolveEvmBlockTagAtDepth");
 
 // src/services/queue/workers/util/submitEthTransaction.ts
-import { assertEx, hexToBigInt, toEthAddress } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import {
+  assertEx as assertEx2,
+  hexToBigInt,
+  toEthAddress
+} from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk-js";
 import { isBridgeIntent } from "@xyo-network/xl1-sdk";
-var submitEthTransaction = /* @__PURE__ */ __name(async (tx, offChainPayloads, bridge, wallet) => {
-  const xl1Transaction = assertEx(tx[0], () => "No corresponding XL1 transaction found");
-  const allPayloads = [
-    ...tx[1],
-    ...offChainPayloads
-  ];
-  const bridgeIntent = assertEx(allPayloads.find(isBridgeIntent), () => "No bridge intent found");
+var submitEthTransaction = async (tx, offChainPayloads, bridge, wallet) => {
+  const xl1Transaction = assertEx2(tx[0], () => "No corresponding XL1 transaction found");
+  const allPayloads = [...tx[1], ...offChainPayloads];
+  const bridgeIntent = assertEx2(allPayloads.find(isBridgeIntent), () => "No bridge intent found");
   const srcAddress = toEthAddress(bridgeIntent.srcAddress);
   const destAddress = toEthAddress(bridgeIntent.destAddress);
   const amount = hexToBigInt(bridgeIntent.destAmount);
-  const nonce = hexToBigInt(await PayloadBuilder2.hash(xl1Transaction));
+  const nonce = hexToBigInt(await PayloadBuilder3.hash(xl1Transaction));
   const bridgeTx = await bridge.connect(wallet).bridgeFromRemote(srcAddress, destAddress, amount, nonce);
   const receipt = await bridgeTx.wait(1);
   return receipt?.hash;
-}, "submitEthTransaction");
+};
 
 // src/services/queue/workers/util/submitXl1Transaction.ts
-var submitXl1Transaction = /* @__PURE__ */ __name(async (preparedTx, offChain = [], gateway) => {
+var submitXl1Transaction = async (preparedTx, offChain = [], gateway) => {
   const result = await gateway.addTransactionToChain(preparedTx, offChain);
   return result;
-}, "submitXl1Transaction");
+};
 
 // src/services/queue/workers/util/verifyEthBridgeEvent.ts
 import { asHex, toAddress } from "@xylabs/sdk-js";
 import { ZeroAddress } from "ethers";
 async function verifyEthBridgeEvent(id, bridge, provider, confirmationDepth) {
   const blockTag = await resolveEvmBlockTagAtDepth(provider, confirmationDepth);
-  const data = await bridge.bridgesToRemote(id, {
-    blockTag
-  });
+  const data = await bridge.bridgesToRemote(id, { blockTag });
   if (data.srcAddress === ZeroAddress) {
     return null;
   }
@@ -155,53 +217,60 @@ async function verifyEthBridgeEvent(id, bridge, provider, confirmationDepth) {
     srcAddress: toAddress(data.srcAddress)
   };
 }
-__name(verifyEthBridgeEvent, "verifyEthBridgeEvent");
 
 // src/services/queue/workers/EthEventVerification.ts
 var name = "Verify ETH Bridge Event at Depth";
 var queueName = "eth-event-verify";
-var createWorker = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const svc = assertEx2(services, () => "services not provided");
-  const { bridge, bridgeFulfillmentMap, provider, remoteConfirmationDepth } = svc;
-  const worker = new Worker(queueName, async (job) => {
-    const { bridgeId, identity } = job.data;
-    const id = BigInt(bridgeId);
-    const existing = await bridgeFulfillmentMap.get(identity);
-    if (existing?.canonical) {
-      await job.log(`[${identity}] canonical already set; verification skipped`);
-      return;
-    }
-    const state = existing ?? {
-      identity,
-      previousAttempts: []
-    };
-    if (state.failed) state.failed = void 0;
-    await job.log(`[${identity}] verifying BridgedToRemote(${id}) at depth ${remoteConfirmationDepth}`);
-    const data = await verifyEthBridgeEvent(id, bridge, provider, remoteConfirmationDepth);
-    if (isNull(data)) {
-      state.failed = {
-        at: Date.now(),
-        reason: "non-canonical at confirmation depth \u2014 orphaned by reorg or never reached canonical state"
-      };
+var createWorker = (connection2, telemetry2, services) => {
+  const svc = assertEx3(services, () => "services not provided");
+  const {
+    bridge,
+    bridgeFulfillmentMap,
+    provider,
+    remoteConfirmationDepth
+  } = svc;
+  const worker = new Worker(
+    queueName,
+    async (job) => {
+      const { bridgeId, identity } = job.data;
+      const id = BigInt(bridgeId);
+      const existing = await bridgeFulfillmentMap.get(identity);
+      if (existing?.canonical) {
+        await job.log(`[${identity}] canonical already set; verification skipped`);
+        return;
+      }
+      const state = existing ?? { identity, previousAttempts: [] };
+      if (state.failed) state.failed = void 0;
+      await job.log(`[${identity}] verifying BridgedToRemote(${id}) at depth ${remoteConfirmationDepth}`);
+      const data = await verifyEthBridgeEvent(id, bridge, provider, remoteConfirmationDepth);
+      if (isNull(data)) {
+        state.failed = {
+          at: Date.now(),
+          reason: "non-canonical at confirmation depth \u2014 orphaned by reorg or never reached canonical state"
+        };
+        await bridgeFulfillmentMap.set(identity, state);
+        await job.log(`[${identity}] non-canonical at depth \u2014 marked failed`);
+        throw new UnrecoverableError(`[${identity}] bridgesToRemote slot empty at confirmation depth ${remoteConfirmationDepth}`);
+      }
+      state.canonical = data;
       await bridgeFulfillmentMap.set(identity, state);
-      await job.log(`[${identity}] non-canonical at depth \u2014 marked failed`);
-      throw new UnrecoverableError(`[${identity}] bridgesToRemote slot empty at confirmation depth ${remoteConfirmationDepth}`);
+      await job.log(
+        `[${identity}] verified: src=${data.srcAddress} dest=${data.destAddress} amount=${data.amount} evmTxHash=${data.evmTxHash}`
+      );
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    state.canonical = data;
-    await bridgeFulfillmentMap.set(identity, state);
-    await job.log(`[${identity}] verified: src=${data.srcAddress} dest=${data.destAddress} amount=${data.amount} evmTxHash=${data.evmTxHash}`);
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var EthEventVerification = {
   createWorker,
   name,
@@ -212,23 +281,27 @@ var EthEventVerification = {
 import { Worker as Worker2 } from "bullmq";
 var name2 = "Bridge Ethereum to XL1";
 var queueName2 = "eth-to-xl1-bridge";
-var createWorker2 = /* @__PURE__ */ __name((connection2, telemetry2) => {
-  const worker = new Worker2(queueName2, async (job) => {
-    await job.log(`[${job.name}] start`);
-    await job.log(`[${job.name}] done`);
-    return {};
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+var createWorker2 = (connection2, telemetry2) => {
+  const worker = new Worker2(
+    queueName2,
+    async (job) => {
+      await job.log(`[${job.name}] start`);
+      await job.log(`[${job.name}] done`);
+      return {};
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
+    }
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name2}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name2}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var EthToXl1BridgeParent = {
   createWorker: createWorker2,
   name: name2,
@@ -236,41 +309,45 @@ var EthToXl1BridgeParent = {
 };
 
 // src/services/queue/workers/EthTransactionMonitor.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk-js";
+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 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const provider = assertEx3(services?.provider, () => "provider service not provided");
-  const stateMap = assertEx3(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
-  const worker = new Worker3(queueName3, async (job) => {
-    const { tx } = job.data;
-    const hash = await PayloadBuilder3.hash(tx[0]);
-    const state = assertEx3(await stateMap.get(hash), () => "State not found");
-    const submissionHash = assertEx3(state?.submissionHash, () => "submissionHash not found");
-    const receipt = assertEx3(await provider.getTransactionReceipt(submissionHash), () => "Transaction receipt not found");
-    await job.log(`[${hash}] confirmed ETH tx ${submissionHash} in block ${receipt.blockNumber}`);
-    const { blockHash, blockNumber } = receipt;
-    state.confirmationHash = blockHash;
-    await stateMap.set(hash, state);
-    return {
-      blockHash,
-      blockNumber,
-      submissionHash
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+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
+      };
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
+    }
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name3}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name3}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var EthTransactionMonitor = {
   createWorker: createWorker3,
   name: name3,
@@ -278,121 +355,124 @@ var EthTransactionMonitor = {
 };
 
 // src/services/queue/workers/EthTransactionPreparation.ts
-import { assertEx as assertEx14, hexToBigInt as hexToBigInt9 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/sdk-js";
+import { 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 hexToBigInt5, isUndefined } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
+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 = /* @__PURE__ */ __name((value) => {
+var asChainId = (value) => {
   const chainId = asHex2(value);
   return chainId;
-}, "asChainId");
+};
 
 // src/services/evm/asToken.ts
 import { asAddress } from "@xylabs/sdk-js";
-var asToken = /* @__PURE__ */ __name((value) => {
+var asToken = (value) => {
   const token = asAddress(value);
   return token;
-}, "asToken");
+};
 
 // src/services/evm/getBridgeEscrowAddress.ts
-import { asAddress as asAddress2, assertEx as assertEx4 } from "@xylabs/sdk-js";
-var tryGetBridgeEscrowAddress = /* @__PURE__ */ __name((config) => {
+import { asAddress as asAddress2, assertEx as assertEx5 } from "@xylabs/sdk-js";
+var tryGetBridgeEscrowAddress = (config) => {
   const address = asAddress2(config.escrowAddress);
   return address;
-}, "tryGetBridgeEscrowAddress");
+};
 
 // src/services/evm/getBridgeFeesAddress.ts
-import { asAddress as asAddress3, assertEx as assertEx5 } from "@xylabs/sdk-js";
-var tryGetBridgeFeesAddress = /* @__PURE__ */ __name((config) => {
+import { asAddress as asAddress3, assertEx as assertEx6 } from "@xylabs/sdk-js";
+var tryGetBridgeFeesAddress = (config) => {
   const address = asAddress3(config.feesAddress);
   return address;
-}, "tryGetBridgeFeesAddress");
+};
 
 // src/services/evm/getFeeStructure.ts
-var getFeeStructure = /* @__PURE__ */ __name((config) => {
+var getFeeStructure = (config) => {
   const { feeFixed, feeRateBasisPoints } = config;
-  return {
-    feeFixed,
-    feeRateBasisPoints
-  };
-}, "getFeeStructure");
+  return { feeFixed, feeRateBasisPoints };
+};
 
 // src/services/evm/getMaxBridgeAmount.ts
-var getMaxBridgeAmount = /* @__PURE__ */ __name((config) => {
+var getMaxBridgeAmount = (config) => {
   const { maxBridgeAmount } = config;
   return maxBridgeAmount;
-}, "getMaxBridgeAmount");
+};
 
 // src/services/evm/getMinBridgeAmount.ts
-var getMinBridgeAmount = /* @__PURE__ */ __name((config) => {
+var getMinBridgeAmount = (config) => {
   const { minBridgeAmount } = config;
   return minBridgeAmount;
-}, "getMinBridgeAmount");
+};
 
 // src/services/evm/getRemoteChainId.ts
-import { assertEx as assertEx6 } from "@xylabs/sdk-js";
-var getRemoteChainId = /* @__PURE__ */ __name((config) => {
-  const remoteChainId = assertEx6(asChainId(config.remoteChainId), () => "Invalid remote chain ID in config");
+import { assertEx as assertEx7 } from "@xylabs/sdk-js";
+var getRemoteChainId = (config) => {
+  const remoteChainId = assertEx7(asChainId(config.remoteChainId), () => "Invalid remote chain ID in config");
   return remoteChainId;
-}, "getRemoteChainId");
+};
 
 // src/services/evm/getRemoteTokenAddress.ts
-import { assertEx as assertEx7 } from "@xylabs/sdk-js";
-var getRemoteTokenAddress = /* @__PURE__ */ __name((config) => {
+import { assertEx as assertEx8 } from "@xylabs/sdk-js";
+var getRemoteTokenAddress = (config) => {
   const token = asToken(config.remoteTokenAddress);
-  return assertEx7(token, () => "Remote token address is not defined in bridge configuration");
-}, "getRemoteTokenAddress");
+  return 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 = /* @__PURE__ */ __name(async (config) => {
+var getBridgeWalletAccount = async (config) => {
   if (accountServiceSingleton) return accountServiceSingleton;
   const accountPath = typeof config.accountPath === "string" ? config.accountPath : void 0;
   const account = await resolveWalletForActor(config.name, accountPath);
   accountServiceSingleton = account;
   return accountServiceSingleton;
-}, "getBridgeWalletAccount");
+};
 
 // src/services/evm/getTransferAddresses.ts
-var getTransferAddresses = /* @__PURE__ */ __name(async (config) => {
+var getTransferAddresses = async (config) => {
   const escrowAddress = tryGetBridgeEscrowAddress(config) ?? (await getBridgeWalletAccount(config)).address;
   const feesAddress = tryGetBridgeFeesAddress(config) ?? (await getBridgeWalletAccount(config)).address;
-  return {
-    escrowAddress,
-    feesAddress
-  };
-}, "getTransferAddresses");
+  return { escrowAddress, feesAddress };
+};
 
 // src/services/evm/getXl1ChainId.ts
-import { assertEx as assertEx8, isDefined as isDefined4 } from "@xylabs/sdk-js";
-var getXl1ChainId = /* @__PURE__ */ __name((config) => {
+import { assertEx as assertEx9, isDefined as isDefined4 } from "@xylabs/sdk-js";
+var getXl1ChainId = (config) => {
   const xl1ChainId = config.xl1ChainId;
   if (isDefined4(xl1ChainId)) {
-    return assertEx8(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
+    return assertEx9(asChainId(xl1ChainId), () => "Invalid xl1ChainId in bridge config");
   }
-  return assertEx8(asChainId(config.chain.id), () => "Invalid chain.id in config");
-}, "getXl1ChainId");
+  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 = /* @__PURE__ */ __name((config) => {
+var getXl1TokenAddress = (config) => {
   const token = asToken(config.xl1TokenAddress);
   if (isDefined5(token)) return token;
   return getXl1ChainId(config);
-}, "getXl1TokenAddress");
+};
 
 // src/services/evm/getBridgeSettings.ts
-var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
+var getBridgeSettings = async (config) => {
   const { feeFixed, feeRateBasisPoints } = getFeeStructure(config);
   const { feesAddress, escrowAddress } = await getTransferAddresses(config);
   const maxBridgeAmount = getMaxBridgeAmount(config);
@@ -413,84 +493,83 @@ var getBridgeSettings = /* @__PURE__ */ __name(async (config) => {
     xl1TokenAddress,
     xl1ChainId
   };
-}, "getBridgeSettings");
+};
 
 // src/services/evm/getRemoteConfirmationDepth.ts
-import { isDefined as isDefined6 } from "@xylabs/sdk-js";
-var HARDHAT_CHAIN_ID = "0x7a69";
-var ETHEREUM_MAINNET_CHAIN_ID = "0x1";
+import { isDefined as isDefined6, toHex 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 = {
-  [HARDHAT_CHAIN_ID]: 0,
-  [ETHEREUM_MAINNET_CHAIN_ID]: 32
-};
+var DEFAULT_CONFIRMATION_DEPTH_BY_CHAIN_ID = /* @__PURE__ */ new Map([
+  [HARDHAT_CHAIN_ID, 0],
+  [ETHEREUM_MAINNET_CHAIN_ID, 32]
+]);
 function getRemoteConfirmationDepth(config) {
   if (isDefined6(config.remoteConfirmationDepth)) return config.remoteConfirmationDepth;
-  const chainId = getRemoteChainId(config).toLowerCase();
-  return DEFAULT_CONFIRMATION_DEPTH_BY_CHAIN_ID[chainId] ?? FALLBACK_CONFIRMATION_DEPTH;
+  const chainId = toHex3(getRemoteChainId(config));
+  return DEFAULT_CONFIRMATION_DEPTH_BY_CHAIN_ID.get(chainId) ?? FALLBACK_CONFIRMATION_DEPTH;
 }
-__name(getRemoteConfirmationDepth, "getRemoteConfirmationDepth");
 
 // src/services/evm/getScannerIntervalMs.ts
 function getScannerIntervalMs(config) {
   return config.scannerIntervalMs;
 }
-__name(getScannerIntervalMs, "getScannerIntervalMs");
 
 // src/services/util/calculateBridgeFees.ts
-import { hexToBigInt as hexToBigInt2, toHex as toHex2 } from "@xylabs/sdk-js";
-var calculateBridgeFees = /* @__PURE__ */ __name((srcAmount, feeStructure) => {
+import { hexToBigInt as hexToBigInt3, toHex as toHex4 } from "@xylabs/sdk-js";
+var calculateBridgeFees = (srcAmount, feeStructure) => {
   const { feeFixed, feeRateBasisPoints } = feeStructure;
-  const srcAmountBigInt = hexToBigInt2(srcAmount);
+  const srcAmountBigInt = hexToBigInt3(srcAmount);
   const feeVariableBigInt = srcAmountBigInt * BigInt(feeRateBasisPoints) / 10000n;
-  const feeVariable = toHex2(feeVariableBigInt);
+  const feeVariable = toHex4(feeVariableBigInt);
   return {
     feeFixed,
     feeVariable,
     srcAmount
   };
-}, "calculateBridgeFees");
+};
 
 // src/services/util/calculateMaxBridgeAmount.ts
-import { hexToBigInt as hexToBigInt3, toHex as toHex3 } from "@xylabs/sdk-js";
-var calculateMaxBridgeAmount = /* @__PURE__ */ __name((balance, feeStructure) => {
+import { hexToBigInt as hexToBigInt4, toHex as toHex5 } from "@xylabs/sdk-js";
+var calculateMaxBridgeAmount = (balance, feeStructure) => {
   const { feeFixed, feeRateBasisPoints } = feeStructure;
-  const balanceBigInt = hexToBigInt3(balance);
-  const feeFixedBigInt = hexToBigInt3(feeFixed);
-  if (balanceBigInt <= feeFixedBigInt) return toHex3(0n);
+  const balanceBigInt = hexToBigInt4(balance);
+  const feeFixedBigInt = hexToBigInt4(feeFixed);
+  if (balanceBigInt <= feeFixedBigInt) return toHex5(0n);
   const maxAmount = (balanceBigInt - feeFixedBigInt) * 10000n / (10000n + BigInt(feeRateBasisPoints));
-  return toHex3(maxAmount);
-}, "calculateMaxBridgeAmount");
+  return toHex5(maxAmount);
+};
 
 // src/services/util/createBridgeTransfer.ts
-import { hexToBigInt as hexToBigInt4 } from "@xylabs/sdk-js";
+import { hexToBigInt as hexToBigInt5 } from "@xylabs/sdk-js";
 import { createTransferPayload as createTransferPayload2 } from "@xyo-network/xl1-sdk";
-var createBridgeTransfer = /* @__PURE__ */ __name((sender, srcAmount, escrowAddress, feesAddress, context) => {
+var createBridgeTransfer = (sender, srcAmount, escrowAddress, feesAddress, context) => {
   const { feeFixed, feeVariable } = context;
-  const escrowAmount = hexToBigInt4(srcAmount);
-  const feesAmount = hexToBigInt4(feeFixed) + hexToBigInt4(feeVariable);
-  const transfers = escrowAddress === feesAddress ? {
-    [feesAddress]: escrowAmount + feesAmount
-  } : {
-    [escrowAddress]: escrowAmount,
-    [feesAddress]: feesAmount
-  };
+  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;
-}, "createBridgeTransfer");
+};
 
 // src/services/util/generateBridgeEstimate.ts
 import { toAddress as toAddress2 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
 import { BridgeIntentSchema as BridgeIntentSchema2 } from "@xyo-network/xl1-sdk";
 import { v4 } from "uuid";
-var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount, destAddress, config, nonceOverride) => {
-  const { escrowAddress, feeFixed, feeRateBasisPoints, feesAddress, remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
-  const sender = toAddress2(srcAddress);
-  const fees = calculateBridgeFees(srcAmount, {
+var generateBridgeEstimate = async (srcAddress, srcAmount, destAddress, config, nonceOverride) => {
+  const {
+    escrowAddress,
     feeFixed,
-    feeRateBasisPoints
-  });
+    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
@@ -502,99 +581,92 @@ var generateBridgeEstimate = /* @__PURE__ */ __name(async (srcAddress, srcAmount
     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 PayloadBuilder4({
-    schema: BridgeIntentSchema2
-  }).fields(bridgeIntentFields).build();
+  const bridgeIntent = new PayloadBuilder5({ schema: BridgeIntentSchema2 }).fields(bridgeIntentFields).build();
   const transfer = createBridgeTransfer(sender, srcAmount, escrowAddress, feesAddress, fees);
-  return [
-    bridgeIntent,
-    transfer
-  ];
-}, "generateBridgeEstimate");
+  return [bridgeIntent, transfer];
+};
 
 // src/services/validation/validateBridgeEstimateExact.ts
-var validateBridgeEstimateExact = /* @__PURE__ */ __name(async (intent, transfer, config) => {
-  const { srcAddress, srcAmount, destAddress } = intent;
-  if (hexToBigInt5(srcAmount) < hexToBigInt5(getMinBridgeAmount(config))) return false;
-  if (hexToBigInt5(srcAmount) > hexToBigInt5(getMaxBridgeAmount(config))) return false;
+var validateBridgeEstimateExact = async (intent, transfer, config) => {
+  const {
+    srcAddress,
+    srcAmount,
+    destAddress
+  } = intent;
+  if (hexToBigInt6(srcAmount) < hexToBigInt6(getMinBridgeAmount(config))) return false;
+  if (hexToBigInt6(srcAmount) > hexToBigInt6(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 PayloadBuilder5.dataHash(expectedIntentStatic) !== await PayloadBuilder5.dataHash(actualIntentStatic)) return false;
+  if (await PayloadBuilder6.dataHash(expectedIntentStatic) !== await PayloadBuilder6.dataHash(actualIntentStatic)) return false;
   const { epoch: expectedTransferEpoch, ...expectedTransferStatic } = calculatedTransfer;
   const { epoch: actualTransferEpoch, ...actualTransferStatic } = transfer;
-  if (await PayloadBuilder5.dataHash(expectedTransferStatic) !== await PayloadBuilder5.dataHash(actualTransferStatic)) return false;
+  if (await PayloadBuilder6.dataHash(expectedTransferStatic) !== await PayloadBuilder6.dataHash(actualTransferStatic)) return false;
   return true;
-}, "validateBridgeEstimateExact");
+};
 
 // src/services/validation/validateBridgeTransaction.ts
 import { asAddress as asAddress4 } from "@xylabs/sdk-js";
-import { addressesContains, BoundWitnessValidator, payloadHashesContainsAll, payloadSchemasContainsAll } from "@xyo-network/boundwitness-validator";
-import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/sdk-js";
+import {
+  addressesContains,
+  BoundWitnessValidator,
+  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";
-var validateBridgeTransaction = /* @__PURE__ */ __name(async (signedTxBw, intent, transfer, config) => {
+var validateBridgeTransaction = async (signedTxBw, intent, transfer, config) => {
   const { srcAddress } = intent;
   const chainId = getXl1ChainId(config);
   if (signedTxBw.chain !== chainId) return false;
   if (signedTxBw.payload_hashes.length != 2) return false;
-  if (!payloadSchemasContainsAll(signedTxBw, [
-    BridgeIntentSchema3,
-    TransferSchema
-  ])) return false;
-  const hashes = await PayloadBuilder6.hashes([
-    intent,
-    transfer
-  ]);
+  if (!payloadSchemasContainsAll(signedTxBw, [BridgeIntentSchema3, TransferSchema])) return false;
+  const hashes = await PayloadBuilder7.hashes([intent, transfer]);
   if (!payloadHashesContainsAll(signedTxBw, hashes)) return false;
   const errors = await new BoundWitnessValidator(signedTxBw).validate();
   if (errors.length > 0) return false;
   const sender = asAddress4(srcAddress, true);
   if (!addressesContains(signedTxBw, sender)) return false;
   return true;
-}, "validateBridgeTransaction");
+};
 
 // src/services/validation/validateSufficientLiquiditySourceAllowance.ts
-import { assertEx as assertEx9, hexToBigInt as hexToBigInt6 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, hexToBigInt as hexToBigInt7 } from "@xylabs/sdk-js";
 import { isBridgeIntent as isBridgeIntent2 } from "@xyo-network/xl1-sdk";
-var validateSufficientLiquiditySourceAllowance = /* @__PURE__ */ __name(async (tx, offChainPayloads, bridgeableToken, bridge, logger) => {
-  const allPayloads = [
-    ...tx[1],
-    ...offChainPayloads
-  ];
-  const bridgeIntent = assertEx9(allPayloads.find(isBridgeIntent2), () => "No bridge intent found");
-  const amount = hexToBigInt6(bridgeIntent.destAmount);
+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 liquiditySourceAddress = await bridge.liquiditySource();
   const bridgeAddress = await bridge.getAddress();
   const remainingAllowance = await bridgeableToken.allowance(liquiditySourceAddress, bridgeAddress);
   await logger?.log(`Remaining allowance: ${remainingAllowance.toString()}`);
   return remainingAllowance >= amount;
-}, "validateSufficientLiquiditySourceAllowance");
+};
 
 // src/services/validation/validateSufficientLiquiditySourceBalance.ts
-import { assertEx as assertEx10, hexToBigInt as hexToBigInt7 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11, hexToBigInt as hexToBigInt8 } from "@xylabs/sdk-js";
 import { isBridgeIntent as isBridgeIntent3 } from "@xyo-network/xl1-sdk";
-var validateSufficientLiquiditySourceBalance = /* @__PURE__ */ __name(async (tx, offChainPayloads, bridgeableToken, bridge, logger) => {
-  const allPayloads = [
-    ...tx[1],
-    ...offChainPayloads
-  ];
-  const bridgeIntent = assertEx10(allPayloads.find(isBridgeIntent3), () => "No bridge intent found");
-  const amount = hexToBigInt7(bridgeIntent.destAmount);
+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 liquiditySourceAddress = await bridge.liquiditySource();
   const balance = await bridgeableToken.balanceOf(liquiditySourceAddress);
   await logger?.log(`Remaining balance: ${balance.toString()}`);
   return balance >= amount;
-}, "validateSufficientLiquiditySourceBalance");
+};
 
 // src/services/validation/validateSufficientRunnerEthBalanceForGas.ts
-import { assertEx as assertEx11 } from "@xylabs/sdk-js";
+import { assertEx as assertEx12 } from "@xylabs/sdk-js";
 var DEFAULT_GAS_BUFFER_BPS = 2000n;
-var validateSufficientRunnerEthBalanceForGas = /* @__PURE__ */ __name(async (preparedTx, wallet, logger, bufferBps = DEFAULT_GAS_BUFFER_BPS) => {
-  const provider = assertEx11(wallet.provider, () => "Wallet provider is not defined");
+var validateSufficientRunnerEthBalanceForGas = async (preparedTx, wallet, logger, bufferBps = DEFAULT_GAS_BUFFER_BPS) => {
+  const provider = assertEx12(wallet.provider, () => "Wallet provider is not defined");
   const feeData = await provider.getFeeData();
   const perGas = feeData.maxFeePerGas ?? feeData.gasPrice;
   if (perGas == null) {
@@ -610,91 +682,104 @@ var validateSufficientRunnerEthBalanceForGas = /* @__PURE__ */ __name(async (pre
   const baseRequired = estGas * perGas + txValue;
   const required = baseRequired * (10000n + bufferBps) / 10000n;
   const balance = await provider.getBalance(await wallet.getAddress());
-  await logger?.log(`[gas] runner=${await wallet.getAddress()} balance=${balance.toString()} estGas=${estGas.toString()} perGas=${perGas.toString()} value=${txValue.toString()} requiredWithBuffer=${required.toString()} bufferBps=${bufferBps.toString()}`);
+  await logger?.log(
+    `[gas] runner=${await wallet.getAddress()} balance=${balance.toString()} estGas=${estGas.toString()} perGas=${perGas.toString()} value=${txValue.toString()} requiredWithBuffer=${required.toString()} bufferBps=${bufferBps.toString()}`
+  );
   return balance >= required;
-}, "validateSufficientRunnerEthBalanceForGas");
+};
 
 // src/services/validation/validateSufficientXl1ReserveBalance.ts
-import { assertEx as assertEx12 } from "@xylabs/sdk-js";
-async function validateSufficientXl1ReserveBalance({ amount, bridgeAccount, gateway, logger }) {
-  const viewer = assertEx12(gateway.connection.viewer, () => "Gateway connection does not have a viewer");
+import { assertEx as assertEx13 } from "@xylabs/sdk-js";
+async function validateSufficientXl1ReserveBalance({
+  amount,
+  bridgeAccount,
+  gateway,
+  logger
+}) {
+  const viewer = assertEx13(gateway.connection.viewer, () => "Gateway connection does not have a viewer");
   const balance = await viewer.account.balance.accountBalance(bridgeAccount.address);
   await logger?.log(`XL1 reserve account ${bridgeAccount.address} balance: ${balance.toString()}; required: ${amount.toString()}`);
   return balance >= amount;
 }
-__name(validateSufficientXl1ReserveBalance, "validateSufficientXl1ReserveBalance");
 
 // src/services/validation/validateSufficientXL1SourceAddressBalance.ts
-import { asAddress as asAddress5, assertEx as assertEx13, hexToBigInt as hexToBigInt8 } from "@xylabs/sdk-js";
-var validateSufficientXL1SourceAddressBalance = /* @__PURE__ */ __name(async (bridgeIntent, gateway, config, logger) => {
-  const viewer = assertEx13(gateway.connection.viewer, () => "Gateway connection does not have a viewer");
-  const { srcAddress, srcAmount, destAddress } = bridgeIntent;
+import {
+  asAddress as asAddress5,
+  assertEx as assertEx14,
+  hexToBigInt as hexToBigInt9
+} from "@xylabs/sdk-js";
+var validateSufficientXL1SourceAddressBalance = async (bridgeIntent, gateway, config, logger) => {
+  const viewer = assertEx14(gateway.connection.viewer, () => "Gateway connection does not have a viewer");
+  const {
+    srcAddress,
+    srcAmount,
+    destAddress
+  } = bridgeIntent;
   const srcAddressBranded = asAddress5(srcAddress, () => `Invalid source address in bridge intent: ${srcAddress}`);
   const [_, calculatedTransfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
-  const totalAmount = Object.values(calculatedTransfer.transfers).reduce((acc, transfer) => acc + hexToBigInt8(transfer), 0n);
+  const totalAmount = Object.values(calculatedTransfer.transfers).reduce((acc, transfer) => acc + hexToBigInt9(transfer), 0n);
   const accountBalance = await viewer.account.balance.accountBalance(srcAddressBranded);
   await logger?.log(`Account balance for ${srcAddressBranded}: ${accountBalance.toString()}`);
   return accountBalance >= totalAmount;
-}, "validateSufficientXL1SourceAddressBalance");
+};
 
 // src/services/queue/workers/EthTransactionPreparation.ts
 var name4 = "Prepare ETH Transaction";
 var queueName4 = "eth-tx-prepare";
-var createWorker4 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const bridge = assertEx14(services?.bridge, () => "bridge service not provided");
-  const bridgeableToken = assertEx14(services?.bridgeableToken, () => "bridgeableToken service not provided");
-  const stateMap = assertEx14(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
-  const wallet = assertEx14(services?.wallet, () => "wallet service not provided");
-  const worker = new Worker4(queueName4, async (job) => {
-    const { tx, offChainPayloads } = job.data;
-    const hash = await PayloadBuilder7.hash(tx[0]);
-    await job.log(`[${hash}] preparing ETH transaction`);
-    await job.log(`[${hash}] validating liquiditySource has sufficient allowance`);
-    if (!await validateSufficientLiquiditySourceAllowance(tx, offChainPayloads, bridgeableToken, bridge, job)) {
-      throw new Error("Liquidity source does not have sufficient allowance for the bridge to execute the transaction");
-    }
-    await job.log(`[${hash}] validated liquiditySource has sufficient allowance`);
-    await job.log(`[${hash}] validating liquiditySource has sufficient balance`);
-    if (!await validateSufficientLiquiditySourceBalance(tx, offChainPayloads, bridgeableToken, bridge, job)) {
-      throw new Error("Liquidity source does not have sufficient balance for the bridge to execute the transaction");
-    }
-    await job.log(`[${hash}] validated liquiditySource has sufficient balance`);
-    await job.log(`[${hash}] building ETH transaction`);
-    const allPayloads = [
-      ...tx[1],
-      ...offChainPayloads
-    ];
-    const bridgeIntent = assertEx14(allPayloads.find(isBridgeIntent4), () => "No bridge intent found");
-    const amount = hexToBigInt9(bridgeIntent.destAmount);
-    const srcAddress = getAddress(bridgeIntent.srcAddress);
-    const destAddress = getAddress(bridgeIntent.destAddress);
-    const nonce = hexToBigInt9(await PayloadBuilder7.hash(tx[0]));
-    const preparedTx = await bridge.getFunction("bridgeFromRemote").populateTransaction(srcAddress, destAddress, amount, nonce);
-    await job.log(`[${hash}] built ETH transaction`);
-    await job.log(`[${hash}] validating tx runner has sufficient ETH for gas`);
-    if (!await validateSufficientRunnerEthBalanceForGas(preparedTx, wallet, job)) {
-      throw new Error("Transaction runner does not have sufficient ETH to cover estimated gas (with buffer)");
+var createWorker4 = (connection2, telemetry2, services) => {
+  const bridge = assertEx15(services?.bridge, () => "bridge service not provided");
+  const bridgeableToken = assertEx15(services?.bridgeableToken, () => "bridgeableToken service not provided");
+  const stateMap = assertEx15(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const wallet = assertEx15(services?.wallet, () => "wallet service not provided");
+  const 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 {};
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    await job.log(`[${hash}] validated tx runner has sufficient ETH for gas`);
-    await job.log(`[${hash}] storing ETH preparedTx`);
-    await stateMap.set(hash, {
-      preparedTx
-    });
-    await job.log(`[${hash}] stored ETH preparedTx`);
-    await job.log(`[${hash}] prepared ETH transaction`);
-    return {};
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name4}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name4}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var EthTransactionPreparation = {
   createWorker: createWorker4,
   name: name4,
@@ -702,45 +787,45 @@ var EthTransactionPreparation = {
 };
 
 // src/services/queue/workers/EthTransactionSubmission.ts
-import { assertEx as assertEx15, isDefined as isDefined7 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/sdk-js";
+import { assertEx as assertEx16, isDefined as isDefined7 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/sdk-js";
 import { Worker as Worker5 } from "bullmq";
 var name5 = "Submit ETH Transaction";
 var queueName5 = "eth-tx-submit";
-var createWorker5 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const bridge = assertEx15(services?.bridge, () => "bridge service not provided");
-  const wallet = assertEx15(services?.wallet, () => "wallet service not provided");
-  const stateMap = assertEx15(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
-  const worker = new Worker5(queueName5, async (job) => {
-    const { tx, offChainPayloads } = job.data;
-    const hash = await PayloadBuilder8.hash(tx[0]);
-    const state = assertEx15(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined7(existingSubmissionHash)) {
-      await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
-      return {
-        submissionHash: existingSubmissionHash
-      };
+var createWorker5 = (connection2, telemetry2, services) => {
+  const bridge = assertEx16(services?.bridge, () => "bridge service not provided");
+  const wallet = assertEx16(services?.wallet, () => "wallet service not provided");
+  const stateMap = assertEx16(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const 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 };
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      concurrency: 1,
+      prefix
     }
-    await job.log(`[${hash}] Submitting ETH tx`);
-    const submissionHash = assertEx15(await submitEthTransaction(tx, offChainPayloads, bridge, wallet), () => `[${hash}] submissionHash not found in receipt`);
-    await job.log(`[${hash}] Submitted ETH tx and received submission response hash ${submissionHash}`);
-    return {
-      submissionHash
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    concurrency: 1,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name5}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name5}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var EthTransactionSubmission = {
   createWorker: createWorker5,
   name: name5,
@@ -748,48 +833,48 @@ var EthTransactionSubmission = {
 };
 
 // src/services/queue/workers/EthTransactionSubmissionStorage.ts
-import { assertEx as assertEx16, isDefined as isDefined8 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/sdk-js";
+import { assertEx as assertEx17, isDefined as isDefined8 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/sdk-js";
 import { Worker as Worker6 } from "bullmq";
 var name6 = "Store ETH Transaction Submission";
 var queueName6 = "eth-tx-store-submission";
-var createWorker6 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const stateMap = assertEx16(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
-  const worker = new Worker6(queueName6, async (job) => {
-    const { tx } = job.data;
-    const hash = await PayloadBuilder9.hash(tx[0]);
-    const state = assertEx16(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined8(existingSubmissionHash)) {
-      await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`);
-      return {
-        submissionHash: existingSubmissionHash
-      };
+var createWorker6 = (connection2, telemetry2, services) => {
+  const stateMap = assertEx17(services?.ethTxStateMap, () => "ethTxStateMap service not provided");
+  const 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 };
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    const childrenValues = await job.getChildrenValues();
-    const jobKey = `${prefix}:${EthTransactionSubmission.queueName}:${hash}`;
-    const childValues = childrenValues?.[jobKey];
-    const submissionHash = childValues?.submissionHash;
-    const resolvedSubmissionHash = assertEx16(submissionHash, () => `[${hash}] child submissionHash not found in children values`);
-    await job.log(`[${hash}] Storing ETH submissionHash`);
-    state.submissionHash = resolvedSubmissionHash;
-    await stateMap.set(hash, state);
-    await job.log(`[${hash}] Stored ETH submissionHash`);
-    return {
-      submissionHash: resolvedSubmissionHash
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name6}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name6}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var EthTransactionSubmissionStorage = {
   createWorker: createWorker6,
   name: name6,
@@ -797,8 +882,15 @@ var EthTransactionSubmissionStorage = {
 };
 
 // src/services/queue/workers/Xl1ReserveTxFulfillment.ts
-import { assertEx as assertEx17, delay, isDefined as isDefined9, isNull as isNull2 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/sdk-js";
+import {
+  assertEx as assertEx18,
+  delay,
+  hexToBigInt as hexToBigInt11,
+  isDefined as isDefined9,
+  isNull as isNull2,
+  toHex as toHex6
+} from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
 import { asXL1BlockNumber } from "@xyo-network/xl1-sdk";
 import { Worker as Worker7 } from "bullmq";
 var name7 = "XL1 Reserve Transfer Fulfillment";
@@ -807,8 +899,14 @@ var EXP_BLOCKS_AHEAD = 1e3;
 var POLL_INTERVAL_MS = 5e3;
 var CONCURRENCY = 32;
 async function tryResumeCurrentAttempt(ctx) {
-  const { fulfillmentMap, identity, job, state, viewer } = ctx;
-  const attempt = assertEx17(state.currentAttempt, () => "tryResumeCurrentAttempt called without currentAttempt");
+  const {
+    fulfillmentMap,
+    identity,
+    job,
+    state,
+    viewer
+  } = ctx;
+  const attempt = assertEx18(state.currentAttempt, () => "tryResumeCurrentAttempt called without currentAttempt");
   const found = await viewer.transaction.byHash(attempt.txHash);
   if (isDefined9(found) && !isNull2(found)) {
     state.fulfilled = attempt;
@@ -825,10 +923,26 @@ async function tryResumeCurrentAttempt(ctx) {
     await job.log(`[${identity}] resumed attempt expired (head=${head}); will build fresh`);
   }
 }
-__name(tryResumeCurrentAttempt, "tryResumeCurrentAttempt");
 async function buildAndSubmitFreshAttempt(ctx) {
-  const { account, bridgeId, contractAddress, evmChainId, fulfillmentMap, gateway, identity, job, state, viewer, xl1ChainId, xl1TokenAddress } = ctx;
-  const canonical = assertEx17(state.canonical, () => "buildAndSubmitFreshAttempt requires canonical");
+  const {
+    account,
+    bridgeId,
+    config,
+    contractAddress,
+    evmChainId,
+    fulfillmentMap,
+    gateway,
+    identity,
+    job,
+    state,
+    viewer,
+    xl1ChainId,
+    xl1TokenAddress
+  } = ctx;
+  const canonical = assertEx18(state.canonical, () => "buildAndSubmitFreshAttempt requires canonical");
+  const fees = calculateBridgeFees(toHex6(canonical.amount), getFeeStructure(config));
+  const feesAmount = hexToBigInt11(fees.feeFixed) + hexToBigInt11(fees.feeVariable);
+  const { feesAddress } = await getTransferAddresses(config);
   const sufficient = await validateSufficientXl1ReserveBalance({
     amount: canonical.amount,
     bridgeAccount: account,
@@ -853,11 +967,13 @@ async function buildAndSubmitFreshAttempt(ctx) {
     evmTokenAddress: canonical.destToken,
     evmTxHash: canonical.evmTxHash,
     exp,
+    feesAddress,
+    feesAmount,
     nbf,
     xl1ChainId,
     xl1TokenAddress
   });
-  const txHash = await PayloadBuilder10.hash(tx[0]);
+  const txHash = await PayloadBuilder11.hash(tx[0]);
   state.currentAttempt = {
     exp: head + EXP_BLOCKS_AHEAD,
     nbf: head,
@@ -866,12 +982,19 @@ async function buildAndSubmitFreshAttempt(ctx) {
   };
   await fulfillmentMap.set(identity, state);
   await submitXl1Transaction(tx, [], gateway);
-  await job.log(`[${identity}] attempt ${state.previousAttempts.length + 1} submitted: txHash=${txHash} nbf=${head} exp=${head + EXP_BLOCKS_AHEAD}`);
+  await job.log(
+    `[${identity}] attempt ${state.previousAttempts.length + 1} submitted: txHash=${txHash} nbf=${head} exp=${head + EXP_BLOCKS_AHEAD}`
+  );
 }
-__name(buildAndSubmitFreshAttempt, "buildAndSubmitFreshAttempt");
 async function pollUntilIncludedOrExpired(ctx) {
-  const { fulfillmentMap, identity, job, state, viewer } = ctx;
-  const attempt = assertEx17(state.currentAttempt, () => "pollUntilIncludedOrExpired requires currentAttempt");
+  const {
+    fulfillmentMap,
+    identity,
+    job,
+    state,
+    viewer
+  } = ctx;
+  const attempt = assertEx18(state.currentAttempt, () => "pollUntilIncludedOrExpired requires currentAttempt");
   while (true) {
     const found = await viewer.transaction.byHash(attempt.txHash);
     if (isDefined9(found) && !isNull2(found)) {
@@ -893,54 +1016,80 @@ async function pollUntilIncludedOrExpired(ctx) {
     await delay(POLL_INTERVAL_MS);
   }
 }
-__name(pollUntilIncludedOrExpired, "pollUntilIncludedOrExpired");
-var createWorker7 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const svc = assertEx17(services, () => "services not provided");
-  const { account, bridgeFulfillmentMap, gateway } = svc;
-  const worker = new Worker7(queueName7, async (job) => {
-    const { bridgeId, contractAddress, evmChainId, identity, xl1ChainId, xl1TokenAddress } = job.data;
-    const initialState = await bridgeFulfillmentMap.get(identity);
-    if (initialState?.fulfilled) {
-      await job.log(`[${identity}] already fulfilled \u2014 skipping`);
-      return;
-    }
-    const state = assertEx17(initialState, () => `[${identity}] no fulfillment state \u2014 Stage 1 did not run`);
-    assertEx17(state.canonical, () => `[${identity}] canonical missing \u2014 Stage 1 did not write canonical`);
-    if (state.failed) {
-      state.failed = void 0;
-      await bridgeFulfillmentMap.set(identity, state);
-    }
-    const viewer = assertEx17(gateway.connection.viewer, () => `[${identity}] gateway viewer not available`);
-    const ctx = {
-      fulfillmentMap: bridgeFulfillmentMap,
-      identity,
-      job,
-      state,
-      viewer
-    };
-    if (state.currentAttempt) {
-      await tryResumeCurrentAttempt(ctx);
-      if (state.fulfilled) return;
-    }
-    if (!state.currentAttempt) {
-      await buildAndSubmitFreshAttempt({
-        ...ctx,
-        account,
-        bridgeId: BigInt(bridgeId),
+var createWorker7 = (connection2, telemetry2, services) => {
+  const svc = assertEx18(services, () => "services not provided");
+  const {
+    account,
+    bridgeFulfillmentMap,
+    config,
+    gateway
+  } = svc;
+  const worker = new Worker7(
+    queueName7,
+    async (job) => {
+      const {
+        bridgeId,
         contractAddress,
         evmChainId,
-        gateway,
+        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,
+          contractAddress,
+          evmChainId,
+          gateway,
+          xl1ChainId,
+          xl1TokenAddress
+        });
+      }
+      await pollUntilIncludedOrExpired(ctx);
+    },
+    {
+      concurrency: CONCURRENCY,
+      connection: connection2,
+      prefix,
+      telemetry: telemetry2
     }
-    await pollUntilIncludedOrExpired(ctx);
-  }, {
-    concurrency: CONCURRENCY,
-    connection: connection2,
-    prefix,
-    telemetry: telemetry2
-  });
+  );
   worker.on("failed", async (job, err) => {
     if (!isDefined9(job)) return;
     const attemptsAllowed = job.opts.attempts ?? Infinity;
@@ -958,7 +1107,7 @@ var createWorker7 = /* @__PURE__ */ __name((connection2, telemetry2, services) =
   worker.on("error", (err) => {
     console.error(`[${name7}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var Xl1ReserveTxFulfillment = {
   createWorker: createWorker7,
   name: name7,
@@ -969,23 +1118,27 @@ var Xl1ReserveTxFulfillment = {
 import { Worker as Worker8 } from "bullmq";
 var name8 = "Bridge XL1 to Ethereum";
 var queueName8 = "xl1-to-eth-bridge";
-var createWorker8 = /* @__PURE__ */ __name((connection2, telemetry2) => {
-  const worker = new Worker8(queueName8, async (job) => {
-    await job.log(`[${job.name}] start`);
-    await job.log(`[${job.name}] done`);
-    return {};
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+var createWorker8 = (connection2, telemetry2) => {
+  const worker = new Worker8(
+    queueName8,
+    async (job) => {
+      await job.log(`[${job.name}] start`);
+      await job.log(`[${job.name}] done`);
+      return {};
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
+    }
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name8}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name8}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var Xl1ToEthBridgeParent = {
   createWorker: createWorker8,
   name: name8,
@@ -993,48 +1146,56 @@ var Xl1ToEthBridgeParent = {
 };
 
 // src/services/queue/workers/Xl1TransactionMonitor.ts
-import { assertEx as assertEx18, isDefined as isDefined10, isNull as isNull3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
+import {
+  assertEx as assertEx19,
+  isDefined as isDefined10,
+  isNull as isNull3
+} from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/sdk-js";
 import { UnrecoverableError as UnrecoverableError2, Worker as Worker9 } from "bullmq";
 var name9 = "Monitor Submitted XL1 Transaction";
 var queueName9 = "xl1-tx-monitor";
-var createWorker9 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const gateway = assertEx18(services?.gateway, () => "gateway service not provided");
-  const stateMap = assertEx18(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
-  const viewer = assertEx18(gateway.connection.viewer, () => "viewer not defined on gateway");
-  const worker = new Worker9(queueName9, async (job) => {
-    const { tx } = job.data;
-    const hash = await PayloadBuilder11.hash(tx[0]);
-    const state = assertEx18(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const submissionHash = assertEx18(state.submissionHash, () => `[${hash}] submissionHash not found`);
-    await job.log(`[${hash}] Checking for XL1 transaction inclusion on chain`);
-    const foundTx = await viewer.transaction.byHash(submissionHash);
-    if (isDefined10(foundTx) && !isNull3(foundTx)) {
-      await job.log(`[${hash}] Found transaction on chain`);
-      const submissionHash2 = await PayloadBuilder11.hash(foundTx[0]);
-      return {
-        submissionHash: submissionHash2
-      };
-    }
-    const currentBlockNumber = await viewer.currentBlockNumber();
-    if (tx[0].exp < currentBlockNumber) {
-      await job.log(`[${hash}] Transaction expired at block ${tx[0].exp}, current block ${currentBlockNumber}`);
-      throw new UnrecoverableError2(`[${hash}] Transaction expired and will never be included`);
+var createWorker9 = (connection2, telemetry2, services) => {
+  const gateway = 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 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`);
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    await job.log(`[${hash}] Transaction not yet included, retrying later`);
-    throw new Error(`[${hash}] Transaction not yet included`);
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name9}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name9}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var Xl1TransactionMonitor = {
   createWorker: createWorker9,
   name: name9,
@@ -1042,40 +1203,39 @@ var Xl1TransactionMonitor = {
 };
 
 // src/services/queue/workers/Xl1TransactionPreparation.ts
-import { assertEx as assertEx19 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/sdk-js";
+import { assertEx as assertEx20 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/sdk-js";
 import { Worker as Worker10 } from "bullmq";
 var name10 = "Prepare XL1 Transaction";
 var queueName10 = "xl1-tx-prepare";
-var createWorker10 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const stateMap = assertEx19(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
-  const worker = new Worker10(queueName10, async (job) => {
-    const { tx, offChainPayloads = [] } = job.data;
-    const hash = await PayloadBuilder12.hash(tx[0]);
-    await job.log(`[${hash}] preparing XL1 transaction`);
-    const preparedTx = tx;
-    await job.log(`[${hash}] storing XL1 preparedTx`);
-    await stateMap.set(hash, {
-      offChainPayloads,
-      preparedTx
-    });
-    await job.log(`[${hash}] stored XL1 preparedTx`);
-    await job.log(`[${hash}] prepared XL1 transaction`);
-    return {
-      preparedTx
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+var createWorker10 = (connection2, telemetry2, services) => {
+  const stateMap = assertEx20(services?.xl1TxStateMap, () => "xl1TxStateMap 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 };
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
+    }
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name10}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name10}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var Xl1TransactionPreparation = {
   createWorker: createWorker10,
   name: name10,
@@ -1083,44 +1243,48 @@ var Xl1TransactionPreparation = {
 };
 
 // src/services/queue/workers/Xl1TransactionSubmission.ts
-import { assertEx as assertEx20, isDefined as isDefined11 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/sdk-js";
+import { assertEx as assertEx21, isDefined as isDefined11 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/sdk-js";
 import { Worker as Worker11 } from "bullmq";
 var name11 = "Submit XL1 Transaction";
 var queueName11 = "xl1-tx-submit";
-var createWorker11 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const gateway = assertEx20(services?.gateway, () => "gateway service not provided");
-  const stateMap = assertEx20(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
-  const worker = new Worker11(queueName11, async (job) => {
-    const { tx } = job.data;
-    const hash = await PayloadBuilder13.hash(tx[0]);
-    const state = assertEx20(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const { preparedTx, offChainPayloads = [], submissionHash: existingSubmissionHash } = state;
-    if (isDefined11(existingSubmissionHash)) {
-      await job.log(`[${hash}] Tx already submitted with submission response hash ${existingSubmissionHash}`);
-      return {
+var createWorker11 = (connection2, telemetry2, services) => {
+  const gateway = assertEx21(services?.gateway, () => "gateway service not provided");
+  const stateMap = assertEx21(services?.xl1TxStateMap, () => "xl1TxStateMap 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 };
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    const txToSubmit = assertEx20(preparedTx, () => `[${hash}] preparedTx not found`);
-    await job.log(`[${hash}] Submitting XL1 tx`);
-    const [submissionHash] = await submitXl1Transaction(txToSubmit, offChainPayloads, gateway);
-    await job.log(`[${hash}] Submitted XL1 tx`);
-    return {
-      submissionHash
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name11}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name11}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var Xl1TransactionSubmission = {
   createWorker: createWorker11,
   name: name11,
@@ -1128,48 +1292,48 @@ var Xl1TransactionSubmission = {
 };
 
 // src/services/queue/workers/Xl1TransactionSubmissionStorage.ts
-import { assertEx as assertEx21, isDefined as isDefined12 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/sdk-js";
+import { assertEx as assertEx22, isDefined as isDefined12 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/sdk-js";
 import { Worker as Worker12 } from "bullmq";
 var name12 = "Store XL1 Transaction Submission";
 var queueName12 = "xl1-tx-store-submission";
-var createWorker12 = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
-  const stateMap = assertEx21(services?.xl1TxStateMap, () => "xl1TxStateMap service not provided");
-  const worker = new Worker12(queueName12, async (job) => {
-    const { tx } = job.data;
-    const hash = await PayloadBuilder14.hash(tx[0]);
-    const state = assertEx21(await stateMap.get(hash), () => `[${hash}] state not found`);
-    const { submissionHash: existingSubmissionHash } = state;
-    if (isDefined12(existingSubmissionHash)) {
-      await job.log(`[${hash}] submissionHash already stored as ${existingSubmissionHash}`);
-      return {
-        submissionHash: existingSubmissionHash
-      };
+var createWorker12 = (connection2, telemetry2, services) => {
+  const stateMap = assertEx22(services?.xl1TxStateMap, () => "xl1TxStateMap 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 };
+    },
+    {
+      connection: connection2,
+      telemetry: telemetry2,
+      prefix
     }
-    const childrenValues = await job.getChildrenValues();
-    const jobKey = `${prefix}:${Xl1TransactionSubmission.queueName}:${hash}`;
-    const childValues = childrenValues?.[jobKey];
-    const submissionHash = childValues?.submissionHash;
-    const resolvedSubmissionHash = assertEx21(submissionHash, () => `[${hash}] child submissionHash not found in children values`);
-    await job.log(`[${hash}] Storing XL1 submissionHash`);
-    state.submissionHash = resolvedSubmissionHash;
-    await stateMap.set(hash, state);
-    await job.log(`[${hash}] Stored XL1 submissionHash`);
-    return {
-      submissionHash: resolvedSubmissionHash
-    };
-  }, {
-    connection: connection2,
-    telemetry: telemetry2,
-    prefix
-  });
+  );
   worker.on("failed", (job, err) => {
     console.error(`[${name12}] Job ${job?.id} failed:`, err.message);
   });
   worker.on("error", (err) => {
     console.error(`[${name12}] Worker error:`, err);
   });
-}, "createWorker");
+};
 var Xl1TransactionSubmissionStorage = {
   createWorker: createWorker12,
   name: name12,
@@ -1177,7 +1341,7 @@ var Xl1TransactionSubmissionStorage = {
 };
 
 // src/services/queue/workers/createWorkers.ts
-var createWorkers = /* @__PURE__ */ __name((connection2, telemetry2, services) => {
+var createWorkers = (connection2, telemetry2, services) => {
   EthEventVerification.createWorker(connection2, telemetry2, services);
   EthToXl1BridgeParent.createWorker(connection2, telemetry2);
   EthTransactionMonitor.createWorker(connection2, telemetry2, services);
@@ -1190,13 +1354,12 @@ var createWorkers = /* @__PURE__ */ __name((connection2, telemetry2, services) =
   Xl1TransactionPreparation.createWorker(connection2, telemetry2, services);
   Xl1TransactionSubmission.createWorker(connection2, telemetry2, services);
   Xl1TransactionSubmissionStorage.createWorker(connection2, telemetry2, services);
-}, "createWorkers");
+};
 
 // src/services/queue/flows/createEthToXl1BridgeJob/getJobIdForEthToXl1BridgeJob.ts
 function getJobIdForEthToXl1BridgeJob(context) {
-  return `evm:${context.evmChainId.toLowerCase()}:${context.contractAddress.toLowerCase()}:${context.bridgeId.toString()}`;
+  return `evm-${context.evmChainId.toLowerCase()}-${context.contractAddress.toLowerCase()}-${context.bridgeId.toString()}`;
 }
-__name(getJobIdForEthToXl1BridgeJob, "getJobIdForEthToXl1BridgeJob");
 
 // src/services/queue/flows/createEthToXl1BridgeJob/createEthToXl1BridgeJob.ts
 var STAGE_2_RETRY = {
@@ -1206,10 +1369,8 @@ var STAGE_2_RETRY = {
     type: "fixed"
   }
 };
-var STAGE_1_RETRY = {
-  attempts: 1
-};
-var createEthToXl1BridgeJob = /* @__PURE__ */ __name(async (flowProducer2, context) => {
+var STAGE_1_RETRY = { attempts: 1 };
+var createEthToXl1BridgeJob = async (flowProducer2, context) => {
   const jobId = getJobIdForEthToXl1BridgeJob(context);
   const identity = jobId;
   const stageJobData = {
@@ -1224,175 +1385,121 @@ var createEthToXl1BridgeJob = /* @__PURE__ */ __name(async (flowProducer2, conte
     name: EthToXl1BridgeParent.name,
     queueName: EthToXl1BridgeParent.queueName,
     data: stageJobData,
-    opts: {
-      jobId
-    },
+    opts: { jobId },
     children: [
       {
         name: Xl1ReserveTxFulfillment.name,
         queueName: Xl1ReserveTxFulfillment.queueName,
         data: stageJobData,
-        opts: {
-          jobId,
-          ...STAGE_2_RETRY
-        },
+        opts: { jobId, ...STAGE_2_RETRY },
         children: [
           {
             name: EthEventVerification.name,
             queueName: EthEventVerification.queueName,
             data: stageJobData,
-            opts: {
-              jobId,
-              ...STAGE_1_RETRY
-            }
+            opts: { jobId, ...STAGE_1_RETRY }
           }
         ]
       }
     ]
   });
-}, "createEthToXl1BridgeJob");
+};
 
 // src/services/queue/flows/createXl1ToEthBridgeJob/getJobIdForXl1ToEthBridgeJob.ts
-import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/sdk-js";
-var getJobIdForXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (tx) => {
-  const jobId = await PayloadBuilder15.hash(tx[0]);
+import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/sdk-js";
+var getJobIdForXl1ToEthBridgeJob = async (tx) => {
+  const jobId = await PayloadBuilder16.hash(tx[0]);
   return jobId;
-}, "getJobIdForXl1ToEthBridgeJob");
+};
 
 // src/services/queue/flows/createXl1ToEthBridgeJob/createXl1ToEthBridgeJob.ts
-var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx, offChainPayloads = []) => {
+var createXl1ToEthBridgeJob = async (flowProducer2, tx, offChainPayloads = []) => {
   const jobId = await getJobIdForXl1ToEthBridgeJob(tx);
   const flow = await flowProducer2.add({
     // Step 0 (runs first as parent job)
     name: Xl1ToEthBridgeParent.name,
     queueName: Xl1ToEthBridgeParent.queueName,
-    data: {
-      tx,
-      offChainPayloads
-    },
-    opts: {
-      jobId
-    },
+    data: { tx, offChainPayloads },
+    opts: { jobId },
     children: [
       {
         // Step 8
         name: EthTransactionMonitor.name,
         queueName: EthTransactionMonitor.queueName,
-        data: {
-          tx
-        },
+        data: { tx },
         opts: {
           jobId,
           attempts: 60,
-          backoff: {
-            type: "fixed",
-            delay: 5e3
-          }
+          backoff: { type: "fixed", delay: 5e3 }
         },
         children: [
           {
             // Step 7
             name: EthTransactionSubmissionStorage.name,
             queueName: EthTransactionSubmissionStorage.queueName,
-            data: {
-              tx
-            },
+            data: { tx },
             opts: {
               jobId,
               attempts: 60,
-              backoff: {
-                type: "fixed",
-                delay: 5e3
-              }
+              backoff: { type: "fixed", delay: 5e3 }
             },
             children: [
               {
                 // Step 6
                 name: EthTransactionSubmission.name,
                 queueName: EthTransactionSubmission.queueName,
-                data: {
-                  tx,
-                  offChainPayloads
-                },
-                opts: {
-                  jobId
-                },
+                data: { tx, offChainPayloads },
+                opts: { jobId },
                 children: [
                   {
                     // Step 5
                     name: EthTransactionPreparation.name,
                     queueName: EthTransactionPreparation.queueName,
-                    data: {
-                      tx,
-                      offChainPayloads
-                    },
+                    data: { tx, offChainPayloads },
                     opts: {
                       jobId,
                       attempts: 60,
-                      backoff: {
-                        type: "fixed",
-                        delay: 5e3
-                      }
+                      backoff: { type: "fixed", delay: 5e3 }
                     },
                     children: [
                       {
                         // Step 4
                         name: Xl1TransactionMonitor.name,
                         queueName: Xl1TransactionMonitor.queueName,
-                        data: {
-                          tx
-                        },
+                        data: { tx },
                         opts: {
                           jobId,
                           attempts: 60,
-                          backoff: {
-                            type: "fixed",
-                            delay: 5e3
-                          }
+                          backoff: { type: "fixed", delay: 5e3 }
                         },
                         children: [
                           {
                             // Step 3
                             name: Xl1TransactionSubmissionStorage.name,
                             queueName: Xl1TransactionSubmissionStorage.queueName,
-                            data: {
-                              tx
-                            },
+                            data: { tx },
                             opts: {
                               jobId,
                               attempts: 60,
-                              backoff: {
-                                type: "fixed",
-                                delay: 5e3
-                              }
+                              backoff: { type: "fixed", delay: 5e3 }
                             },
                             children: [
                               {
                                 // Step 2
                                 name: Xl1TransactionSubmission.name,
                                 queueName: Xl1TransactionSubmission.queueName,
-                                data: {
-                                  tx
-                                },
-                                opts: {
-                                  jobId
-                                },
+                                data: { tx },
+                                opts: { jobId },
                                 children: [
                                   {
                                     // Step 1 (runs first as deepest child)
                                     name: Xl1TransactionPreparation.name,
                                     queueName: Xl1TransactionPreparation.queueName,
-                                    data: {
-                                      tx,
-                                      offChainPayloads
-                                    },
+                                    data: { tx, offChainPayloads },
                                     opts: {
                                       jobId,
                                       attempts: 60,
-                                      backoff: {
-                                        type: "fixed",
-                                        delay: 5e3
-                                      }
+                                      backoff: { type: "fixed", delay: 5e3 }
                                     }
                                   }
                                 ]
@@ -1412,44 +1519,41 @@ var createXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx, o
     ]
   });
   return flow;
-}, "createXl1ToEthBridgeJob");
+};
 
 // src/services/queue/flows/createXl1ToEthBridgeJob/getXl1ToEthBridgeJob.ts
-var getXl1ToEthBridgeJob = /* @__PURE__ */ __name(async (flowProducer2, tx) => {
+var getXl1ToEthBridgeJob = async (flowProducer2, tx) => {
   const id = await getJobIdForXl1ToEthBridgeJob(tx);
-  const flow = await flowProducer2.getFlow({
-    queueName: Xl1ToEthBridgeParent.queueName,
-    id
-  });
+  const flow = await flowProducer2.getFlow({ queueName: Xl1ToEthBridgeParent.queueName, id });
   return flow;
-}, "getXl1ToEthBridgeJob");
+};
 
 // src/services/queue/getEthToXl1Queues.ts
 import { Queue } from "bullmq";
 var ethToXl1Queues;
-var getEthToXl1Queues = /* @__PURE__ */ __name((config) => {
+var getEthToXl1Queues = (config) => {
   if (ethToXl1Queues) return ethToXl1Queues;
   const connection2 = getConnection(config);
   ethToXl1Queues = {
-    ethEventVerification: new Queue(EthEventVerification.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    ethToXl1BridgeParent: new Queue(EthToXl1BridgeParent.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1ReserveTxFulfillment: new Queue(Xl1ReserveTxFulfillment.queueName, {
-      connection: connection2,
-      prefix
-    })
+    ethEventVerification: new Queue(EthEventVerification.queueName, { connection: connection2, prefix }),
+    ethToXl1BridgeParent: new Queue(EthToXl1BridgeParent.queueName, { connection: connection2, prefix }),
+    xl1ReserveTxFulfillment: new Queue(Xl1ReserveTxFulfillment.queueName, { connection: connection2, prefix })
   };
   return ethToXl1Queues;
-}, "getEthToXl1Queues");
+};
 
 // src/services/queue/getXl1ToEthQueueJobs.ts
-var getStatusQueueJobs = /* @__PURE__ */ __name(async (queues, jobId) => {
-  const [ethTransactionMonitorJob, ethTransactionPreparationJob, ethTransactionSubmissionJob, xl1ToEthBridgeParentJob, xl1TransactionMonitorJob, xl1TransactionPreparationJob, xl1TransactionSubmissionJob, xl1TransactionSubmissionStorageJob] = await Promise.all([
+var getStatusQueueJobs = async (queues, jobId) => {
+  const [
+    ethTransactionMonitorJob,
+    ethTransactionPreparationJob,
+    ethTransactionSubmissionJob,
+    xl1ToEthBridgeParentJob,
+    xl1TransactionMonitorJob,
+    xl1TransactionPreparationJob,
+    xl1TransactionSubmissionJob,
+    xl1TransactionSubmissionStorageJob
+  ] = await Promise.all([
     queues.ethTransactionMonitor.getJob(jobId),
     queues.ethTransactionPreparation.getJob(jobId),
     queues.ethTransactionSubmission.getJob(jobId),
@@ -1469,54 +1573,36 @@ var getStatusQueueJobs = /* @__PURE__ */ __name(async (queues, jobId) => {
     xl1TransactionSubmissionStorageJob,
     xl1TransactionSubmissionJob
   };
-}, "getStatusQueueJobs");
+};
 
 // src/services/queue/getXl1ToEthQueues.ts
 import { Queue as Queue2 } from "bullmq";
 var xl1ToEthQueues;
-var getXl1ToEthQueues = /* @__PURE__ */ __name((config) => {
+var getXl1ToEthQueues = (config) => {
   if (xl1ToEthQueues) return xl1ToEthQueues;
   const connection2 = getConnection(config);
   xl1ToEthQueues = {
-    ethTransactionMonitor: new Queue2(EthTransactionMonitor.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    ethTransactionPreparation: new Queue2(EthTransactionPreparation.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    ethTransactionSubmission: new Queue2(EthTransactionSubmission.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1ToEthBridgeParent: new Queue2(Xl1ToEthBridgeParent.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1TransactionMonitor: new Queue2(Xl1TransactionMonitor.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1TransactionPreparation: new Queue2(Xl1TransactionPreparation.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1TransactionSubmission: new Queue2(Xl1TransactionSubmission.queueName, {
-      connection: connection2,
-      prefix
-    }),
-    xl1TransactionSubmissionStorage: new Queue2(Xl1TransactionSubmissionStorage.queueName, {
-      connection: connection2,
-      prefix
-    })
+    ethTransactionMonitor: new Queue2(EthTransactionMonitor.queueName, { connection: connection2, prefix }),
+    ethTransactionPreparation: new Queue2(EthTransactionPreparation.queueName, { connection: connection2, prefix }),
+    ethTransactionSubmission: new Queue2(EthTransactionSubmission.queueName, { connection: connection2, prefix }),
+    xl1ToEthBridgeParent: new Queue2(Xl1ToEthBridgeParent.queueName, { connection: connection2, prefix }),
+    xl1TransactionMonitor: new Queue2(Xl1TransactionMonitor.queueName, { connection: connection2, prefix }),
+    xl1TransactionPreparation: new Queue2(Xl1TransactionPreparation.queueName, { connection: connection2, prefix }),
+    xl1TransactionSubmission: new Queue2(Xl1TransactionSubmission.queueName, { connection: connection2, prefix }),
+    xl1TransactionSubmissionStorage: new Queue2(Xl1TransactionSubmissionStorage.queueName, { connection: connection2, prefix })
   };
   return xl1ToEthQueues;
-}, "getXl1ToEthQueues");
+};
 
 // src/services/queue/scanner/createEnqueueEthToXl1Bridge.ts
 function createEnqueueEthToXl1Bridge(options2) {
-  const { evmChainId, evmContractAddress, flowProducer: flowProducer2, xl1ChainId, xl1TokenAddress } = options2;
+  const {
+    evmChainId,
+    evmContractAddress,
+    flowProducer: flowProducer2,
+    xl1ChainId,
+    xl1TokenAddress
+  } = options2;
   return async (bridgeId, jobLog) => {
     await createEthToXl1BridgeJob(flowProducer2, {
       bridgeId,
@@ -1528,7 +1614,6 @@ function createEnqueueEthToXl1Bridge(options2) {
     await jobLog?.(`[bridge-scanner] bridgeId ${bridgeId} enqueued`);
   };
 }
-__name(createEnqueueEthToXl1Bridge, "createEnqueueEthToXl1Bridge");
 
 // src/services/queue/scanner/EvmBridgeScanner.ts
 import { isUndefined as isUndefined2 } from "@xylabs/sdk-js";
@@ -1537,19 +1622,24 @@ import { isUndefined as isUndefined2 } from "@xylabs/sdk-js";
 function getEvmBridgeCursorKey(chainId, contractAddress) {
   return `${chainId.toLowerCase()}:${contractAddress.toLowerCase()}`;
 }
-__name(getEvmBridgeCursorKey, "getEvmBridgeCursorKey");
 
 // src/services/queue/scanner/EvmBridgeScanner.ts
 function createEvmBridgeScanner(options2) {
-  const { bridge, bridgeAddress, chainId, confirmationDepth, cursors, enqueue, provider } = options2;
+  const {
+    bridge,
+    bridgeAddress,
+    chainId,
+    confirmationDepth,
+    cursors,
+    enqueue,
+    provider
+  } = options2;
   const cursorKey = getEvmBridgeCursorKey(chainId, bridgeAddress);
   return {
     async scan(options3) {
       const jobLog = options3?.jobLog;
       const blockTag = await resolveEvmBlockTagAtDepth(provider, confirmationDepth);
-      const confirmedHigh = await bridge.nextBridgeToId({
-        blockTag
-      });
+      const confirmedHigh = await bridge.nextBridgeToId({ blockTag });
       const cursor = await cursors.get(cursorKey);
       const lastProcessedId = isUndefined2(cursor) ? 0n : BigInt(cursor.lastProcessedId);
       if (confirmedHigh <= lastProcessedId) {
@@ -1564,9 +1654,7 @@ function createEvmBridgeScanner(options2) {
         await enqueue(id, jobLog);
         enqueued++;
       }
-      await cursors.set(cursorKey, {
-        lastProcessedId: confirmedHigh.toString()
-      });
+      await cursors.set(cursorKey, { lastProcessedId: confirmedHigh.toString() });
       return {
         confirmedHigh,
         enqueued,
@@ -1575,7 +1663,6 @@ function createEvmBridgeScanner(options2) {
     }
   };
 }
-__name(createEvmBridgeScanner, "createEvmBridgeScanner");
 
 // src/services/queue/scanner/EvmBridgeScannerRunner.ts
 import { Queue as Queue3, Worker as Worker13 } from "bullmq";
@@ -1583,7 +1670,12 @@ var QUEUE_NAME = "eth-to-xl1-scanner";
 var REPEATABLE_JOB_NAME = "scan";
 var REPEATABLE_JOB_ID = "eth-to-xl1-scanner-tick";
 function createEvmBridgeScannerRunner(options2) {
-  const { connection: connection2, intervalMs, scanner, telemetry: telemetry2 } = options2;
+  const {
+    connection: connection2,
+    intervalMs,
+    scanner,
+    telemetry: telemetry2
+  } = options2;
   const logger = options2.logger ?? console;
   let queue;
   let worker;
@@ -1596,10 +1688,10 @@ function createEvmBridgeScannerRunner(options2) {
       });
       worker = new Worker13(QUEUE_NAME, async (job) => {
         await job.log("[scanner] tick start");
-        const result = await scanner.scan({
-          jobLog: /* @__PURE__ */ __name((msg) => job.log(msg), "jobLog")
-        });
-        await job.log(`[scanner] tick complete: enqueued=${result.enqueued} confirmedHigh=${result.confirmedHigh.toString()} lastProcessedId=${result.lastProcessedId.toString()}`);
+        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()}`
+        );
       }, {
         connection: connection2,
         prefix,
@@ -1613,9 +1705,7 @@ function createEvmBridgeScannerRunner(options2) {
       });
       await queue.add(REPEATABLE_JOB_NAME, {}, {
         jobId: REPEATABLE_JOB_ID,
-        repeat: {
-          every: intervalMs
-        }
+        repeat: { every: intervalMs }
       });
     },
     async stop() {
@@ -1626,11 +1716,17 @@ function createEvmBridgeScannerRunner(options2) {
     }
   };
 }
-__name(createEvmBridgeScannerRunner, "createEvmBridgeScannerRunner");
 
 // src/services/queue/scanner/buildEvmBridgeScannerRunner.ts
 function buildEvmBridgeScannerRunner(options2) {
-  const { config, connection: connection2, flowProducer: flowProducer2, logger, services, telemetry: telemetry2 } = options2;
+  const {
+    config,
+    connection: connection2,
+    flowProducer: flowProducer2,
+    logger,
+    services,
+    telemetry: telemetry2
+  } = options2;
   const evmChainId = getRemoteChainId(config);
   const evmContractAddress = config.remoteBridgeContractAddress;
   const xl1ChainId = getXl1ChainId(config);
@@ -1660,100 +1756,95 @@ function buildEvmBridgeScannerRunner(options2) {
     telemetry: telemetry2
   });
 }
-__name(buildEvmBridgeScannerRunner, "buildEvmBridgeScannerRunner");
 
 // src/services/queue/telemetry.ts
 import { isDefined as isDefined13 } from "@xylabs/sdk-js";
 import { BullMQOtel } from "bullmq-otel";
 var telemetry;
-var options = {
-  enableMetrics: true
-};
-var getTelemetry = /* @__PURE__ */ __name(() => {
+var options = { enableMetrics: true };
+var getTelemetry = () => {
   if (isDefined13(telemetry)) return telemetry;
   telemetry = new BullMQOtel(options);
   return telemetry;
-}, "getTelemetry");
+};
 
 // src/server/addFlowProducer.ts
-var addFlowProducer = /* @__PURE__ */ __name((app, config) => {
+var addFlowProducer = (app, config) => {
   const connection2 = getConnection(config);
   const telemetry2 = getTelemetry();
   const flowProducer2 = getFlowProducer(connection2, telemetry2);
   app.flowProducer = flowProducer2;
   return app;
-}, "addFlowProducer");
+};
 
 // src/server/instrumentation.ts
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
 import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
 import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
-var addInstrumentation = /* @__PURE__ */ __name(() => {
-  const instrumentations = [
-    new HttpInstrumentation(),
-    new ExpressInstrumentation()
-  ];
-  registerInstrumentations({
-    instrumentations
-  });
-}, "addInstrumentation");
+var addInstrumentation = () => {
+  const instrumentations = [new HttpInstrumentation(), new ExpressInstrumentation()];
+  registerInstrumentations({ instrumentations });
+};
 
 // src/server/routes/livez/get.ts
 import { setRawResponseFormat } from "@xylabs/express";
 import { ReasonPhrases } from "http-status-codes";
 var message = ReasonPhrases.OK;
-var handler = /* @__PURE__ */ __name((_req, res) => {
+var handler = (_req, res) => {
   setRawResponseFormat(res);
-  res.status(200).send({
-    message
-  });
-}, "handler");
+  res.status(200).send({ message });
+};
 var getLivez = handler;
 
 // src/server/routes/readyz/get.ts
 import { setRawResponseFormat as setRawResponseFormat2 } from "@xylabs/express";
 import { ReasonPhrases as ReasonPhrases2 } from "http-status-codes";
 var message2 = ReasonPhrases2.OK;
-var handler2 = /* @__PURE__ */ __name((_req, res) => {
+var handler2 = (_req, res) => {
   setRawResponseFormat2(res);
-  res.status(200).send({
-    message: message2
-  });
-}, "handler");
+  res.status(200).send({ message: message2 });
+};
 var getReadyz = handler2;
 
 // src/server/routes/startupz/get.ts
 import { setRawResponseFormat as setRawResponseFormat3 } from "@xylabs/express";
 import { ReasonPhrases as ReasonPhrases3 } from "http-status-codes";
 var message3 = ReasonPhrases3.OK;
-var handler3 = /* @__PURE__ */ __name((_req, res) => {
+var handler3 = (_req, res) => {
   setRawResponseFormat3(res);
-  res.status(200).send({
-    message: message3
-  });
-}, "handler");
+  res.status(200).send({ message: message3 });
+};
 var getStartupz = handler3;
 
 // src/server/routes/addProbeRoutes.ts
-var addProbeRoutes = /* @__PURE__ */ __name((app) => {
+var addProbeRoutes = (app) => {
   app.get("/livez", getLivez);
   app.get("/readyz", getReadyz);
   app.get("/startupz", getStartupz);
-}, "addProbeRoutes");
+};
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeConfig.ts
 import { requestHandlerValidator } from "@xylabs/express";
 import { BridgeSettingsZod } from "@xyo-network/chain-orchestration";
 var BridgeConfigResponseZod = BridgeSettingsZod;
-var validateRequest = requestHandlerValidator({
-  response: BridgeConfigResponseZod
-});
-var makeBridgeConfigRoute = /* @__PURE__ */ __name((config) => {
+var validateRequest = requestHandlerValidator({ response: BridgeConfigResponseZod });
+var makeBridgeConfigRoute = (config) => {
   return {
     method: "get",
     path: "/bridge/chains/:chainId/config",
     handlers: validateRequest(async (_, res) => {
-      const { escrowAddress, feeFixed, feeRateBasisPoints, feesAddress, maxBridgeAmount, minBridgeAmount, remoteChainId, remoteTokenAddress, xl1ChainId, xl1TokenAddress } = await getBridgeSettings(config);
+      const {
+        escrowAddress,
+        feeFixed,
+        feeRateBasisPoints,
+        feesAddress,
+        maxBridgeAmount,
+        minBridgeAmount,
+        remoteChainId,
+        remoteTokenAddress,
+        xl1ChainId,
+        xl1TokenAddress
+      } = await getBridgeSettings(config);
       const sanitizedConfig = {
         escrowAddress,
         feeFixed,
@@ -1769,18 +1860,33 @@ var makeBridgeConfigRoute = /* @__PURE__ */ __name((config) => {
       res.json(sanitizedConfig);
     })
   };
-}, "makeBridgeConfigRoute");
+};
 
-// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
+// src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteEstimate.ts
 import { requestHandlerValidator as requestHandlerValidator2 } from "@xylabs/express";
-import { isDefined as isDefined14, toHex as toHex4 } from "@xylabs/sdk-js";
+import {
+  assertEx as assertEx23,
+  hexToBigInt as hexToBigInt12,
+  toAddress as toAddress3
+} from "@xylabs/sdk-js";
 import { PayloadZodStrictOfSchema } from "@xyo-network/sdk-js";
-import { BridgeDestinationObservationFieldsZod, BridgeDestinationObservationSchema, BridgeIntentFieldsZod, BridgeIntentSchema as BridgeIntentSchema4, BridgeSourceObservationFieldsZod, BridgeSourceObservationSchema as BridgeSourceObservationSchema2 } from "@xyo-network/xl1-sdk";
+import {
+  BridgeIntentFieldsZod,
+  BridgeIntentSchema as BridgeIntentSchema4,
+  buildUnsignedTransaction,
+  toXL1BlockNumber,
+  TransactionBoundWitnessZod,
+  TransferZod
+} from "@xyo-network/xl1-sdk";
 import { z } from "zod";
 
 // src/server/routes/bridge/routeDefinitions/pathParams/ChainIdPathParam.ts
-import { asHex as asHex3, HexZod, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
-var getRemoteChainIdZod = /* @__PURE__ */ __name((config) => {
+import {
+  asHex as asHex3,
+  HexZod,
+  isUndefined as isUndefined3
+} from "@xylabs/sdk-js";
+var getRemoteChainIdZod = (config) => {
   const remoteChainId = getRemoteChainId(config);
   return HexZod.superRefine((val, ctx) => {
     const chainId = asHex3(val);
@@ -1792,72 +1898,145 @@ var getRemoteChainIdZod = /* @__PURE__ */ __name((config) => {
       ctx.addIssue(`Only ${remoteChainId} is supported`);
     }
   });
-}, "getRemoteChainIdZod");
+};
+
+// 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 validateRequest2 = requestHandlerValidator2({
+    params,
+    body: BridgeFromRemoteEstimateBodyZod,
+    response: BridgeFromRemoteEstimateResponseZod
+  });
+  return {
+    method: "post",
+    path: "/bridge/chains/:chainId/bridgeFromRemote/estimate",
+    handlers: validateRequest2(async (req, res) => {
+      const services = req.app.services;
+      const {
+        account,
+        bridge,
+        gateway
+      } = services;
+      const {
+        srcAddress,
+        srcAmount,
+        destAddress
+      } = req.body;
+      const { maxBridgeAmount, minBridgeAmount } = await getBridgeSettings(config);
+      if (hexToBigInt12(srcAmount) < hexToBigInt12(minBridgeAmount) || hexToBigInt12(srcAmount) > hexToBigInt12(maxBridgeAmount)) {
+        res.status(400).send();
+        return;
+      }
+      const fees = calculateBridgeFees(srcAmount, getFeeStructure(config));
+      const feesAmount = hexToBigInt12(fees.feeFixed) + hexToBigInt12(fees.feeVariable);
+      const { feesAddress } = await getTransferAddresses(config);
+      const currentNextId = await bridge.nextBridgeToId({ blockTag: "latest" });
+      const projectedBridgeId = currentNextId + 1n;
+      const xl1ChainId = getXl1ChainId(config);
+      const xl1TokenAddress = getXl1TokenAddress(config);
+      const evmChainId = config.remoteChainId;
+      const evmContractAddress = config.remoteBridgeContractAddress;
+      const evmTokenAddress = getRemoteTokenAddress(config);
+      const viewer = assertEx23(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),
+        bridgeAccountAddress: account.address,
+        bridgeId: projectedBridgeId,
+        destAddress: toAddress3(destAddress),
+        evmChainId,
+        evmContractAddress,
+        evmSrcAddress: toAddress3(srcAddress),
+        evmTokenAddress,
+        feesAddress,
+        feesAmount,
+        xl1ChainId,
+        xl1TokenAddress
+      });
+      const [txBw] = await buildUnsignedTransaction(xl1ChainId, [transfer], [intent], nbf, exp, account.address);
+      res.json([txBw, intent, transfer]);
+    })
+  };
+};
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeFromRemoteStatus.ts
-var BridgeIntentResponseZod = PayloadZodStrictOfSchema(BridgeIntentSchema4).extend(BridgeIntentFieldsZod.shape);
-var BridgeSourceResponseZod = PayloadZodStrictOfSchema(BridgeSourceObservationSchema2).extend(BridgeSourceObservationFieldsZod.shape);
-var BridgeDestinationResponseZod = PayloadZodStrictOfSchema(BridgeDestinationObservationSchema).extend(BridgeDestinationObservationFieldsZod.shape);
-var BridgeFromRemoteStatusResponseZod = z.union([
-  z.tuple([]),
-  z.tuple([
-    BridgeIntentResponseZod
-  ]),
-  z.tuple([
-    BridgeIntentResponseZod,
-    BridgeSourceResponseZod
-  ]),
-  z.tuple([
-    BridgeIntentResponseZod,
-    BridgeSourceResponseZod,
-    BridgeDestinationResponseZod
-  ])
+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 amountHex = toHex4(canonical.amount);
+  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 = BridgeIntentFieldsZod.parse({
+  const intentFields = BridgeIntentFieldsZod2.parse({
     dest: xl1ChainId,
     destAddress: canonical.destAddress,
-    destAmount: amountHex,
+    destAmount: destAmountHex,
     destToken: xl1TokenAddress,
     nonce,
     src: evmChainId,
     srcAddress: canonical.srcAddress,
-    srcAmount: amountHex,
+    srcAmount: srcAmountHex,
     srcToken: evmTokenAddress
   });
-  const intent = {
-    schema: BridgeIntentSchema4,
-    ...intentFields
-  };
+  const intent = { schema: BridgeIntentSchema5, ...intentFields };
   const sourceFields = BridgeSourceObservationFieldsZod.parse({
     ...intentFields,
     srcConfirmation: canonical.evmTxHash
   });
-  const source = {
-    schema: BridgeSourceObservationSchema2,
-    ...sourceFields
-  };
-  return [
-    intent,
-    source
-  ];
+  const source = { schema: BridgeSourceObservationSchema2, ...sourceFields };
+  return [intent, source];
 }
-__name(buildIntentAndSource, "buildIntentAndSource");
-var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
-  const params = z.object({
+var makeBridgeFromRemoteStatusRoute = (config) => {
+  const params = z2.object({
     chainId: getRemoteChainIdZod(config),
-    nonce: z.string().regex(/^\d+$/, "nonce must be a non-negative integer (the bridge contract's id)")
-  });
-  const validateRequest2 = requestHandlerValidator2({
-    params,
-    response: BridgeFromRemoteStatusResponseZod
+    nonce: z2.string().regex(/^\d+$/, "nonce must be a non-negative integer (the bridge contract's id)")
   });
+  const validateRequest2 = requestHandlerValidator3({ params, response: BridgeFromRemoteStatusResponseZod });
   return {
     method: "get",
     path: "/bridge/chains/:chainId/bridgeFromRemote/status/:nonce",
@@ -1884,44 +2063,43 @@ var makeBridgeFromRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
         config,
         nonce: identity
       });
-      if (!state.fulfilled) return res.json([
-        intent,
-        source
-      ]);
+      if (!state.fulfilled) return res.json([intent, source]);
       const destinationFields = BridgeDestinationObservationFieldsZod.parse({
         ...intent,
         destConfirmation: state.fulfilled.txHash
       });
-      const destination = {
-        schema: BridgeDestinationObservationSchema,
-        ...destinationFields
-      };
-      res.json([
-        intent,
-        source,
-        destination
-      ]);
+      const destination = { schema: BridgeDestinationObservationSchema, ...destinationFields };
+      res.json([intent, source, destination]);
     })
   };
-}, "makeBridgeFromRemoteStatusRoute");
+};
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemote.ts
-import { requestHandlerValidator as requestHandlerValidator3 } from "@xylabs/express";
+import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
 import { isDefined as isDefined15 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder16, PayloadZodLooseOfSchema, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema2 } from "@xyo-network/sdk-js";
-import { BridgeIntentFieldsZod as BridgeIntentFieldsZod2, BridgeIntentSchema as BridgeIntentSchema5, BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod2, BridgeSourceObservationSchema as BridgeSourceObservationSchema3, SignedTransactionBoundWitnessZod, TransferZod } from "@xyo-network/xl1-sdk";
-import { z as z2 } from "zod";
-var BridgeToRemoteBodyZod = z2.tuple([
+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,
-  PayloadZodLooseOfSchema(BridgeIntentSchema5).extend(BridgeIntentFieldsZod2.shape),
-  TransferZod
+  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 = PayloadZodStrictOfSchema2(BridgeSourceObservationSchema3).extend(BridgeSourceObservationFieldsZod2.shape);
-var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
-  const params = z2.object({
-    chainId: getRemoteChainIdZod(config)
-  });
-  const validateRequest2 = requestHandlerValidator3({
+var BridgeToRemoteResponseZod = PayloadZodStrictOfSchema3(BridgeSourceObservationSchema3).extend(BridgeSourceObservationFieldsZod2.shape);
+var makeBridgeToRemoteRoute = (config) => {
+  const params = z3.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator4({
     params,
     body: BridgeToRemoteBodyZod,
     response: BridgeToRemoteResponseZod
@@ -1948,56 +2126,55 @@ var makeBridgeToRemoteRoute = /* @__PURE__ */ __name((config) => {
         res.status(400).send();
         return;
       }
-      const singedHydratedTransaction = [
-        signedTxBw,
-        [
-          transfer
-        ]
-      ];
+      const singedHydratedTransaction = [signedTxBw, [transfer]];
       const existingFlow = await getXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction);
       if (isDefined15(existingFlow)) {
         res.status(200).send();
         return;
       }
-      await createXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction, [
-        bridgeIntent
-      ]);
-      const srcConfirmation = await PayloadBuilder16.hash(signedTxBw);
-      const bridgeCommonFieldsZod = z2.object({}).extend(BridgeSourceObservationFieldsZod2.shape);
+      await createXl1ToEthBridgeJob(flowProducer2, singedHydratedTransaction, [bridgeIntent]);
+      const srcConfirmation = await PayloadBuilder17.hash(signedTxBw);
+      const bridgeCommonFieldsZod = z3.object({}).extend(BridgeSourceObservationFieldsZod2.shape);
       const bridgeCommonFields = bridgeCommonFieldsZod.parse(bridgeIntent);
-      const bridgeObservationFields = {
-        ...bridgeCommonFields,
-        srcConfirmation
-      };
-      const bridgeObservation = new PayloadBuilder16({
-        schema: BridgeSourceObservationSchema3
-      }).fields(bridgeObservationFields).build();
+      const bridgeObservationFields = { ...bridgeCommonFields, srcConfirmation };
+      const bridgeObservation = new PayloadBuilder17(
+        { schema: BridgeSourceObservationSchema3 }
+      ).fields(bridgeObservationFields).build();
       res.status(202).json(bridgeObservation);
     })
   };
-}, "makeBridgeToRemoteRoute");
+};
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteEstimate.ts
-import { requestHandlerValidator as requestHandlerValidator4 } from "@xylabs/express";
-import { assertEx as assertEx22, hexToBigInt as hexToBigInt10, toAddress as toAddress3 } from "@xylabs/sdk-js";
-import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema3 } from "@xyo-network/sdk-js";
-import { BridgeIntentFieldsZod as BridgeIntentFieldsZod3, BridgeIntentSchema as BridgeIntentSchema6, buildUnsignedTransaction, toXL1BlockNumber, TransactionBoundWitnessZod, TransferZod as TransferZod2 } from "@xyo-network/xl1-sdk";
-import { z as z3 } from "zod";
-var BridgeToRemoteEstimateBodyZod = BridgeIntentFieldsZod3.pick({
+import { requestHandlerValidator as requestHandlerValidator5 } from "@xylabs/express";
+import {
+  assertEx as assertEx24,
+  hexToBigInt as hexToBigInt14,
+  toAddress as toAddress4
+} 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 = z3.tuple([
-  TransactionBoundWitnessZod,
-  PayloadZodStrictOfSchema3(BridgeIntentSchema6).extend(BridgeIntentFieldsZod3.shape),
-  TransferZod2
+var BridgeToRemoteEstimateResponseZod = z4.tuple([
+  TransactionBoundWitnessZod2,
+  PayloadZodStrictOfSchema4(BridgeIntentSchema7).extend(BridgeIntentFieldsZod4.shape),
+  TransferZod3
 ]);
-var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) => {
-  const params = z3.object({
-    chainId: getRemoteChainIdZod(config)
-  });
-  const validateRequest2 = requestHandlerValidator4({
+var makeBridgeToRemoteEstimateRoute = (config, gateway) => {
+  const params = z4.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator5({
     params,
     body: BridgeToRemoteEstimateBodyZod,
     response: BridgeToRemoteEstimateResponseZod
@@ -2007,53 +2184,59 @@ var makeBridgeToRemoteEstimateRoute = /* @__PURE__ */ __name((config, gateway) =
     path: "/bridge/chains/:chainId/bridgeToRemote/estimate",
     handlers: validateRequest2(async (req, res) => {
       const xl1ChainId = getXl1ChainId(config);
-      const { srcAddress, srcAmount, destAddress } = req.body;
+      const {
+        srcAddress,
+        srcAmount,
+        destAddress
+      } = req.body;
       const { maxBridgeAmount, minBridgeAmount } = await getBridgeSettings(config);
-      if (hexToBigInt10(srcAmount) < hexToBigInt10(minBridgeAmount) || hexToBigInt10(srcAmount) > hexToBigInt10(maxBridgeAmount)) {
+      if (hexToBigInt14(srcAmount) < hexToBigInt14(minBridgeAmount) || hexToBigInt14(srcAmount) > hexToBigInt14(maxBridgeAmount)) {
         res.status(400).send();
         return;
       }
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, srcAmount, destAddress, config);
-      const sender = toAddress3(srcAddress);
-      const viewer = assertEx22(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const sender = toAddress4(srcAddress);
+      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 [txBw] = await buildUnsignedTransaction(xl1ChainId, [
-        transfer
-      ], [
-        bridgeIntent
-      ], nbf, exp, sender);
-      res.json([
-        txBw,
-        bridgeIntent,
-        transfer
-      ]);
+      const nbf = toXL1BlockNumber2(currentBlockNumber, true);
+      const exp = toXL1BlockNumber2(currentBlockNumber + 1e3, true);
+      const [txBw] = await buildUnsignedTransaction2(xl1ChainId, [transfer], [bridgeIntent], nbf, exp, sender);
+      res.json([txBw, bridgeIntent, transfer]);
     })
   };
-}, "makeBridgeToRemoteEstimateRoute");
+};
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteMaxEstimate.ts
-import { requestHandlerValidator as requestHandlerValidator5 } from "@xylabs/express";
-import { assertEx as assertEx23, hexToBigInt as hexToBigInt11, toAddress as toAddress4, toHex as toHex5 } from "@xylabs/sdk-js";
-import { PayloadZodStrictOfSchema as PayloadZodStrictOfSchema4 } from "@xyo-network/sdk-js";
-import { BridgeIntentFieldsZod as BridgeIntentFieldsZod4, BridgeIntentSchema as BridgeIntentSchema7, buildUnsignedTransaction as buildUnsignedTransaction2, toXL1BlockNumber as toXL1BlockNumber2, TransactionBoundWitnessZod as TransactionBoundWitnessZod2, TransferZod as TransferZod3 } from "@xyo-network/xl1-sdk";
-import { z as z4 } from "zod";
-var BridgeToRemoteMaxEstimateBodyZod = BridgeIntentFieldsZod4.pick({
+import { requestHandlerValidator as requestHandlerValidator6 } from "@xylabs/express";
+import {
+  assertEx as assertEx25,
+  hexToBigInt as hexToBigInt15,
+  toAddress as toAddress5,
+  toHex as toHex8
+} 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 = z4.tuple([
-  TransactionBoundWitnessZod2,
-  PayloadZodStrictOfSchema4(BridgeIntentSchema7).extend(BridgeIntentFieldsZod4.shape),
-  TransferZod3
+var BridgeToRemoteMaxEstimateResponseZod = z5.tuple([
+  TransactionBoundWitnessZod3,
+  PayloadZodStrictOfSchema5(BridgeIntentSchema8).extend(BridgeIntentFieldsZod5.shape),
+  TransferZod4
 ]);
-var makeBridgeToRemoteMaxEstimateRoute = /* @__PURE__ */ __name((config, gateway) => {
-  const params = z4.object({
-    chainId: getRemoteChainIdZod(config)
-  });
-  const validateRequest2 = requestHandlerValidator5({
+var makeBridgeToRemoteMaxEstimateRoute = (config, gateway) => {
+  const params = z5.object({ chainId: getRemoteChainIdZod(config) });
+  const validateRequest2 = requestHandlerValidator6({
     params,
     body: BridgeToRemoteMaxEstimateBodyZod,
     response: BridgeToRemoteMaxEstimateResponseZod
@@ -2062,66 +2245,61 @@ var makeBridgeToRemoteMaxEstimateRoute = /* @__PURE__ */ __name((config, gateway
     method: "post",
     path: "/bridge/chains/:chainId/bridgeToRemote/maxEstimate",
     handlers: validateRequest2(async (req, res) => {
-      const { feeFixed, feeRateBasisPoints, maxBridgeAmount: configMax, xl1ChainId } = await getBridgeSettings(config);
-      const { srcAddress, srcAmount: balance, destAddress } = req.body;
-      const balanceMax = calculateMaxBridgeAmount(balance, {
+      const {
         feeFixed,
-        feeRateBasisPoints
-      });
-      const maxBridgeAmount = toHex5(hexToBigInt11(balanceMax) < hexToBigInt11(configMax) ? balanceMax : configMax);
+        feeRateBasisPoints,
+        maxBridgeAmount: configMax,
+        xl1ChainId
+      } = await getBridgeSettings(config);
+      const {
+        srcAddress,
+        srcAmount: balance,
+        destAddress
+      } = req.body;
+      const balanceMax = calculateMaxBridgeAmount(balance, { feeFixed, feeRateBasisPoints });
+      const maxBridgeAmount = toHex8(hexToBigInt15(balanceMax) < hexToBigInt15(configMax) ? balanceMax : configMax);
       const [bridgeIntent, transfer] = await generateBridgeEstimate(srcAddress, maxBridgeAmount, destAddress, config);
-      const sender = toAddress4(srcAddress);
-      const viewer = assertEx23(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
+      const sender = toAddress5(srcAddress);
+      const viewer = assertEx25(gateway.connection.viewer, () => new Error("Viewer not available on gateway connection"));
       const currentBlockNumber = await viewer.currentBlockNumber();
-      const nbf = toXL1BlockNumber2(currentBlockNumber, true);
-      const exp = toXL1BlockNumber2(currentBlockNumber + 1e3, true);
-      const [txBw] = await buildUnsignedTransaction2(xl1ChainId, [
-        transfer
-      ], [
-        bridgeIntent
-      ], nbf, exp, sender);
-      res.json([
-        txBw,
-        bridgeIntent,
-        transfer
-      ]);
+      const nbf = toXL1BlockNumber3(currentBlockNumber, true);
+      const exp = toXL1BlockNumber3(currentBlockNumber + 1e3, true);
+      const [txBw] = await buildUnsignedTransaction3(xl1ChainId, [transfer], [bridgeIntent], nbf, exp, sender);
+      res.json([txBw, bridgeIntent, transfer]);
     })
   };
-}, "makeBridgeToRemoteMaxEstimateRoute");
+};
 
 // src/server/routes/bridge/routeDefinitions/routes/bridgeToRemoteStatus.ts
-import { requestHandlerValidator as requestHandlerValidator6 } from "@xylabs/express";
+import { requestHandlerValidator as requestHandlerValidator7 } from "@xylabs/express";
 import { asHex as asHex4, isDefined as isDefined16 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder17, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema5 } from "@xyo-network/sdk-js";
-import { asBridgeIntent, BridgeDestinationObservationFieldsZod as BridgeDestinationObservationFieldsZod2, BridgeDestinationObservationSchema as BridgeDestinationObservationSchema2, BridgeIntentFieldsZod as BridgeIntentFieldsZod5, BridgeIntentSchema as BridgeIntentSchema8, BridgeSourceObservationFieldsZod as BridgeSourceObservationFieldsZod3, BridgeSourceObservationSchema as BridgeSourceObservationSchema4, isBridgeIntent as isBridgeIntent5 } from "@xyo-network/xl1-sdk";
-import { z as z5 } from "zod";
-var BridgeIntentResponseZod2 = PayloadZodStrictOfSchema5(BridgeIntentSchema8).extend(BridgeIntentFieldsZod5.shape);
-var BridgeSourceResponseZod2 = PayloadZodStrictOfSchema5(BridgeSourceObservationSchema4).extend(BridgeSourceObservationFieldsZod3.shape);
-var BridgeDestinationResponseZod2 = PayloadZodStrictOfSchema5(BridgeDestinationObservationSchema2).extend(BridgeDestinationObservationFieldsZod2.shape);
-var BridgeToRemoteStatusResponseZod = z5.union([
-  z5.tuple([]),
-  z5.tuple([
-    BridgeIntentResponseZod2
-  ]),
-  z5.tuple([
-    BridgeIntentResponseZod2,
-    BridgeSourceResponseZod2
-  ]),
-  z5.tuple([
-    BridgeIntentResponseZod2,
-    BridgeSourceResponseZod2,
-    BridgeDestinationResponseZod2
-  ])
+import { PayloadBuilder as PayloadBuilder18, PayloadZodStrictOfSchema as PayloadZodStrictOfSchema6 } 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
+} 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])
 ]);
-var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
-  const params = z5.object({
+var makeBridgeToRemoteStatusRoute = (config) => {
+  const params = z6.object({
     chainId: getRemoteChainIdZod(config),
-    nonce: z5.string().nonempty()
-  });
-  const validateRequest2 = requestHandlerValidator6({
-    params,
-    response: BridgeToRemoteStatusResponseZod
+    nonce: z6.string().nonempty()
   });
+  const validateRequest2 = requestHandlerValidator7({ params, response: BridgeToRemoteStatusResponseZod });
   return {
     method: "get",
     path: "/bridge/chains/:chainId/bridgeToRemote/status/:nonce",
@@ -2132,13 +2310,10 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
       const statusQueueJobs = await getStatusQueueJobs(queues, jobId);
       const { tx, offChainPayloads = [] } = statusQueueJobs.xl1ToEthBridgeParentJob?.data ?? {};
       if (!tx) return res.sendStatus(404);
-      const allPayloads = [
-        ...tx[1],
-        ...offChainPayloads
-      ];
+      const allPayloads = [...tx[1], ...offChainPayloads];
       const bridgeIntent = allPayloads.find(isBridgeIntent5);
       if (!bridgeIntent) return res.sendStatus(404);
-      result[0] = asBridgeIntent(PayloadBuilder17.omitMeta(bridgeIntent));
+      result[0] = asBridgeIntent(PayloadBuilder18.omitMeta(bridgeIntent));
       const { xl1TransactionMonitorJob } = statusQueueJobs;
       const xl1MonitorState = xl1TransactionMonitorJob ? await xl1TransactionMonitorJob.getState() : void 0;
       if (xl1MonitorState === "completed") {
@@ -2172,36 +2347,37 @@ var makeBridgeToRemoteStatusRoute = /* @__PURE__ */ __name((config) => {
       res.json(result);
     })
   };
-}, "makeBridgeToRemoteStatusRoute");
+};
 
 // src/server/routes/bridge/routeDefinitions/getRouteDefinitions.ts
-var getRouteDefinitions = /* @__PURE__ */ __name((config, gateway) => {
+var getRouteDefinitions = (config, gateway) => {
   return [
     makeBridgeConfigRoute(config),
     makeBridgeToRemoteEstimateRoute(config, gateway),
     makeBridgeToRemoteMaxEstimateRoute(config, gateway),
     makeBridgeToRemoteRoute(config),
     makeBridgeToRemoteStatusRoute(config),
+    makeBridgeFromRemoteEstimateRoute(config),
     makeBridgeFromRemoteStatusRoute(config)
   ];
-}, "getRouteDefinitions");
+};
 
 // src/server/routes/bridge/addBridgeRoutes.ts
-var addBridgeRoutes = /* @__PURE__ */ __name((app, config, gateway) => {
+var addBridgeRoutes = (app, config, gateway) => {
   const routeDefinitions = getRouteDefinitions(config, gateway);
   for (const definition of routeDefinitions) {
     app[definition.method](definition.path, definition.handlers);
   }
-}, "addBridgeRoutes");
+};
 
 // src/server/routes/addRoutes.ts
-var addRoutes = /* @__PURE__ */ __name((app, config, gateway) => {
+var addRoutes = (app, config, gateway) => {
   addProbeRoutes(app);
   addBridgeRoutes(app, config, gateway);
-}, "addRoutes");
+};
 
 // src/server/app.ts
-var getApp = /* @__PURE__ */ __name((config, gateway) => {
+var getApp = (config, gateway) => {
   addInstrumentation();
   const app = express();
   sharedMiddleware(app);
@@ -2209,10 +2385,10 @@ var getApp = /* @__PURE__ */ __name((config, gateway) => {
   addRoutes(app, config, gateway);
   app.use(standardErrors);
   return app;
-}, "getApp");
+};
 
 // src/services/getServices.ts
-import { assertEx as assertEx24 } from "@xylabs/sdk-js";
+import { assertEx as assertEx26 } 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";
@@ -2221,10 +2397,16 @@ import { getAddress as getAddress2, Wallet } from "ethers";
 import { BaseMongoSdk } from "@xylabs/mongo";
 import { MongoMap } from "@xyo-network/chain-protocol-driver-mongodb";
 import { hasMongoConfig, mapToMapType } from "@xyo-network/xl1-sdk";
-var getIterableMap = /* @__PURE__ */ __name(async (config, collection) => {
+var getIterableMap = async (config, collection) => {
   const mongoConfig = config.storage?.mongo;
   if (hasMongoConfig(mongoConfig)) {
-    const { connectionString: dbConnectionString, database: dbName, domain: dbDomain, password: dbPassword, username: dbUserName } = mongoConfig;
+    const {
+      connectionString: dbConnectionString,
+      database: dbName,
+      domain: dbDomain,
+      password: dbPassword,
+      username: dbUserName
+    } = mongoConfig;
     const payloadSdkConfig = {
       dbConnectionString,
       dbDomain,
@@ -2232,44 +2414,44 @@ var getIterableMap = /* @__PURE__ */ __name(async (config, collection) => {
       dbPassword,
       dbUserName
     };
-    const sdkBalanceSummaryMap = new BaseMongoSdk({
-      ...payloadSdkConfig,
-      collection
-    });
+    const sdkBalanceSummaryMap = new BaseMongoSdk({ ...payloadSdkConfig, collection });
     const result = await MongoMap.create({
       sdk: sdkBalanceSummaryMap,
-      getCache: {
-        enabled: true,
-        maxEntries: 5e3
-      }
+      getCache: { enabled: true, maxEntries: 5e3 }
     });
     return result;
   } else {
     return mapToMapType(/* @__PURE__ */ new Map());
   }
-}, "getIterableMap");
+};
 
 // src/services/getServices.ts
-var getServices = /* @__PURE__ */ __name(async (context, gateway) => {
+var getServices = async (context, gateway) => {
   const { config } = context;
   const ethTxStateMap = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_eth_tx_state");
   const xl1TxStateMap = await getIterableMap(config, "liquidity_bridge_xl1_to_eth_xl1_tx_state");
   const evmBridgeCursorMap = await getIterableMap(config, "liquidity_bridge_eth_to_xl1_scanner_cursor");
   const bridgeFulfillmentMap = await getIterableMap(config, "liquidity_bridge_eth_to_xl1_fulfillment");
   const provider = await initEvmProvider(context);
-  const { remoteBridgeContractAddress, remoteChainWalletPrivateKey, remoteTokenAddress, accountPath } = config;
+  const {
+    remoteBridgeContractAddress,
+    remoteChainWalletPrivateKey,
+    remoteTokenAddress,
+    accountPath
+  } = config;
   const account = await resolveWalletForActor2(config.name, accountPath);
   const wallet = new Wallet(remoteChainWalletPrivateKey, provider);
   const bridgeableToken = BridgeableToken__factory.connect(getAddress2(remoteTokenAddress), wallet);
   const bridge = LiquidityPoolBridge__factory.connect(getAddress2(remoteBridgeContractAddress), wallet);
   const bridgeOwner = await bridge.owner();
-  assertEx24(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
+  assertEx26(bridgeOwner.toLowerCase() === wallet.address.toLowerCase(), () => "Wallet is not the owner of the bridge contract");
   const remoteConfirmationDepth = getRemoteConfirmationDepth(config);
   return {
     account,
     bridge,
     bridgeableToken,
     bridgeFulfillmentMap,
+    config,
     ethTxStateMap,
     evmBridgeCursorMap,
     gateway,
@@ -2278,18 +2460,18 @@ var getServices = /* @__PURE__ */ __name(async (context, gateway) => {
     wallet,
     xl1TxStateMap
   };
-}, "getServices");
+};
 
 // src/server/addWorkers.ts
-var addWorkers = /* @__PURE__ */ __name((config, services) => {
+var addWorkers = (config, services) => {
   const connection2 = getConnection(config);
   const telemetry2 = getTelemetry();
   createWorkers(connection2, telemetry2, services);
-}, "addWorkers");
+};
 
 // src/server/server.ts
 var hostname = "::";
-var getServer = /* @__PURE__ */ __name(async (context, gateway) => {
+var getServer = async (context, gateway) => {
   const { logger, config } = context;
   const { port } = config;
   const app = getApp(config, gateway);
@@ -2304,51 +2486,53 @@ var getServer = /* @__PURE__ */ __name(async (context, gateway) => {
     srv.once("error", reject);
   });
   server.setTimeout(2e4);
-  return {
-    server,
-    services
-  };
-}, "getServer");
+  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;
+  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 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
-      });
+      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
-      });
+      liquidityTokenBalance.record(Number(balance / TOKEN_DECIMALS), { address: liquiditySourceAddress });
     } catch (err) {
       console.error("[BalanceMonitor] Failed to read liquidity source token balance:", err);
     }
@@ -2356,9 +2540,7 @@ function createBalanceMonitor(config) {
       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
-      });
+      liquidityTokenAllowance.record(Number(allowance / TOKEN_DECIMALS), { address: liquiditySourceAddress });
     } catch (err) {
       console.error("[BalanceMonitor] Failed to read liquidity source token allowance:", err);
     }
@@ -2366,15 +2548,12 @@ function createBalanceMonitor(config) {
       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()
-        });
+        xl1AccountBalance.record(Number(balance / TOKEN_DECIMALS), { address: account.address.toString() });
       }
     } catch (err) {
       console.error("[BalanceMonitor] Failed to read XL1 account balance:", err);
     }
   }
-  __name(poll, "poll");
   return {
     start() {
       void poll();
@@ -2388,35 +2567,41 @@ function createBalanceMonitor(config) {
     }
   };
 }
-__name(createBalanceMonitor, "createBalanceMonitor");
 
 // src/telemetry/createQueueMetrics.ts
 var DEFAULT_INTERVAL_MS2 = 3e4;
 function createQueueMetrics(config) {
-  const { meter, queues, intervalMs = DEFAULT_INTERVAL_MS2 } = 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"
-  });
+  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
-        };
+        const attrs = { queue_name: name13 };
         waitingGauge.record(counts.waiting ?? 0, attrs);
         activeGauge.record(counts.active ?? 0, attrs);
         completedGauge.record(counts.completed ?? 0, attrs);
@@ -2427,7 +2612,6 @@ function createQueueMetrics(config) {
       }
     }
   }
-  __name(poll, "poll");
   return {
     start() {
       void poll();
@@ -2441,26 +2625,9 @@ function createQueueMetrics(config) {
     }
   };
 }
-__name(createQueueMetrics, "createQueueMetrics");
 
 // src/BridgeActor.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
 var BridgeActor = class extends ActorV3 {
-  static {
-    __name(this, "BridgeActor");
-  }
-  static needs = {
-    required: [
-      XyoGatewayRunnerMoniker,
-      XyoViewerMoniker
-    ]
-  };
   _gatewayRunner;
   _balanceMonitor;
   _queueMetrics;
@@ -2532,7 +2699,13 @@ var BridgeActor = class extends ActorV3 {
     this.server = void 0;
   }
 };
-BridgeActor = _ts_decorate([
+__publicField(BridgeActor, "needs", {
+  required: [
+    XyoGatewayRunnerMoniker,
+    XyoViewerMoniker
+  ]
+});
+BridgeActor = __decorateClass([
   creatable()
 ], BridgeActor);
 
@@ -2542,7 +2715,7 @@ import { BridgeConfigZod } from "@xyo-network/chain-orchestration";
 // src/run.ts
 import { exists } from "@xylabs/sdk-js";
 import { initActorWallet } from "@xyo-network/chain-orchestration";
-var getBridgeActor = /* @__PURE__ */ __name(async (config, locator) => {
+var getBridgeActor = async (config, locator) => {
   const account = await initActorWallet({
     config,
     logger: locator.context.logger,
@@ -2554,17 +2727,15 @@ var getBridgeActor = /* @__PURE__ */ __name(async (config, locator) => {
     config,
     locator
   });
-}, "getBridgeActor");
-var runBridge = /* @__PURE__ */ __name(async (config, orchestrator, locator) => {
+};
+var runBridge = async (config, orchestrator, locator) => {
   const bridge = await getBridgeActor(config, locator);
-  const actors = [
-    bridge
-  ].filter(exists);
+  const actors = [bridge].filter(exists);
   for (const actor of actors) {
     await orchestrator.registerActor(actor);
   }
   await orchestrator.start();
-}, "runBridge");
+};
 
 // src/command.ts
 function bridgeCommand(getConfiguration, getLocatorsFromConfig) {
@@ -2572,16 +2743,13 @@ function bridgeCommand(getConfiguration, getLocatorsFromConfig) {
     command: "bridge",
     deprecated: 'Use "start bridge" instead',
     describe: "Run a XL1 Bridge Node",
-    handler: /* @__PURE__ */ __name(async () => {
+    handler: async () => {
       const configuration = getConfiguration();
-      const { locators, orchestrator } = await getLocatorsFromConfig([
-        "bridge"
-      ], configuration);
+      const { locators, orchestrator } = await getLocatorsFromConfig(["bridge"], configuration);
       await runBridge(BridgeConfigZod.parse(locators["bridge"].context.config), orchestrator, locators["bridge"]);
-    }, "handler")
+    }
   };
 }
-__name(bridgeCommand, "bridgeCommand");
 export {
   BridgeActor,
   bridgeCommand,
@@ -2590,4 +2758,4 @@ export {
   getBridgeActor,
   runBridge
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map