@matterlabs/zksync-js 0.0.1 → 0.0.2

package/dist/adapters/viem/sdk.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-var viem = require('viem');
 var sha3 = require('@noble/hashes/sha3');
 var utils = require('@noble/hashes/utils');
+var viem = require('viem');
 
 // src/core/internal/abis/IBridgehub.ts
 var IBridgehubABI = [
@@ -3656,139 +3656,12 @@ var TOPIC_L1_MESSAGE_SENT_NEW = k256hex("L1MessageSent(uint256,bytes32,bytes)");
 var TOPIC_L1_MESSAGE_SENT_LEG = k256hex("L1MessageSent(address,bytes32,bytes)");
 var TOPIC_CANONICAL_ASSIGNED = "0x779f441679936c5441b671969f37400b8c3ed0071cb47444431bf985754560df";
 var TOPIC_CANONICAL_SUCCESS = "0xe4def01b981193a97a9e81230d7b9f31812ceaf23f864a828a82c687911cb2df";
-
-// src/core/utils/gas.ts
-function assertNoLegacyGas(overrides) {
-  if (!overrides) return;
-  if ("gasPrice" in overrides && overrides.gasPrice !== void 0) {
-    throw new Error("Legacy gasPrice is not supported; use EIP-1559 fields instead.");
-  }
-}
-function assertPriorityFeeBounds(fees) {
-  if (fees.maxPriorityFeePerGas > fees.maxFeePerGas) {
-    throw new Error("maxPriorityFeePerGas cannot exceed maxFeePerGas.");
-  }
-}
-
-// src/adapters/viem/resources/utils.ts
-function encodeNativeTokenVaultAssetId(chainId, address) {
-  const encoded = viem.encodeAbiParameters(
-    [
-      { type: "uint256", name: "originChainId" },
-      { type: "address", name: "ntv" },
-      { type: "address", name: "token" }
-    ],
-    [chainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, address]
-  );
-  return viem.keccak256(encoded);
-}
-async function getFeeOverrides(client, overrides) {
-  assertNoLegacyGas(overrides);
-  let maxFeePerGasFromProvider;
-  let maxPriorityFromProvider;
-  let gasPriceFromProvider;
-  try {
-    const fees = await client.l1.estimateFeesPerGas();
-    const { maxFeePerGas: maxFeePerGas2, maxPriorityFeePerGas: maxPriorityFeePerGas2 } = fees;
-    if (maxFeePerGas2 != null && maxPriorityFeePerGas2 != null) {
-      maxFeePerGasFromProvider = maxFeePerGas2;
-      maxPriorityFromProvider = maxPriorityFeePerGas2;
-      gasPriceFromProvider = fees.gasPrice ?? maxFeePerGas2;
-    } else if (fees.gasPrice != null) {
-      gasPriceFromProvider = fees.gasPrice;
-    }
-  } catch {
-  }
-  if (gasPriceFromProvider == null) {
-    try {
-      gasPriceFromProvider = await client.l1.getGasPrice();
-    } catch {
-    }
-  }
-  const maxFeePerGas = overrides?.maxFeePerGas ?? maxFeePerGasFromProvider ?? gasPriceFromProvider;
-  if (maxFeePerGas == null) {
-    throw new Error("L1 provider returned no gas price data");
-  }
-  const maxPriorityFeePerGas = overrides?.maxPriorityFeePerGas ?? maxPriorityFromProvider ?? maxFeePerGas;
-  assertPriorityFeeBounds({ maxFeePerGas, maxPriorityFeePerGas });
-  const gasPriceForBaseCost = overrides?.maxFeePerGas ?? maxFeePerGasFromProvider ?? gasPriceFromProvider ?? maxFeePerGas;
-  return {
-    gasLimit: overrides?.gasLimit,
-    maxFeePerGas,
-    maxPriorityFeePerGas,
-    gasPriceForBaseCost
-  };
-}
-async function getL2FeeOverrides(client, overrides) {
-  assertNoLegacyGas(overrides);
-  let maxFeePerGasFromProvider;
-  let maxPriorityFromProvider;
-  let gasPriceFromProvider;
-  try {
-    const fees = await client.l2.estimateFeesPerGas();
-    if (fees?.maxFeePerGas != null && fees.maxPriorityFeePerGas != null) {
-      maxFeePerGasFromProvider = fees.maxFeePerGas;
-      maxPriorityFromProvider = fees.maxPriorityFeePerGas;
-      gasPriceFromProvider = fees.gasPrice ?? fees.maxFeePerGas;
-    } else if (fees?.gasPrice != null) {
-      gasPriceFromProvider = fees.gasPrice;
-    }
-  } catch {
-  }
-  if (gasPriceFromProvider == null) {
-    try {
-      gasPriceFromProvider = await client.l2.getGasPrice();
-    } catch {
-    }
-  }
-  const maxFeePerGas = overrides?.maxFeePerGas ?? maxFeePerGasFromProvider ?? gasPriceFromProvider;
-  if (maxFeePerGas == null) {
-    throw new Error("provider returned no gas price data");
-  }
-  const maxPriorityFeePerGas = overrides?.maxPriorityFeePerGas ?? maxPriorityFromProvider ?? maxFeePerGas;
-  assertPriorityFeeBounds({ maxFeePerGas, maxPriorityFeePerGas });
-  return {
-    gasLimit: overrides?.gasLimit,
-    maxFeePerGas,
-    maxPriorityFeePerGas
-  };
-}
-function buildViemFeeOverrides(fees) {
-  return {
-    maxFeePerGas: fees.maxFeePerGas,
-    maxPriorityFeePerGas: fees.maxPriorityFeePerGas,
-    gas: fees.gasLimit
-  };
-}
-function buildDirectRequestStruct(args) {
-  return {
-    chainId: args.chainId,
-    l2Contract: args.l2Contract,
-    mintValue: args.mintValue,
-    l2Value: args.l2Value,
-    l2Calldata: "0x",
-    l2GasLimit: args.l2GasLimit,
-    l2GasPerPubdataByteLimit: args.gasPerPubdata,
-    factoryDeps: [],
-    refundRecipient: args.refundRecipient
-  };
-}
-function encodeSecondBridgeArgs(token, amount, l2Receiver) {
-  return viem.encodeAbiParameters(
-    [
-      { type: "address", name: "token" },
-      { type: "uint256", name: "amount" },
-      { type: "address", name: "l2Receiver" }
-    ],
-    [token, amount, l2Receiver]
-  );
-}
-function encodeSecondBridgeErc20Args(token, amount, l2Receiver) {
-  return encodeSecondBridgeArgs(token, amount, l2Receiver);
-}
-function encodeSecondBridgeEthArgs(amount, l2Receiver, ethToken = ETH_ADDRESS) {
-  return encodeSecondBridgeArgs(ethToken, amount, l2Receiver);
-}
+var BUFFER = 20n;
+var TX_OVERHEAD_GAS = 10000n;
+var TX_MEMORY_OVERHEAD_GAS = 10n;
+var DEFAULT_PUBDATA_BYTES = 155n;
+var DEFAULT_ABI_BYTES = 400n;
+var SAFE_L1_BRIDGE_GAS = 600000n;
 
 // src/core/utils/addr.ts
 var isHash66 = (x) => !!x && x.startsWith("0x") && x.length === 66;
@@ -3823,8 +3696,6 @@ async function commonCtx(p, client) {
   const { bridgehub, l1AssetRouter } = await client.ensureAddresses();
   const chainId = await client.l2.getChainId();
   const sender = client.account.address;
-  const fee = await getFeeOverrides(client, p.l1TxOverrides);
-  const l2GasLimit = p.l2GasLimit ?? 300000n;
   const gasPerPubdata = p.gasPerPubdata ?? 800n;
   const operatorTip = p.operatorTip ?? 0n;
   const refundRecipient = p.refundRecipient ?? sender;
@@ -3836,13 +3707,53 @@ async function commonCtx(p, client) {
     bridgehub,
     chainIdL2: BigInt(chainId),
     sender,
-    fee,
-    l2GasLimit,
+    gasOverrides: p.l1TxOverrides,
+    l2GasLimit: p.l2GasLimit,
     gasPerPubdata,
     operatorTip,
     refundRecipient
   };
 }
+function encodeNativeTokenVaultAssetId(chainId, address) {
+  const encoded = viem.encodeAbiParameters(
+    [
+      { type: "uint256", name: "originChainId" },
+      { type: "address", name: "ntv" },
+      { type: "address", name: "token" }
+    ],
+    [chainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, address]
+  );
+  return viem.keccak256(encoded);
+}
+function encodeSecondBridgeArgs(token, amount, l2Receiver) {
+  return viem.encodeAbiParameters(
+    [
+      { type: "address", name: "token" },
+      { type: "uint256", name: "amount" },
+      { type: "address", name: "l2Receiver" }
+    ],
+    [token, amount, l2Receiver]
+  );
+}
+function encodeSecondBridgeErc20Args(token, amount, l2Receiver) {
+  return encodeSecondBridgeArgs(token, amount, l2Receiver);
+}
+function encodeSecondBridgeEthArgs(amount, l2Receiver, ethToken = ETH_ADDRESS) {
+  return encodeSecondBridgeArgs(ethToken, amount, l2Receiver);
+}
+function buildDirectRequestStruct(args) {
+  return {
+    chainId: args.chainId,
+    l2Contract: args.l2Contract,
+    mintValue: args.mintValue,
+    l2Value: args.l2Value,
+    l2Calldata: "0x",
+    l2GasLimit: args.l2GasLimit,
+    l2GasPerPubdataByteLimit: args.gasPerPubdata,
+    factoryDeps: [],
+    refundRecipient: args.refundRecipient
+  };
+}
 
 // src/core/errors/formatter.ts
 function elideMiddle(s, max = 96) {
@@ -4055,27 +3966,21 @@ var OP_DEPOSITS = {
   base: {
     assertErc20Asset: "deposits.erc20-base:assertErc20Asset",
     assertMatchesBase: "deposits.erc20-base:assertMatchesBase",
-    baseToken: "deposits.erc20-base:baseToken",
     allowance: "deposits.erc20-base:allowance",
-    baseCost: "deposits.erc20-base:l2TransactionBaseCost",
     estGas: "deposits.erc20-base:estimateGas"
   },
   nonbase: {
-    baseToken: "deposits.erc20-nonbase:baseToken",
     assertNotEthAsset: "deposits.erc20-nonbase:assertNotEthAsset",
-    allowance: "deposits.erc20-nonbase:allowance",
-    allowanceFees: "deposits.erc20-nonbase:allowanceFeesBaseToken",
-    baseCost: "deposits.erc20-nonbase:l2TransactionBaseCost",
     encodeCalldata: "deposits.erc20-nonbase:encodeSecondBridgeErc20Args",
     estGas: "deposits.erc20-nonbase:estimateGas",
-    assertNonBaseToken: "deposits.erc20-nonbase:assertNonBaseToken"},
+    assertNonBaseToken: "deposits.erc20-nonbase:assertNonBaseToken",
+    allowanceToken: "deposits.erc20-nonbase:allowanceToken",
+    allowanceBase: "deposits.erc20-nonbase:allowanceBase"
+  },
   eth: {
-    baseCost: "deposits.eth:l2TransactionBaseCost",
     estGas: "deposits.eth:estimateGas"
   },
   ethNonBase: {
-    baseToken: "deposits.eth-nonbase:baseToken",
-    baseCost: "deposits.eth-nonbase:l2TransactionBaseCost",
     allowanceBase: "deposits.eth-nonbase:allowanceBaseToken",
     ethBalance: "deposits.eth-nonbase:getEthBalance",
     encodeCalldata: "deposits.eth-nonbase:encodeSecondBridgeEthArgs",
@@ -4337,41 +4242,361 @@ function createErrorHandlers(resource) {
   return { wrap: wrap2, wrapAs: wrapAs9, toResult: toResult2 };
 }
 
-// src/adapters/viem/resources/deposits/routes/eth.ts
+// src/core/resources/deposits/gas.ts
+function makeGasQuote(p) {
+  const maxPriorityFeePerGas = p.maxPriorityFeePerGas ?? 0n;
+  return {
+    gasLimit: p.gasLimit,
+    maxFeePerGas: p.maxFeePerGas,
+    maxPriorityFeePerGas,
+    gasPerPubdata: p.gasPerPubdata,
+    maxCost: p.gasLimit * p.maxFeePerGas
+  };
+}
+async function fetchFees(estimator) {
+  try {
+    const fees = await estimator.estimateFeesPerGas();
+    if (fees.maxFeePerGas != null) {
+      return {
+        maxFeePerGas: fees.maxFeePerGas,
+        maxPriorityFeePerGas: fees.maxPriorityFeePerGas ?? 0n
+      };
+    }
+    if (fees.gasPrice != null) {
+      return {
+        maxFeePerGas: fees.gasPrice,
+        maxPriorityFeePerGas: 0n
+      };
+    }
+  } catch {
+  }
+  try {
+    const gp = await estimator.getGasPrice();
+    return { maxFeePerGas: gp, maxPriorityFeePerGas: 0n };
+  } catch {
+    return { maxFeePerGas: 0n, maxPriorityFeePerGas: 0n };
+  }
+}
+async function quoteL1Gas(input) {
+  const { estimator, tx, overrides, fallbackGasLimit } = input;
+  let market;
+  const getMarket = async () => {
+    if (market) return market;
+    market = await fetchFees(estimator);
+    return market;
+  };
+  const maxFeePerGas = overrides?.maxFeePerGas ?? (tx.maxFeePerGas != null ? BigInt(tx.maxFeePerGas) : (await getMarket()).maxFeePerGas);
+  const maxPriorityFeePerGas = overrides?.maxPriorityFeePerGas ?? (tx.maxPriorityFeePerGas != null ? BigInt(tx.maxPriorityFeePerGas) : (await getMarket()).maxPriorityFeePerGas);
+  const explicitGasLimit = overrides?.gasLimit ?? (tx.gasLimit != null ? BigInt(tx.gasLimit) : void 0);
+  if (explicitGasLimit != null) {
+    return makeGasQuote({ gasLimit: explicitGasLimit, maxFeePerGas, maxPriorityFeePerGas });
+  }
+  try {
+    const est = await estimator.estimateGas(tx);
+    const buffered = BigInt(est) * (100n + BUFFER) / 100n;
+    return makeGasQuote({ gasLimit: buffered, maxFeePerGas, maxPriorityFeePerGas });
+  } catch (err) {
+    if (fallbackGasLimit != null) {
+      return makeGasQuote({ gasLimit: fallbackGasLimit, maxFeePerGas, maxPriorityFeePerGas });
+    }
+    console.warn("L1 gas estimation failed", err);
+    return void 0;
+  }
+}
+async function quoteL2Gas(input) {
+  const { estimator, route, tx, gasPerPubdata, l2GasLimit, overrideGasLimit, stateOverrides } = input;
+  const market = await fetchFees(estimator);
+  const maxFeePerGas = market.maxFeePerGas || market.maxPriorityFeePerGas || 0n;
+  const txGasLimit = tx?.gasLimit != null ? BigInt(tx.gasLimit) : void 0;
+  const explicit = overrideGasLimit ?? txGasLimit;
+  if (explicit != null) {
+    return makeGasQuote({
+      gasLimit: explicit,
+      maxFeePerGas,
+      gasPerPubdata
+    });
+  }
+  if (!tx) {
+    return makeGasQuote({
+      gasLimit: l2GasLimit ?? 0n,
+      maxFeePerGas,
+      gasPerPubdata
+    });
+  }
+  try {
+    const execEstimate = await estimator.estimateGas(tx, stateOverrides);
+    const memoryBytes = route === "erc20-nonbase" ? 500n : DEFAULT_ABI_BYTES;
+    const pubdataBytes = route === "erc20-nonbase" ? 200n : DEFAULT_PUBDATA_BYTES;
+    const pp = gasPerPubdata ?? 800n;
+    const memoryOverhead = memoryBytes * TX_MEMORY_OVERHEAD_GAS;
+    const pubdataOverhead = pubdataBytes * pp;
+    let total = BigInt(execEstimate) + TX_OVERHEAD_GAS + memoryOverhead + pubdataOverhead;
+    total = total * (100n + BUFFER) / 100n;
+    return makeGasQuote({
+      gasLimit: total,
+      maxFeePerGas,
+      gasPerPubdata: pp
+    });
+  } catch (err) {
+    console.warn("L2 gas estimation failed", err);
+    return makeGasQuote({
+      gasLimit: l2GasLimit ?? 0n,
+      maxFeePerGas,
+      gasPerPubdata
+    });
+  }
+}
+
+// src/adapters/viem/estimator.ts
+function toCoreTx(tx) {
+  return {
+    to: tx.to,
+    from: tx.from,
+    data: tx.data,
+    value: tx.value,
+    gasLimit: tx.gas,
+    maxFeePerGas: tx.maxFeePerGas,
+    maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+  };
+}
+function viemToGasEstimator(client) {
+  return {
+    async estimateGas(tx, stateOverrides) {
+      if (stateOverrides) {
+        try {
+          const result = await client.request({
+            method: "eth_estimateGas",
+            params: [
+              {
+                from: tx.from,
+                to: tx.to,
+                data: tx.data,
+                value: tx.value,
+                gas: tx.gasLimit,
+                maxFeePerGas: tx.maxFeePerGas,
+                maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+              },
+              "latest",
+              stateOverrides
+            ]
+          });
+          return BigInt(result);
+        } catch (error) {
+          console.warn(
+            "Failed to estimate gas with state overrides, falling back to standard estimation:",
+            error
+          );
+        }
+      }
+      return await client.estimateGas({
+        account: tx.from,
+        to: tx.to,
+        data: tx.data,
+        value: tx.value,
+        gas: tx.gasLimit,
+        maxFeePerGas: tx.maxFeePerGas,
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+      });
+    },
+    async estimateFeesPerGas() {
+      try {
+        const fees = await client.estimateFeesPerGas();
+        return {
+          maxFeePerGas: fees.maxFeePerGas,
+          maxPriorityFeePerGas: fees.maxPriorityFeePerGas
+        };
+      } catch {
+      }
+      try {
+        const gp = await client.getGasPrice();
+        return { gasPrice: gp };
+      } catch {
+        return {};
+      }
+    },
+    async getGasPrice() {
+      return await client.getGasPrice();
+    },
+    async call(tx) {
+      const res = await client.call({
+        to: tx.to,
+        data: tx.data,
+        value: tx.value,
+        account: tx.from
+      });
+      return res.data ?? "0x";
+    }
+  };
+}
+
+// src/adapters/viem/resources/deposits/services/gas.ts
+async function quoteL1Gas2(input) {
+  const { ctx, tx, overrides, fallbackGasLimit } = input;
+  const estimator = viemToGasEstimator(ctx.client.l1);
+  return quoteL1Gas({
+    estimator,
+    tx: toCoreTx(tx),
+    overrides,
+    fallbackGasLimit
+  });
+}
+async function quoteL2Gas2(input) {
+  const { ctx, route, l2TxForModeling, overrideGasLimit } = input;
+  const estimator = viemToGasEstimator(ctx.client.l2);
+  return quoteL2Gas({
+    estimator,
+    route,
+    tx: l2TxForModeling ? toCoreTx(l2TxForModeling) : void 0,
+    gasPerPubdata: ctx.gasPerPubdata,
+    l2GasLimit: ctx.l2GasLimit,
+    // TODO: investigate if this should be passed here; weird viem quirk
+    overrideGasLimit,
+    stateOverrides: input.stateOverrides
+  });
+}
+async function determineErc20L2Gas(input) {
+  const { ctx, l1Token } = input;
+  const DEFAULT_SAFE_L2_GAS_LIMIT = 3000000n;
+  if (ctx.l2GasLimit != null) {
+    return quoteL2Gas2({
+      ctx,
+      route: "erc20-nonbase",
+      overrideGasLimit: ctx.l2GasLimit
+    });
+  }
+  try {
+    const l2NativeTokenVault = (await ctx.client.contracts()).l2NativeTokenVault;
+    const l2TokenAddress = await ctx.client.l2.readContract({
+      address: l2NativeTokenVault.address,
+      abi: l2NativeTokenVault.abi,
+      functionName: "l2TokenAddress",
+      args: [l1Token]
+    });
+    if (l2TokenAddress === viem.zeroAddress) {
+      return quoteL2Gas2({
+        ctx,
+        route: "erc20-nonbase",
+        overrideGasLimit: DEFAULT_SAFE_L2_GAS_LIMIT
+      });
+    }
+    const modelTx = {
+      to: input.modelTx?.to ?? ctx.sender,
+      from: input.modelTx?.from ?? ctx.sender,
+      data: input.modelTx?.data ?? "0x",
+      value: input.modelTx?.value ?? 0n
+    };
+    const gas = await quoteL2Gas2({
+      ctx,
+      route: "erc20-nonbase",
+      l2TxForModeling: modelTx
+    });
+    if (!gas) {
+      return quoteL2Gas2({
+        ctx,
+        route: "erc20-nonbase",
+        overrideGasLimit: DEFAULT_SAFE_L2_GAS_LIMIT
+      });
+    }
+    return gas;
+  } catch (err) {
+    console.warn("Failed to determine ERC20 L2 gas; defaulting to safe gas limit.", err);
+    return quoteL2Gas2({
+      ctx,
+      route: "erc20-nonbase",
+      overrideGasLimit: DEFAULT_SAFE_L2_GAS_LIMIT
+    });
+  }
+}
+
+// src/adapters/viem/resources/deposits/services/fee.ts
 var { wrapAs } = createErrorHandlers("deposits");
+async function quoteL2BaseCost(input) {
+  const { ctx, l2GasLimit } = input;
+  const estimator = viemToGasEstimator(ctx.client.l1);
+  const fees = await estimator.estimateFeesPerGas();
+  const gasPrice = fees.maxFeePerGas ?? fees.gasPrice ?? await estimator.getGasPrice();
+  return wrapAs(
+    "RPC",
+    "deposits.fees.l2BaseCost",
+    async () => {
+      return await ctx.client.l1.readContract({
+        address: ctx.bridgehub,
+        abi: IBridgehub_default,
+        functionName: "l2TransactionBaseCost",
+        args: [ctx.chainIdL2, gasPrice, l2GasLimit, ctx.gasPerPubdata]
+      });
+    },
+    { ctx: { chainIdL2: ctx.chainIdL2 } }
+  );
+}
+
+// src/core/resources/deposits/fee.ts
+function buildFeeBreakdown(p) {
+  const l1MaxTotal = p.l1Gas?.maxCost ?? 0n;
+  const l2Total = p.l2BaseCost + p.operatorTip;
+  const l1 = {
+    gasLimit: p.l1Gas?.gasLimit ?? 0n,
+    maxFeePerGas: p.l1Gas?.maxFeePerGas ?? 0n,
+    maxPriorityFeePerGas: p.l1Gas?.maxPriorityFeePerGas,
+    maxTotal: l1MaxTotal
+  };
+  const l2 = {
+    total: l2Total,
+    baseCost: p.l2BaseCost,
+    operatorTip: p.operatorTip,
+    gasLimit: p.l2Gas?.gasLimit ?? 0n,
+    maxFeePerGas: p.l2Gas?.maxFeePerGas ?? 0n,
+    maxPriorityFeePerGas: p.l2Gas?.maxPriorityFeePerGas,
+    gasPerPubdata: p.l2Gas?.gasPerPubdata ?? 0n
+  };
+  return {
+    token: p.feeToken,
+    maxTotal: l1MaxTotal + l2Total,
+    mintValue: p.mintValue,
+    l1,
+    l2
+  };
+}
+
+// src/adapters/viem/resources/deposits/routes/eth.ts
+var { wrapAs: wrapAs2 } = createErrorHandlers("deposits");
 function routeEthDirect() {
   return {
     async build(p, ctx) {
-      const { gasPriceForBaseCost } = ctx.fee;
-      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
-      const rawBaseCost = await wrapAs(
-        "CONTRACT",
-        OP_DEPOSITS.eth.baseCost,
-        () => ctx.client.l1.readContract({
-          address: ctx.bridgehub,
-          abi: IBridgehub_default,
-          functionName: "l2TransactionBaseCost",
-          args: [ctx.chainIdL2, gasPriceForBaseCost, ctx.l2GasLimit, ctx.gasPerPubdata]
-        }),
-        {
-          ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 },
-          message: "Could not fetch L2 base cost from Bridgehub."
+      const l2TxModel = {
+        to: p.to ?? ctx.sender,
+        from: ctx.sender,
+        data: "0x",
+        value: p.amount
+      };
+      const l2GasParams = await quoteL2Gas2({
+        ctx,
+        route: "eth-base",
+        l2TxForModeling: l2TxModel,
+        overrideGasLimit: ctx.l2GasLimit,
+        stateOverrides: {
+          [ctx.sender]: {
+            balance: "0xffffffffffffffffffff"
+          }
         }
-      );
-      const baseCost = rawBaseCost;
+      });
+      if (!l2GasParams) {
+        throw new Error("Failed to estimate L2 gas for deposit.");
+      }
+      const baseCost = await quoteL2BaseCost({ ctx, l2GasLimit: l2GasParams.gasLimit });
       const l2Contract = p.to ?? ctx.sender;
       const l2Value = p.amount;
       const mintValue = baseCost + ctx.operatorTip + l2Value;
       const req = buildDirectRequestStruct({
         chainId: ctx.chainIdL2,
         mintValue,
-        l2GasLimit: ctx.l2GasLimit,
+        l2GasLimit: l2GasParams.gasLimit,
         gasPerPubdata: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
         l2Contract,
         l2Value
       });
-      const sim = await wrapAs(
+      const sim = await wrapAs2(
         "RPC",
         OP_DEPOSITS.eth.estGas,
         () => ctx.client.l1.simulateContract({
@@ -4387,33 +4612,53 @@ function routeEthDirect() {
           message: "Failed to simulate Bridgehub.requestL2TransactionDirect."
         }
       );
-      const resolvedL1GasLimit = sim.request.gas ?? ctx.l2GasLimit;
+      const data = viem.encodeFunctionData({
+        abi: sim.request.abi,
+        functionName: sim.request.functionName,
+        args: sim.request.args
+      });
+      const l1TxCandidate = {
+        to: ctx.bridgehub,
+        data,
+        value: mintValue,
+        from: ctx.sender,
+        ...ctx.gasOverrides
+      };
+      const l1Gas = await quoteL1Gas2({
+        ctx,
+        tx: l1TxCandidate,
+        overrides: ctx.gasOverrides
+      });
       const steps = [
         {
           key: "bridgehub:direct",
           kind: "bridgehub:direct",
           description: "Bridge ETH via Bridgehub.requestL2TransactionDirect",
-          tx: { ...sim.request, ...txFeeOverrides }
+          tx: { ...sim.request, ...l1Gas }
         }
       ];
+      const fees = buildFeeBreakdown({
+        feeToken: ETH_ADDRESS,
+        l1Gas,
+        l2Gas: l2GasParams,
+        l2BaseCost: baseCost,
+        operatorTip: ctx.operatorTip,
+        mintValue
+      });
       return {
         steps,
         approvals: [],
-        quoteExtras: { baseCost, mintValue, l1GasLimit: resolvedL1GasLimit }
+        fees
       };
     }
   };
 }
-
-// src/adapters/viem/resources/deposits/routes/erc20-nonbase.ts
-var { wrapAs: wrapAs2 } = createErrorHandlers("deposits");
-var BASE_COST_BUFFER_BPS = 100n;
-var BPS = 10000n;
-var withBuffer = (x) => x * (BPS + BASE_COST_BUFFER_BPS) / BPS;
+var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
 function routeErc20NonBase() {
   return {
+    // TODO: do we even need these validations?
     async preflight(p, ctx) {
-      await wrapAs2(
+      await wrapAs3(
         "VALIDATION",
         OP_DEPOSITS.nonbase.assertNotEthAsset,
         () => {
@@ -4423,18 +4668,8 @@ function routeErc20NonBase() {
         },
         { ctx: { token: p.token } }
       );
-      const baseToken = await wrapAs2(
-        "CONTRACT",
-        OP_DEPOSITS.nonbase.baseToken,
-        () => ctx.client.l1.readContract({
-          address: ctx.bridgehub,
-          abi: IBridgehub_default,
-          functionName: "baseToken",
-          args: [ctx.chainIdL2]
-        }),
-        { ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 } }
-      );
-      await wrapAs2(
+      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
+      await wrapAs3(
         "VALIDATION",
         OP_DEPOSITS.nonbase.assertNonBaseToken,
         () => {
@@ -4444,63 +4679,49 @@ function routeErc20NonBase() {
         },
         { ctx: { depositToken: p.token, baseToken } }
       );
-      return;
     },
     async build(p, ctx) {
-      const { gasPriceForBaseCost } = ctx.fee;
-      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
-      const baseToken = await wrapAs2(
-        "CONTRACT",
-        OP_DEPOSITS.nonbase.baseToken,
-        () => ctx.client.l1.readContract({
-          address: ctx.bridgehub,
-          abi: IBridgehub_default,
-          functionName: "baseToken",
-          args: [ctx.chainIdL2]
-        }),
-        { ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 } }
-      );
-      const MIN_L2_GAS_FOR_ERC20 = 2500000n;
-      const l2GasLimitUsed = ctx.l2GasLimit && ctx.l2GasLimit > 0n ? ctx.l2GasLimit < MIN_L2_GAS_FOR_ERC20 ? MIN_L2_GAS_FOR_ERC20 : ctx.l2GasLimit : MIN_L2_GAS_FOR_ERC20;
-      const rawBaseCost = await wrapAs2(
-        "CONTRACT",
-        OP_DEPOSITS.nonbase.baseCost,
-        () => ctx.client.l1.readContract({
-          address: ctx.bridgehub,
-          abi: IBridgehub_default,
-          functionName: "l2TransactionBaseCost",
-          args: [ctx.chainIdL2, gasPriceForBaseCost, l2GasLimitUsed, ctx.gasPerPubdata]
-        }),
-        { ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 } }
-      );
-      const baseCost = rawBaseCost;
-      const mintValue = withBuffer(baseCost + ctx.operatorTip);
+      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
+      const baseIsEth = isETH(baseToken);
+      const assetRouter = ctx.l1AssetRouter;
+      const l2Gas = await determineErc20L2Gas({
+        ctx,
+        l1Token: p.token,
+        modelTx: {
+          to: p.to ?? ctx.sender,
+          from: ctx.sender,
+          data: "0x",
+          value: 0n
+        }
+      });
+      if (!l2Gas) throw new Error("Failed to establish L2 gas parameters.");
+      const l2BaseCost = await quoteL2BaseCost({ ctx, l2GasLimit: l2Gas.gasLimit });
+      const mintValue = l2BaseCost + ctx.operatorTip;
       const approvals = [];
       const steps = [];
-      const depositAllowance = await wrapAs2(
+      const depositAllowance = await wrapAs3(
         "CONTRACT",
-        OP_DEPOSITS.nonbase.allowance,
+        OP_DEPOSITS.nonbase.allowanceToken,
         () => ctx.client.l1.readContract({
           address: p.token,
           abi: IERC20_default,
           functionName: "allowance",
-          args: [ctx.sender, ctx.l1AssetRouter]
+          args: [ctx.sender, assetRouter]
         }),
         {
-          ctx: { where: "erc20.allowance", token: p.token, spender: ctx.l1AssetRouter },
-          message: "Failed to read ERC-20 allowance for deposit token."
+          ctx: { where: "erc20.allowance", token: p.token, spender: assetRouter },
+          message: "Failed to read deposit-token allowance."
         }
       );
-      const needsDepositApprove = depositAllowance < p.amount;
-      if (needsDepositApprove) {
-        const approveDepReq = await wrapAs2(
+      if (depositAllowance < p.amount) {
+        const approveSim = await wrapAs3(
           "CONTRACT",
           OP_DEPOSITS.nonbase.estGas,
           () => ctx.client.l1.simulateContract({
             address: p.token,
             abi: IERC20_default,
             functionName: "approve",
-            args: [ctx.l1AssetRouter, p.amount],
+            args: [assetRouter, p.amount],
             account: ctx.client.account
           }),
           {
@@ -4508,60 +4729,55 @@ function routeErc20NonBase() {
             message: "Failed to simulate deposit token approve."
           }
         );
-        approvals.push({ token: p.token, spender: ctx.l1AssetRouter, amount: p.amount });
+        approvals.push({ token: p.token, spender: assetRouter, amount: p.amount });
         steps.push({
-          key: `approve:${p.token}:${ctx.l1AssetRouter}`,
+          key: `approve:${p.token}:${assetRouter}`,
           kind: "approve",
           description: `Approve deposit token for amount`,
-          tx: { ...approveDepReq.request, ...txFeeOverrides }
+          tx: { ...approveSim.request }
         });
       }
-      const baseIsEth = isETH(baseToken);
-      let msgValue = 0n;
       if (!baseIsEth) {
-        const baseAllowance = await wrapAs2(
+        const baseAllowance = await wrapAs3(
           "CONTRACT",
-          OP_DEPOSITS.nonbase.allowanceFees,
+          OP_DEPOSITS.nonbase.allowanceBase,
           () => ctx.client.l1.readContract({
             address: baseToken,
             abi: IERC20_default,
             functionName: "allowance",
-            args: [ctx.sender, ctx.l1AssetRouter]
+            args: [ctx.sender, assetRouter]
           }),
           {
-            ctx: { where: "erc20.allowance", token: baseToken, spender: ctx.l1AssetRouter },
+            ctx: { where: "erc20.allowance", token: baseToken, spender: assetRouter },
             message: "Failed to read base-token allowance."
           }
         );
         if (baseAllowance < mintValue) {
-          const approveBaseReq = await wrapAs2(
+          const approveBaseSim = await wrapAs3(
             "CONTRACT",
             OP_DEPOSITS.nonbase.estGas,
             () => ctx.client.l1.simulateContract({
               address: baseToken,
               abi: IERC20_default,
               functionName: "approve",
-              args: [ctx.l1AssetRouter, mintValue],
+              args: [assetRouter, mintValue],
               account: ctx.client.account
             }),
             {
               ctx: { where: "l1.simulateContract", to: baseToken },
-              message: "Failed to simulate base-token approve."
+              message: "Failed to simulate base token approve."
             }
           );
-          approvals.push({ token: baseToken, spender: ctx.l1AssetRouter, amount: mintValue });
+          approvals.push({ token: baseToken, spender: assetRouter, amount: mintValue });
           steps.push({
-            key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
+            key: `approve:${baseToken}:${assetRouter}`,
             kind: "approve",
             description: `Approve base token for mintValue`,
-            tx: { ...approveBaseReq.request, ...txFeeOverrides }
+            tx: { ...approveBaseSim.request }
           });
         }
-        msgValue = 0n;
-      } else {
-        msgValue = mintValue;
       }
-      const secondBridgeCalldata = await wrapAs2(
+      const secondBridgeCalldata = await wrapAs3(
         "INTERNAL",
         OP_DEPOSITS.nonbase.encodeCalldata,
         () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, p.to ?? ctx.sender)),
@@ -4570,44 +4786,60 @@ function routeErc20NonBase() {
             where: "encodeSecondBridgeErc20Args",
             token: p.token,
             amount: p.amount.toString()
-          }
+          },
+          message: "Failed to encode bridging calldata."
         }
       );
-      const outer = {
+      const requestStruct = {
         chainId: ctx.chainIdL2,
         mintValue,
         l2Value: 0n,
-        l2GasLimit: l2GasLimitUsed,
+        l2GasLimit: l2Gas.gasLimit,
         l2GasPerPubdataByteLimit: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
-        secondBridgeAddress: ctx.l1AssetRouter,
+        secondBridgeAddress: assetRouter,
         secondBridgeValue: 0n,
         secondBridgeCalldata
       };
+      const msgValue = baseIsEth ? mintValue : 0n;
+      const calldata = viem.encodeFunctionData({
+        abi: IBridgehub_default,
+        functionName: "requestL2TransactionTwoBridges",
+        args: [requestStruct]
+      });
+      const l1TxCandidate = {
+        to: ctx.bridgehub,
+        data: calldata,
+        value: msgValue,
+        from: ctx.sender,
+        ...ctx.gasOverrides
+      };
+      const l1Gas = await quoteL1Gas2({
+        ctx,
+        tx: l1TxCandidate,
+        overrides: ctx.gasOverrides,
+        fallbackGasLimit: SAFE_L1_BRIDGE_GAS
+      });
       const approvalsNeeded = approvals.length > 0;
       let bridgeTx;
-      let resolvedL1GasLimit;
-      const gasOverride = txFeeOverrides.gas;
       if (approvalsNeeded) {
         bridgeTx = {
           address: ctx.bridgehub,
           abi: IBridgehub_default,
           functionName: "requestL2TransactionTwoBridges",
-          args: [outer],
+          args: [requestStruct],
           value: msgValue,
-          account: ctx.client.account,
-          ...txFeeOverrides
+          account: ctx.client.account
         };
-        resolvedL1GasLimit = gasOverride ?? ctx.l2GasLimit;
       } else {
-        const sim = await wrapAs2(
+        const sim = await wrapAs3(
           "CONTRACT",
           OP_DEPOSITS.nonbase.estGas,
           () => ctx.client.l1.simulateContract({
             address: ctx.bridgehub,
             abi: IBridgehub_default,
             functionName: "requestL2TransactionTwoBridges",
-            args: [outer],
+            args: [requestStruct],
             value: msgValue,
             account: ctx.client.account
           }),
@@ -4616,33 +4848,44 @@ function routeErc20NonBase() {
             message: "Failed to simulate two-bridges request."
           }
         );
-        bridgeTx = { ...sim.request, ...txFeeOverrides };
-        resolvedL1GasLimit = sim.request.gas ?? ctx.l2GasLimit;
+        bridgeTx = { ...sim.request };
+      }
+      if (l1Gas) {
+        bridgeTx = {
+          ...bridgeTx,
+          gas: l1Gas.gasLimit,
+          maxFeePerGas: l1Gas.maxFeePerGas,
+          maxPriorityFeePerGas: l1Gas.maxPriorityFeePerGas
+        };
       }
       steps.push({
-        key: "bridgehub:two-bridges:nonbase",
+        key: "bridgehub:two-bridges:erc20-nonbase",
         kind: "bridgehub:two-bridges",
         description: baseIsEth ? "Bridge ERC-20 (fees in ETH) via Bridgehub.requestL2TransactionTwoBridges" : "Bridge ERC-20 (fees in base ERC-20) via Bridgehub.requestL2TransactionTwoBridges",
         tx: bridgeTx
       });
+      const fees = buildFeeBreakdown({
+        feeToken: baseToken,
+        l1Gas,
+        l2Gas,
+        l2BaseCost,
+        operatorTip: ctx.operatorTip,
+        mintValue
+      });
       return {
         steps,
         approvals,
-        quoteExtras: { baseCost, mintValue, l1GasLimit: resolvedL1GasLimit }
+        fees
       };
     }
   };
 }
-
-// src/adapters/viem/resources/deposits/routes/eth-nonbase.ts
-var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
-var BASE_COST_BUFFER_BPS2 = 100n;
-var BPS2 = 10000n;
-var withBuffer2 = (x) => x * (BPS2 + BASE_COST_BUFFER_BPS2) / BPS2;
+var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
 function routeEthNonBase() {
   return {
+    // TODO: do we even need these validations?
     async preflight(p, ctx) {
-      await wrapAs3(
+      await wrapAs4(
         "VALIDATION",
         OP_DEPOSITS.ethNonBase.assertEthAsset,
         () => {
@@ -4652,21 +4895,8 @@ function routeEthNonBase() {
         },
         { ctx: { token: p.token } }
       );
-      const baseToken = await wrapAs3(
-        "CONTRACT",
-        OP_DEPOSITS.ethNonBase.baseToken,
-        () => ctx.client.l1.readContract({
-          address: ctx.bridgehub,
-          abi: IBridgehub_default,
-          functionName: "baseToken",
-          args: [ctx.chainIdL2]
-        }),
-        {
-          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
-          message: "Failed to read base token."
-        }
-      );
-      await wrapAs3(
+      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
+      await wrapAs4(
         "VALIDATION",
         OP_DEPOSITS.ethNonBase.assertNonEthBase,
         () => {
@@ -4676,7 +4906,7 @@ function routeEthNonBase() {
         },
         { ctx: { baseToken, chainIdL2: ctx.chainIdL2 } }
       );
-      const ethBal = await wrapAs3(
+      const ethBal = await wrapAs4(
         "RPC",
         OP_DEPOSITS.ethNonBase.ethBalance,
         () => ctx.client.l1.getBalance({ address: ctx.sender }),
@@ -4685,7 +4915,7 @@ function routeEthNonBase() {
           message: "Failed to read L1 ETH balance."
         }
       );
-      await wrapAs3(
+      await wrapAs4(
         "VALIDATION",
         OP_DEPOSITS.ethNonBase.assertEthBalance,
         () => {
@@ -4695,45 +4925,27 @@ function routeEthNonBase() {
         },
         { ctx: { required: p.amount.toString(), balance: ethBal.toString() } }
       );
-      return;
     },
     async build(p, ctx) {
-      const { gasPriceForBaseCost } = ctx.fee;
-      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
-      const baseToken = await wrapAs3(
-        "CONTRACT",
-        OP_DEPOSITS.ethNonBase.baseToken,
-        () => ctx.client.l1.readContract({
-          address: ctx.bridgehub,
-          abi: IBridgehub_default,
-          functionName: "baseToken",
-          args: [ctx.chainIdL2]
-        }),
-        {
-          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
-          message: "Failed to read base token."
-        }
-      );
-      const rawBaseCost = await wrapAs3(
-        "CONTRACT",
-        OP_DEPOSITS.ethNonBase.baseCost,
-        () => ctx.client.l1.readContract({
-          address: ctx.bridgehub,
-          abi: IBridgehub_default,
-          functionName: "l2TransactionBaseCost",
-          args: [ctx.chainIdL2, gasPriceForBaseCost, ctx.l2GasLimit, ctx.gasPerPubdata]
-        }),
-        {
-          ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 },
-          message: "Could not fetch L2 base cost."
-        }
-      );
-      const baseCost = BigInt(rawBaseCost);
-      const mintValueRaw = baseCost + ctx.operatorTip;
-      const mintValue = withBuffer2(mintValueRaw);
+      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
+      const l2TxModel = {
+        to: p.to ?? ctx.sender,
+        from: ctx.sender,
+        data: "0x",
+        value: 0n
+      };
+      const l2Gas = await quoteL2Gas2({
+        ctx,
+        route: "eth-nonbase",
+        l2TxForModeling: l2TxModel,
+        overrideGasLimit: ctx.l2GasLimit
+      });
+      if (!l2Gas) throw new Error("Failed to estimate L2 gas parameters.");
+      const l2BaseCost = await quoteL2BaseCost({ ctx, l2GasLimit: l2Gas.gasLimit });
+      const mintValue = l2BaseCost + ctx.operatorTip;
       const approvals = [];
       const steps = [];
-      const allowance = await wrapAs3(
+      const allowance = await wrapAs4(
         "CONTRACT",
         OP_DEPOSITS.ethNonBase.allowanceBase,
         () => ctx.client.l1.readContract({
@@ -4749,7 +4961,7 @@ function routeEthNonBase() {
       );
       const needsApprove = allowance < mintValue;
       if (needsApprove) {
-        const approveSim = await wrapAs3(
+        const approveSim = await wrapAs4(
           "CONTRACT",
           OP_DEPOSITS.ethNonBase.estGas,
           () => ctx.client.l1.simulateContract({
@@ -4768,11 +4980,11 @@ function routeEthNonBase() {
         steps.push({
           key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
           kind: "approve",
-          description: `Approve base token for mintValue`,
+          description: `Approve base token for fees (mintValue)`,
           tx: { ...approveSim.request }
         });
       }
-      const secondBridgeCalldata = await wrapAs3(
+      const secondBridgeCalldata = await wrapAs4(
         "INTERNAL",
         OP_DEPOSITS.ethNonBase.encodeCalldata,
         () => Promise.resolve(encodeSecondBridgeEthArgs(p.amount, p.to ?? ctx.sender)),
@@ -4785,11 +4997,11 @@ function routeEthNonBase() {
           message: "Failed to encode ETH bridging calldata."
         }
       );
-      const outer = {
+      const requestStruct = {
         chainId: ctx.chainIdL2,
         mintValue,
-        l2Value: 0n,
-        l2GasLimit: ctx.l2GasLimit,
+        l2Value: p.amount,
+        l2GasLimit: l2Gas.gasLimit,
         l2GasPerPubdataByteLimit: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
         secondBridgeAddress: ctx.l1AssetRouter,
@@ -4797,29 +5009,32 @@ function routeEthNonBase() {
         secondBridgeCalldata
       };
       let bridgeTx;
-      let resolvedL1GasLimit;
+      let calldata;
       if (needsApprove) {
         bridgeTx = {
           address: ctx.bridgehub,
           abi: IBridgehub_default,
           functionName: "requestL2TransactionTwoBridges",
-          args: [outer],
+          args: [requestStruct],
           value: p.amount,
           // base ≠ ETH ⇒ msg.value == secondBridgeValue
           account: ctx.client.account
         };
-        resolvedL1GasLimit = ctx.l2GasLimit;
+        calldata = viem.encodeFunctionData({
+          abi: IBridgehub_default,
+          functionName: "requestL2TransactionTwoBridges",
+          args: [requestStruct]
+        });
       } else {
-        const twoBridgesSim = await wrapAs3(
+        const sim = await wrapAs4(
           "CONTRACT",
           OP_DEPOSITS.ethNonBase.estGas,
           () => ctx.client.l1.simulateContract({
             address: ctx.bridgehub,
             abi: IBridgehub_default,
             functionName: "requestL2TransactionTwoBridges",
-            args: [outer],
+            args: [requestStruct],
             value: p.amount,
-            // base ≠ ETH ⇒ msg.value == secondBridgeValue
             account: ctx.client.account
           }),
           {
@@ -4827,8 +5042,33 @@ function routeEthNonBase() {
             message: "Failed to simulate Bridgehub two-bridges request."
           }
         );
-        bridgeTx = { ...twoBridgesSim.request, ...txFeeOverrides };
-        resolvedL1GasLimit = twoBridgesSim.request.gas ?? ctx.l2GasLimit;
+        calldata = viem.encodeFunctionData({
+          abi: sim.request.abi,
+          functionName: sim.request.functionName,
+          args: sim.request.args
+        });
+        bridgeTx = { ...sim.request };
+      }
+      const l1TxCandidate = {
+        to: ctx.bridgehub,
+        data: calldata,
+        value: p.amount,
+        from: ctx.sender,
+        ...ctx.gasOverrides
+      };
+      const l1Gas = await quoteL1Gas2({
+        ctx,
+        tx: l1TxCandidate,
+        overrides: ctx.gasOverrides,
+        fallbackGasLimit: SAFE_L1_BRIDGE_GAS
+      });
+      if (l1Gas) {
+        bridgeTx = {
+          ...bridgeTx,
+          gas: l1Gas.gasLimit,
+          maxFeePerGas: l1Gas.maxFeePerGas,
+          maxPriorityFeePerGas: l1Gas.maxPriorityFeePerGas
+        };
       }
       steps.push({
         key: "bridgehub:two-bridges:eth-nonbase",
@@ -4836,24 +5076,27 @@ function routeEthNonBase() {
         description: "Bridge ETH (fees in base ERC-20) via Bridgehub.requestL2TransactionTwoBridges",
         tx: bridgeTx
       });
+      const fees = buildFeeBreakdown({
+        feeToken: baseToken,
+        l1Gas,
+        l2Gas,
+        l2BaseCost,
+        operatorTip: ctx.operatorTip,
+        mintValue
+      });
       return {
         steps,
         approvals,
-        quoteExtras: { baseCost, mintValue, l1GasLimit: resolvedL1GasLimit }
+        fees
       };
     }
   };
 }
-
-// src/adapters/viem/resources/deposits/routes/erc20-base.ts
-var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
-var BASE_COST_BUFFER_BPS3 = 100n;
-var BPS3 = 10000n;
-var withBuffer3 = (x) => x * (BPS3 + BASE_COST_BUFFER_BPS3) / BPS3;
+var { wrapAs: wrapAs5 } = createErrorHandlers("deposits");
 function routeErc20Base() {
   return {
     async preflight(p, ctx) {
-      await wrapAs4(
+      await wrapAs5(
         "VALIDATION",
         OP_DEPOSITS.base.assertErc20Asset,
         () => {
@@ -4863,21 +5106,8 @@ function routeErc20Base() {
         },
         { ctx: { token: p.token } }
       );
-      const baseToken = await wrapAs4(
-        "CONTRACT",
-        OP_DEPOSITS.base.baseToken,
-        () => ctx.client.l1.readContract({
-          address: ctx.bridgehub,
-          abi: IBridgehub_default,
-          functionName: "baseToken",
-          args: [ctx.chainIdL2]
-        }),
-        {
-          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
-          message: "Failed to read base token."
-        }
-      );
-      await wrapAs4(
+      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
+      await wrapAs5(
         "VALIDATION",
         OP_DEPOSITS.base.assertMatchesBase,
         () => {
@@ -4887,45 +5117,27 @@ function routeErc20Base() {
         },
         { ctx: { baseToken, provided: p.token, chainIdL2: ctx.chainIdL2 } }
       );
-      return;
     },
     async build(p, ctx) {
-      const { gasPriceForBaseCost } = ctx.fee;
-      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
-      const gasOverride = txFeeOverrides.gas;
-      const baseToken = await wrapAs4(
-        "CONTRACT",
-        OP_DEPOSITS.base.baseToken,
-        () => ctx.client.l1.readContract({
-          address: ctx.bridgehub,
-          abi: IBridgehub_default,
-          functionName: "baseToken",
-          args: [ctx.chainIdL2]
-        }),
-        {
-          ctx: { where: "bridgehub.baseToken", chainIdL2: ctx.chainIdL2 },
-          message: "Failed to read base token."
-        }
-      );
-      const rawBaseCost = await wrapAs4(
-        "CONTRACT",
-        OP_DEPOSITS.base.baseCost,
-        () => ctx.client.l1.readContract({
-          address: ctx.bridgehub,
-          abi: IBridgehub_default,
-          functionName: "l2TransactionBaseCost",
-          args: [ctx.chainIdL2, gasPriceForBaseCost, ctx.l2GasLimit, ctx.gasPerPubdata]
-        }),
-        {
-          ctx: { where: "l2TransactionBaseCost", chainIdL2: ctx.chainIdL2 },
-          message: "Could not fetch L2 base cost from Bridgehub."
-        }
-      );
-      const baseCost = rawBaseCost;
-      const l2Value = p.amount;
-      const rawMintValue = baseCost + ctx.operatorTip + l2Value;
-      const mintValue = withBuffer3(rawMintValue);
-      const allowance = await wrapAs4(
+      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
+      const l2TxModel = {
+        to: p.to ?? ctx.sender,
+        from: ctx.sender,
+        data: "0x",
+        value: 0n
+      };
+      const l2Gas = await quoteL2Gas2({
+        ctx,
+        route: "erc20-base",
+        l2TxForModeling: l2TxModel,
+        overrideGasLimit: ctx.l2GasLimit
+      });
+      if (!l2Gas) throw new Error("Failed to estimate L2 gas parameters.");
+      const l2BaseCost = await quoteL2BaseCost({ ctx, l2GasLimit: l2Gas.gasLimit });
+      const mintValue = l2BaseCost + ctx.operatorTip + p.amount;
+      const approvals = [];
+      const steps = [];
+      const allowance = await wrapAs5(
         "CONTRACT",
         OP_DEPOSITS.base.allowance,
         () => ctx.client.l1.readContract({
@@ -4939,11 +5151,9 @@ function routeErc20Base() {
           message: "Failed to read base-token allowance."
         }
       );
-      const approvals = [];
-      const steps = [];
       const needsApprove = allowance < mintValue;
       if (needsApprove) {
-        const approveSim = await wrapAs4(
+        const approveSim = await wrapAs5(
           "CONTRACT",
           OP_DEPOSITS.base.estGas,
           () => ctx.client.l1.simulateContract({
@@ -4963,20 +5173,20 @@ function routeErc20Base() {
           key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
           kind: "approve",
           description: "Approve base token for mintValue",
-          tx: { ...approveSim.request, ...txFeeOverrides }
+          tx: { ...approveSim.request }
         });
       }
       const req = buildDirectRequestStruct({
         chainId: ctx.chainIdL2,
         mintValue,
-        l2GasLimit: ctx.l2GasLimit,
+        l2GasLimit: l2Gas.gasLimit,
         gasPerPubdata: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
         l2Contract: p.to ?? ctx.sender,
-        l2Value
+        l2Value: p.amount
       });
       let bridgeTx;
-      let resolvedL1GasLimit;
+      let calldata;
       if (needsApprove) {
         bridgeTx = {
           address: ctx.bridgehub,
@@ -4984,13 +5194,16 @@ function routeErc20Base() {
           functionName: "requestL2TransactionDirect",
           args: [req],
           value: 0n,
-          // base is ERC-20 ⇒ msg.value MUST be 0
-          account: ctx.client.account,
-          ...txFeeOverrides
+          // base token is ERC-20 ⇒ msg.value MUST be 0
+          account: ctx.client.account
         };
-        resolvedL1GasLimit = gasOverride ?? ctx.l2GasLimit;
+        calldata = viem.encodeFunctionData({
+          abi: IBridgehub_default,
+          functionName: "requestL2TransactionDirect",
+          args: [req]
+        });
       } else {
-        const sim = await wrapAs4(
+        const sim = await wrapAs5(
           "RPC",
           OP_DEPOSITS.base.estGas,
           () => ctx.client.l1.simulateContract({
@@ -5006,8 +5219,33 @@ function routeErc20Base() {
             message: "Failed to simulate Bridgehub.requestL2TransactionDirect."
           }
         );
-        bridgeTx = { ...sim.request, ...txFeeOverrides };
-        resolvedL1GasLimit = sim.request.gas ?? ctx.l2GasLimit;
+        calldata = viem.encodeFunctionData({
+          abi: sim.request.abi,
+          functionName: sim.request.functionName,
+          args: sim.request.args
+        });
+        bridgeTx = { ...sim.request };
+      }
+      const l1TxCandidate = {
+        to: ctx.bridgehub,
+        data: calldata,
+        value: 0n,
+        from: ctx.sender,
+        ...ctx.gasOverrides
+      };
+      const l1Gas = await quoteL1Gas2({
+        ctx,
+        tx: l1TxCandidate,
+        overrides: ctx.gasOverrides,
+        fallbackGasLimit: SAFE_L1_BRIDGE_GAS
+      });
+      if (l1Gas) {
+        bridgeTx = {
+          ...bridgeTx,
+          gas: l1Gas.gasLimit,
+          maxFeePerGas: l1Gas.maxFeePerGas,
+          maxPriorityFeePerGas: l1Gas.maxPriorityFeePerGas
+        };
       }
       steps.push({
         key: "bridgehub:direct:erc20-base",
@@ -5015,10 +5253,18 @@ function routeErc20Base() {
         description: "Bridge base ERC-20 via Bridgehub.requestL2TransactionDirect",
         tx: bridgeTx
       });
+      const fees = buildFeeBreakdown({
+        feeToken: baseToken,
+        l1Gas,
+        l2Gas,
+        l2BaseCost,
+        operatorTip: ctx.operatorTip,
+        mintValue
+      });
       return {
         steps,
         approvals,
-        quoteExtras: { baseCost, mintValue, l1GasLimit: resolvedL1GasLimit }
+        fees
       };
     }
   };
@@ -5112,32 +5358,19 @@ function createDepositsResource(client) {
     const ctx = await commonCtx(p, client);
     const route = ctx.route;
     await ROUTES[route].preflight?.(p, ctx);
-    const { steps, approvals, quoteExtras } = await ROUTES[route].build(p, ctx);
-    const { baseCost, mintValue } = quoteExtras;
-    const fallbackGasLimit = quoteExtras.l1GasLimit;
-    const resolveGasLimit = () => {
-      if (ctx.fee.gasLimit != null) return ctx.fee.gasLimit;
-      for (let i = steps.length - 1; i >= 0; i--) {
-        const candidate = steps[i].tx.gas;
-        if (candidate != null) return candidate;
-      }
-      if (fallbackGasLimit != null) return fallbackGasLimit;
-      return ctx.l2GasLimit;
-    };
-    const gasLimit = resolveGasLimit();
+    const { steps, approvals, fees } = await ROUTES[route].build(p, ctx);
     return {
       route: ctx.route,
       summary: {
         route: ctx.route,
         approvalsNeeded: approvals,
-        baseCost,
-        mintValue,
-        gasPerPubdata: ctx.gasPerPubdata,
-        fees: {
-          gasLimit,
-          maxFeePerGas: ctx.fee.maxFeePerGas,
-          maxPriorityFeePerGas: ctx.fee.maxPriorityFeePerGas
-        }
+        amounts: {
+          transfer: { token: p.token, amount: p.amount }
+        },
+        fees,
+        // Legacy fields (maintained for backward compatibility)
+        baseCost: fees.l2?.baseCost,
+        mintValue: fees.mintValue
       },
       steps
     };
@@ -5212,7 +5445,7 @@ function createDepositsResource(client) {
             step.tx.gas = overrides.gasLimit;
           }
         }
-        if (step.tx.gas == null) {
+        if (!p.l1TxOverrides?.gasLimit) {
           try {
             const feePart = step.tx.maxFeePerGas != null && step.tx.maxPriorityFeePerGas != null ? {
               maxFeePerGas: step.tx.maxFeePerGas,
@@ -5435,7 +5668,7 @@ function normalizeTokenForRouting(token) {
 function pickWithdrawRoute(args) {
   const tokenNorm = normalizeTokenForRouting(args.token);
   const isL2BaseAlias = tokenNorm.toLowerCase() === L2_BASE_TOKEN_ADDRESS.toLowerCase();
-  if (isL2BaseAlias) return args.baseIsEth ? "eth-base" : "eth-nonbase";
+  if (isL2BaseAlias) return "base";
   return "erc20-nonbase";
 }
 
@@ -5476,13 +5709,7 @@ async function commonCtx2(p, client) {
   } = await client.ensureAddresses();
   const chainIdL2 = BigInt(await client.l2.getChainId());
   const baseIsEth = await isEthBasedChain(client.l2, l2NativeTokenVault);
-  const fee = await getL2FeeOverrides(client, p.l2TxOverrides);
-  const route = pickWithdrawRoute({
-    token: p.token,
-    baseIsEth
-  });
-  const l2GasLimit = p.l2GasLimit ?? 300000n;
-  const gasBufferPct = 15;
+  const route = pickWithdrawRoute({ token: p.token});
   return {
     client,
     bridgehub,
@@ -5495,56 +5722,162 @@ async function commonCtx2(p, client) {
     l2NativeTokenVault,
     l2BaseTokenSystem,
     baseIsEth,
-    l2GasLimit,
-    gasBufferPct,
-    fee
+    gasOverrides: p.l2TxOverrides
+  };
+}
+
+// src/core/resources/withdrawals/gas.ts
+function makeGasQuote2(p) {
+  return {
+    gasLimit: p.gasLimit,
+    maxFeePerGas: p.maxFeePerGas,
+    maxPriorityFeePerGas: p.maxPriorityFeePerGas,
+    maxCost: p.gasLimit * p.maxFeePerGas
+  };
+}
+async function fetchFees2(estimator) {
+  try {
+    const fees = await estimator.estimateFeesPerGas();
+    if (fees.maxFeePerGas != null) {
+      return {
+        maxFeePerGas: fees.maxFeePerGas,
+        maxPriorityFeePerGas: fees.maxPriorityFeePerGas ?? 0n
+      };
+    }
+    if (fees.gasPrice != null) {
+      return {
+        maxFeePerGas: fees.gasPrice,
+        maxPriorityFeePerGas: 0n
+      };
+    }
+  } catch {
+  }
+  try {
+    const gp = await estimator.getGasPrice();
+    return { maxFeePerGas: gp, maxPriorityFeePerGas: 0n };
+  } catch {
+    return { maxFeePerGas: 0n, maxPriorityFeePerGas: 0n };
+  }
+}
+async function quoteL2Gas3(input) {
+  const { estimator, tx, overrides } = input;
+  const market = await fetchFees2(estimator);
+  const o = overrides;
+  const maxFeePerGas = o?.maxFeePerGas ?? (tx.maxFeePerGas != null ? BigInt(tx.maxFeePerGas) : market.maxFeePerGas);
+  const maxPriorityFeePerGas = o?.maxPriorityFeePerGas ?? (tx.maxPriorityFeePerGas != null ? BigInt(tx.maxPriorityFeePerGas) : market.maxPriorityFeePerGas);
+  const explicitGasLimit = o?.gasLimit ?? (tx.gasLimit != null ? BigInt(tx.gasLimit) : void 0);
+  if (explicitGasLimit != null) {
+    return makeGasQuote2({
+      gasLimit: explicitGasLimit,
+      maxFeePerGas,
+      maxPriorityFeePerGas
+    });
+  }
+  try {
+    const est = await estimator.estimateGas(tx);
+    const buffered = BigInt(est) * (100n + BUFFER) / 100n;
+    return makeGasQuote2({
+      gasLimit: buffered,
+      maxFeePerGas,
+      maxPriorityFeePerGas
+    });
+  } catch (err) {
+    console.warn("Failed to estimate L2 gas for withdrawal.", err);
+    return void 0;
+  }
+}
+
+// src/adapters/viem/resources/withdrawals/services/gas.ts
+async function quoteL2Gas4(input) {
+  const { ctx, tx } = input;
+  const estimator = viemToGasEstimator(ctx.client.l2);
+  return quoteL2Gas3({
+    estimator,
+    tx: toCoreTx(tx),
+    overrides: ctx.gasOverrides
+  });
+}
+
+// src/adapters/viem/resources/withdrawals/services/fee.ts
+function buildFeeBreakdown2(p) {
+  const l2Total = p.l2Gas?.maxCost ?? 0n;
+  const l2 = {
+    total: l2Total,
+    gasLimit: p.l2Gas?.gasLimit ?? 0n,
+    maxFeePerGas: p.l2Gas?.maxFeePerGas ?? 0n,
+    maxPriorityFeePerGas: p.l2Gas?.maxPriorityFeePerGas
+  };
+  return {
+    token: p.feeToken,
+    maxTotal: l2Total,
+    l2
   };
 }
 
 // src/adapters/viem/resources/withdrawals/routes/eth.ts
-var { wrapAs: wrapAs5 } = createErrorHandlers("withdrawals");
+var { wrapAs: wrapAs6 } = createErrorHandlers("withdrawals");
 function routeEthBase() {
   return {
     async build(p, ctx) {
-      const toL1 = p.to ?? ctx.sender;
-      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
-      const sim = await wrapAs5(
-        "CONTRACT",
-        OP_WITHDRAWALS.eth.estGas,
-        () => ctx.client.l2.simulateContract({
-          address: L2_BASE_TOKEN_ADDRESS,
-          abi: IBaseToken_default,
-          functionName: "withdraw",
-          args: [toL1],
-          value: p.amount,
-          account: ctx.client.account,
-          ...txFeeOverrides
-        }),
+      const steps = [];
+      const data = await wrapAs6(
+        "INTERNAL",
+        OP_WITHDRAWALS.eth.encodeWithdraw,
+        () => Promise.resolve(
+          viem.encodeFunctionData({
+            abi: IBaseToken_default,
+            functionName: "withdraw",
+            args: [p.to ?? ctx.sender]
+          })
+        ),
         {
-          ctx: { where: "l2.simulateContract", to: L2_BASE_TOKEN_ADDRESS },
-          message: "Failed to simulate L2 ETH withdraw."
+          ctx: { where: "L2BaseToken.withdraw", to: p.to ?? ctx.sender },
+          message: "Failed to encode ETH withdraw calldata."
         }
       );
-      const steps = [
-        {
-          key: "l2-base-token:withdraw",
-          kind: "l2-base-token:withdraw",
-          description: "Withdraw ETH via L2 Base Token System",
-          tx: { ...sim.request, ...txFeeOverrides }
-        }
-      ];
-      return { steps, approvals: [], quoteExtras: {} };
+      const L2tx = {
+        to: L2_BASE_TOKEN_ADDRESS,
+        data,
+        value: p.amount,
+        from: ctx.sender
+      };
+      const l2Gas = await quoteL2Gas4({ ctx, tx: L2tx });
+      if (l2Gas) {
+        L2tx.gas = l2Gas.gasLimit;
+        L2tx.maxFeePerGas = l2Gas.maxFeePerGas;
+        L2tx.maxPriorityFeePerGas = l2Gas.maxPriorityFeePerGas;
+      }
+      const tx = {
+        address: L2_BASE_TOKEN_ADDRESS,
+        abi: IBaseToken_default,
+        functionName: "withdraw",
+        args: [p.to ?? ctx.sender],
+        value: p.amount,
+        account: ctx.client.account,
+        ...l2Gas
+      };
+      const fees = buildFeeBreakdown2({
+        feeToken: L2_BASE_TOKEN_ADDRESS,
+        l2Gas
+      });
+      steps.push({
+        key: "l2-base-token:withdraw",
+        kind: "l2-base-token:withdraw",
+        description: "Withdraw ETH via L2 Base Token System",
+        tx
+      });
+      return { steps, approvals: [], fees };
     }
   };
 }
-var { wrapAs: wrapAs6 } = createErrorHandlers("withdrawals");
+var { wrapAs: wrapAs7 } = createErrorHandlers("withdrawals");
 function routeErc20NonBase2() {
   return {
     // TODO: add preflight validations here
     async build(p, ctx) {
-      const toL1 = p.to ?? ctx.sender;
-      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
-      const current = await wrapAs6(
+      const steps = [];
+      const approvals = [];
+      const current = await wrapAs7(
         "CONTRACT",
         OP_WITHDRAWALS.erc20.allowance,
         () => ctx.client.l2.readContract({
@@ -5564,12 +5897,26 @@ function routeErc20NonBase2() {
           message: "Failed to read L2 ERC-20 allowance."
         }
       );
-      const needsApprove = current < p.amount;
-      const steps = [];
-      const approvals = [];
-      if (needsApprove) {
+      if (current < p.amount) {
         approvals.push({ token: p.token, spender: ctx.l2NativeTokenVault, amount: p.amount });
-        const approveSim = await wrapAs6(
+        const data = viem.encodeFunctionData({
+          abi: IERC20_default,
+          functionName: "approve",
+          args: [ctx.l2NativeTokenVault, p.amount]
+        });
+        const approveTxCandidate = {
+          to: p.token,
+          data,
+          value: 0n,
+          from: ctx.sender
+        };
+        const approveGas = await quoteL2Gas4({ ctx, tx: approveTxCandidate });
+        if (approveGas) {
+          approveTxCandidate.gas = approveGas.gasLimit;
+          approveTxCandidate.maxFeePerGas = approveGas.maxFeePerGas;
+          approveTxCandidate.maxPriorityFeePerGas = approveGas.maxPriorityFeePerGas;
+        }
+        const approveSim = await wrapAs7(
           "CONTRACT",
           OP_WITHDRAWALS.erc20.estGas,
           () => ctx.client.l2.simulateContract({
@@ -5578,21 +5925,25 @@ function routeErc20NonBase2() {
             functionName: "approve",
             args: [ctx.l2NativeTokenVault, p.amount],
             account: ctx.client.account,
-            ...txFeeOverrides
+            ...approveGas
           }),
           {
             ctx: { where: "l2.simulateContract", to: p.token },
             message: "Failed to simulate L2 ERC-20 approve."
           }
         );
+        const { ...approveRequest } = approveSim.request;
+        const approveTx = {
+          ...approveRequest
+        };
         steps.push({
           key: `approve:l2:${p.token}:${ctx.l2NativeTokenVault}`,
           kind: "approve:l2",
           description: `Approve ${p.amount} to NativeTokenVault`,
-          tx: { ...approveSim.request, ...txFeeOverrides }
+          tx: approveTx
         });
       }
-      const ensure = await wrapAs6(
+      const ensure = await wrapAs7(
         "CONTRACT",
         OP_WITHDRAWALS.erc20.ensureRegistered,
         () => ctx.client.l2.simulateContract({
@@ -5614,20 +5965,37 @@ function routeErc20NonBase2() {
           { type: "address", name: "l1Receiver" },
           { type: "address", name: "l2Token" }
         ],
-        [p.amount, toL1, p.token]
+        [p.amount, p.to ?? ctx.sender, p.token]
       );
+      const withdrawCalldata = viem.encodeFunctionData({
+        abi: IL2AssetRouter_default,
+        functionName: "withdraw",
+        args: [assetId, assetData]
+      });
+      const withdrawTxCandidate = {
+        to: ctx.l2AssetRouter,
+        data: withdrawCalldata,
+        value: 0n,
+        from: ctx.sender
+      };
+      const withdrawGas = await quoteL2Gas4({ ctx, tx: withdrawTxCandidate });
+      if (withdrawGas) {
+        withdrawTxCandidate.gas = withdrawGas.gasLimit;
+        withdrawTxCandidate.maxFeePerGas = withdrawGas.maxFeePerGas;
+        withdrawTxCandidate.maxPriorityFeePerGas = withdrawGas.maxPriorityFeePerGas;
+      }
       let withdrawTx;
-      if (needsApprove) {
+      if (current < p.amount) {
         withdrawTx = {
           address: ctx.l2AssetRouter,
           abi: IL2AssetRouter_default,
           functionName: "withdraw",
           args: [assetId, assetData],
           account: ctx.client.account,
-          ...txFeeOverrides
+          ...withdrawGas
         };
       } else {
-        const sim = await wrapAs6(
+        const sim = await wrapAs7(
           "CONTRACT",
           OP_WITHDRAWALS.erc20.estGas,
           () => ctx.client.l2.simulateContract({
@@ -5636,14 +6004,18 @@ function routeErc20NonBase2() {
             functionName: "withdraw",
             args: [assetId, assetData],
             account: ctx.client.account,
-            ...txFeeOverrides
+            ...withdrawGas
           }),
           {
             ctx: { where: "l2.simulateContract", to: ctx.l2AssetRouter },
             message: "Failed to simulate L2 ERC-20 withdraw."
           }
         );
-        withdrawTx = { ...sim.request, ...txFeeOverrides };
+        const { ...withdrawRequest } = sim.request;
+        withdrawTx = {
+          ...withdrawRequest,
+          ...withdrawGas
+        };
       }
       steps.push({
         key: "l2-asset-router:withdraw",
@@ -5651,59 +6023,11 @@ function routeErc20NonBase2() {
         description: "Burn on L2 & send L2\u2192L1 message",
         tx: withdrawTx
       });
-      return { steps, approvals, quoteExtras: {} };
-    }
-  };
-}
-
-// src/adapters/viem/resources/withdrawals/routes/eth-nonbase.ts
-var { wrapAs: wrapAs7 } = createErrorHandlers("withdrawals");
-function routeEthNonBase2() {
-  return {
-    async preflight(p, ctx) {
-      await wrapAs7(
-        "VALIDATION",
-        OP_WITHDRAWALS.ethNonBase.assertNonEthBase,
-        () => {
-          if (p.token.toLowerCase() !== L2_BASE_TOKEN_ADDRESS.toLowerCase()) {
-            throw new Error("eth-nonbase route requires the L2 base-token alias (0x\u2026800A).");
-          }
-          if (ctx.baseIsEth) {
-            throw new Error("eth-nonbase route requires chain base \u2260 ETH.");
-          }
-        },
-        { ctx: { token: p.token, baseIsEth: ctx.baseIsEth } }
-      );
-    },
-    async build(p, ctx) {
-      const toL1 = p.to ?? ctx.sender;
-      const txFeeOverrides = buildViemFeeOverrides(ctx.fee);
-      const sim = await wrapAs7(
-        "CONTRACT",
-        OP_WITHDRAWALS.ethNonBase.estGas,
-        () => ctx.client.l2.simulateContract({
-          address: L2_BASE_TOKEN_ADDRESS,
-          abi: IBaseToken_default,
-          functionName: "withdraw",
-          args: [toL1],
-          value: p.amount,
-          account: ctx.client.account,
-          ...txFeeOverrides
-        }),
-        {
-          ctx: { where: "l2.simulateContract", to: L2_BASE_TOKEN_ADDRESS },
-          message: "Failed to simulate L2 base-token withdraw."
-        }
-      );
-      const steps = [
-        {
-          key: "l2-base-token:withdraw",
-          kind: "l2-base-token:withdraw",
-          description: "Withdraw base token via L2 Base Token System (base \u2260 ETH)",
-          tx: { ...sim.request, ...txFeeOverrides }
-        }
-      ];
-      return { steps, approvals: [], quoteExtras: {} };
+      const fees = buildFeeBreakdown2({
+        feeToken: await ctx.client.baseToken(ctx.chainIdL2),
+        l2Gas: withdrawGas
+      });
+      return { steps, approvals, fees };
     }
   };
 }
@@ -6058,10 +6382,8 @@ function createFinalizationServices(client) {
 
 // src/adapters/viem/resources/withdrawals/index.ts
 var ROUTES2 = {
-  "eth-base": routeEthBase(),
+  base: routeEthBase(),
   // BaseTokenSystem.withdraw, chain base = ETH
-  "eth-nonbase": routeEthNonBase2(),
-  // BaseTokenSystem.withdraw, chain base ≠ ETH
   "erc20-nonbase": routeErc20NonBase2()
   // AssetRouter.withdraw for non-base ERC-20s
 };
@@ -6071,27 +6393,19 @@ function createWithdrawalsResource(client) {
   async function buildPlan(p) {
     const ctx = await commonCtx2(p, client);
     await ROUTES2[ctx.route].preflight?.(p, ctx);
-    const { steps, approvals } = await ROUTES2[ctx.route].build(p, ctx);
-    const resolveGasLimit = () => {
-      if (ctx.fee.gasLimit != null) return ctx.fee.gasLimit;
-      for (let i = steps.length - 1; i >= 0; i--) {
-        const candidate = steps[i].tx.gas;
-        if (candidate != null) return candidate;
-      }
-      return void 0;
-    };
-    const gasLimit = resolveGasLimit();
-    const summary = {
+    const { steps, approvals, fees } = await ROUTES2[ctx.route].build(p, ctx);
+    return {
       route: ctx.route,
-      approvalsNeeded: approvals,
-      suggestedL2GasLimit: ctx.l2GasLimit,
-      fees: {
-        gasLimit,
-        maxFeePerGas: ctx.fee.maxFeePerGas,
-        maxPriorityFeePerGas: ctx.fee.maxPriorityFeePerGas
-      }
+      summary: {
+        route: ctx.route,
+        approvalsNeeded: approvals,
+        amounts: {
+          transfer: { token: p.token, amount: p.amount }
+        },
+        fees
+      },
+      steps
     };
-    return { route: ctx.route, summary, steps };
   }
   const finalizeCache = /* @__PURE__ */ new Map();
   const quote = (p) => wrap2(OP_WITHDRAWALS.quote, async () => (await buildPlan(p)).summary, {
@@ -6125,7 +6439,7 @@ function createWithdrawalsResource(client) {
           }
           if (overrides.gasLimit != null) step.tx.gas = overrides.gasLimit;
         }
-        if (step.tx.gas == null) {
+        if (!p.l2TxOverrides?.gasLimit) {
           try {
             const feePart = step.tx.maxFeePerGas != null && step.tx.maxPriorityFeePerGas != null ? {
               maxFeePerGas: step.tx.maxFeePerGas,