diff --git a/src/app/api/config/gas-estimate/route.test.ts b/src/app/api/config/gas-estimate/route.test.ts
index 5bcfd6f9..43676765 100644
--- a/src/app/api/config/gas-estimate/route.test.ts
+++ b/src/app/api/config/gas-estimate/route.test.ts
@@ -16,6 +16,11 @@ const DEFAULT_GAS_LIMIT = 450_000
 const DEFAULT_GAS_USED = 180_000
 const DEFAULT_SURPLUS_RATE = 0.0056
 const DEFAULT_MILES_CALC_MAX_SLIPPAGE = 50
+/** Mirrors `DEFAULT_SWEEP_OVERHEAD_FALLBACK` in route.ts and the backend's
+ *  `costEstimateLastResort` (cost_estimator.go). */
+const DEFAULT_SWEEP_OVERHEAD: Record<string, number> = { default: 0.001 }
+/** Mirrors `DEFAULT_BID_COST_ETH` in route.ts — p75 of post-Apr-8 realized. */
+const DEFAULT_BID_COST_ETH = 0.00004
 
 /**
  * Build a `mockGet` implementation that returns the values we want for each
@@ -40,15 +45,24 @@ describe("GET /api/config/gas-estimate", () => {
       gasEstimate: DEFAULT_GAS_LIMIT,
       gasUsedEstimate: DEFAULT_GAS_USED,
       surplusRate: DEFAULT_SURPLUS_RATE,
+      sweepOverheadByToken: DEFAULT_SWEEP_OVERHEAD,
+      bidCostEth: DEFAULT_BID_COST_ETH,
       milesCalcMaxSlippagePct: DEFAULT_MILES_CALC_MAX_SLIPPAGE,
     })
   })
 
   it("passes through valid operator-set values", async () => {
+    const sweepMap = {
+      "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48": 0.00004,
+      "0xdac17f958d2ee523a2206206994597c13d831ec7": 0.00005,
+      default: 0.00008,
+    }
     mockKeys({
       miles_estimate_gas_limit_average: 500_000,
       miles_estimate_gas_used_average: 200_000,
       miles_estimate_surplus_rate: 0.012,
+      miles_estimate_sweep_overhead_eth_by_token: sweepMap,
+      miles_estimate_bid_cost_eth: 0.000038,
       miles_calc_max_slippage_pct: 25,
     })
     const res = await GET()
@@ -58,10 +72,29 @@ describe("GET /api/config/gas-estimate", () => {
       gasEstimate: 500_000,
       gasUsedEstimate: 200_000,
       surplusRate: 0.012,
+      sweepOverheadByToken: sweepMap,
+      bidCostEth: 0.000038,
       milesCalcMaxSlippagePct: 25,
     })
   })
 
+  it("falls back to default sweep overhead when the map has a bad value", async () => {
+    mockKeys({
+      // negative overhead is nonsensical — the route should reject and fall back
+      miles_estimate_sweep_overhead_eth_by_token: { "0xfoo": -1 },
+    })
+    const res = await GET()
+    const json = await res.json()
+    expect(json.sweepOverheadByToken).toEqual(DEFAULT_SWEEP_OVERHEAD)
+  })
+
+  it("falls back to default sweep overhead when the map is non-object", async () => {
+    mockKeys({ miles_estimate_sweep_overhead_eth_by_token: "not a map" })
+    const res = await GET()
+    const json = await res.json()
+    expect(json.sweepOverheadByToken).toEqual(DEFAULT_SWEEP_OVERHEAD)
+  })
+
   it("clamps milesCalcMaxSlippagePct above the 50% ceiling", async () => {
     mockKeys({ miles_calc_max_slippage_pct: 75 })
     const res = await GET()
@@ -116,6 +149,8 @@ describe("GET /api/config/gas-estimate", () => {
       gasEstimate: DEFAULT_GAS_LIMIT,
       gasUsedEstimate: DEFAULT_GAS_USED,
       surplusRate: DEFAULT_SURPLUS_RATE,
+      sweepOverheadByToken: DEFAULT_SWEEP_OVERHEAD,
+      bidCostEth: DEFAULT_BID_COST_ETH,
       milesCalcMaxSlippagePct: DEFAULT_MILES_CALC_MAX_SLIPPAGE,
     })
   })
@@ -127,9 +162,11 @@ describe("GET /api/config/gas-estimate", () => {
     expect(fetchedKeys).toEqual(
       [
         "miles_calc_max_slippage_pct",
+        "miles_estimate_bid_cost_eth",
         "miles_estimate_gas_limit_average",
         "miles_estimate_gas_used_average",
         "miles_estimate_surplus_rate",
+        "miles_estimate_sweep_overhead_eth_by_token",
       ].sort()
     )
   })
diff --git a/src/app/api/config/gas-estimate/route.ts b/src/app/api/config/gas-estimate/route.ts
index 868d5567..8bfd2510 100644
--- a/src/app/api/config/gas-estimate/route.ts
+++ b/src/app/api/config/gas-estimate/route.ts
@@ -6,6 +6,22 @@ export const runtime = "edge"
 const DEFAULT_GAS_LIMIT = 450_000
 const DEFAULT_GAS_USED = 180_000
 const DEFAULT_SURPLUS_RATE = 0.0056
+/**
+ * Cold-load fallback for the sweep-overhead map. Mirrors the backend's
+ * `costEstimateLastResort` in `fastswap-miles/cost_estimator.go`. Used
+ * only when Edge Config has no `miles_estimate_sweep_overhead_eth_by_token`
+ * entry at all (e.g. the hourly cron hasn't run for the first time yet);
+ * once populated, the cron writes a `default` key alongside per-token
+ * values and clients read that instead.
+ */
+const DEFAULT_SWEEP_OVERHEAD_FALLBACK: Record<string, number> = { default: 0.001 }
+/**
+ * Cold-load fallback for the dashboard MilesCell bid-cost proxy. Same
+ * value the cron writes when no rows are sampled. Tracks p75 of realized
+ * bid_cost since 2026-04-08; tight enough post-fix that a single
+ * scalar is fine.
+ */
+const DEFAULT_BID_COST_ETH = 0.00004
 /** Default upper bound the miles calculator will plan against, in percent. */
 const DEFAULT_MILES_CALC_MAX_SLIPPAGE = 50
 /** Hard floors and ceilings for the calc cap so a bad Edge Config value can't
@@ -19,14 +35,25 @@ function clampMaxSlippage(value: number): number {
   return Math.min(MILES_CALC_MAX_SLIPPAGE_CEILING, Math.max(MILES_CALC_MAX_SLIPPAGE_FLOOR, value))
 }
 
+function isSweepOverheadMap(value: unknown): value is Record<string, number> {
+  if (value == null || typeof value !== "object") return false
+  for (const v of Object.values(value as Record<string, unknown>)) {
+    if (typeof v !== "number" || !Number.isFinite(v) || v < 0) return false
+  }
+  return true
+}
+
 export async function GET() {
   try {
-    const [gasLimit, gasUsed, surplusRate, milesCalcMaxSlippage] = await Promise.all([
-      get<number>("miles_estimate_gas_limit_average"),
-      get<number>("miles_estimate_gas_used_average"),
-      get<number>("miles_estimate_surplus_rate"),
-      get<number>("miles_calc_max_slippage_pct"),
-    ])
+    const [gasLimit, gasUsed, surplusRate, sweepOverheadByToken, bidCostEth, milesCalcMaxSlippage] =
+      await Promise.all([
+        get<number>("miles_estimate_gas_limit_average"),
+        get<number>("miles_estimate_gas_used_average"),
+        get<number>("miles_estimate_surplus_rate"),
+        get<Record<string, number>>("miles_estimate_sweep_overhead_eth_by_token"),
+        get<number>("miles_estimate_bid_cost_eth"),
+        get<number>("miles_calc_max_slippage_pct"),
+      ])
 
     return NextResponse.json(
       {
@@ -34,6 +61,11 @@ export async function GET() {
         gasUsedEstimate: typeof gasUsed === "number" && gasUsed > 0 ? gasUsed : DEFAULT_GAS_USED,
         surplusRate:
           typeof surplusRate === "number" && surplusRate > 0 ? surplusRate : DEFAULT_SURPLUS_RATE,
+        sweepOverheadByToken: isSweepOverheadMap(sweepOverheadByToken)
+          ? sweepOverheadByToken
+          : DEFAULT_SWEEP_OVERHEAD_FALLBACK,
+        bidCostEth:
+          typeof bidCostEth === "number" && bidCostEth > 0 ? bidCostEth : DEFAULT_BID_COST_ETH,
         milesCalcMaxSlippagePct:
           typeof milesCalcMaxSlippage === "number" && milesCalcMaxSlippage > 0
             ? clampMaxSlippage(milesCalcMaxSlippage)
@@ -48,6 +80,8 @@ export async function GET() {
         gasEstimate: DEFAULT_GAS_LIMIT,
         gasUsedEstimate: DEFAULT_GAS_USED,
         surplusRate: DEFAULT_SURPLUS_RATE,
+        sweepOverheadByToken: DEFAULT_SWEEP_OVERHEAD_FALLBACK,
+        bidCostEth: DEFAULT_BID_COST_ETH,
         milesCalcMaxSlippagePct: DEFAULT_MILES_CALC_MAX_SLIPPAGE,
       },
       { headers: { "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300" } }
diff --git a/src/app/api/cron/update-edge-config/miles-estimate-gas/route.ts b/src/app/api/cron/update-edge-config/miles-estimate-gas/route.ts
index a9596041..fce42dba 100644
--- a/src/app/api/cron/update-edge-config/miles-estimate-gas/route.ts
+++ b/src/app/api/cron/update-edge-config/miles-estimate-gas/route.ts
@@ -31,6 +31,31 @@ const FALLBACK_GAS_USED = 180_000
 /** Fallback p25 surplus rate (0.56% from 2026-04-14 all-swap sample). */
 const FALLBACK_SURPLUS_RATE = 0.0056
 
+/**
+ * Mirrors the backend's `costEstimateLastResort` constant in
+ * `mev-commit/tools/fastswap-miles/cost_estimator.go`. Used as the JSON
+ * map's hardcoded `"default"` fallback when the cron can't compute a
+ * network-wide percentile (e.g. zero rows in the 14d window). The
+ * frontend hook reads this exact key out of the Edge Config map.
+ */
+const LAST_RESORT_SWEEP_OVERHEAD_ETH = 0.001
+
+/**
+ * Minimum sample size before we trust per-token p25. Below this we fall
+ * back to that token's p75, exactly mirroring the backend's
+ * `costEstimateMinSweeps` constant. Keeps both estimators in lockstep
+ * even on low-volume tokens.
+ */
+const SWEEP_OVERHEAD_MIN_SAMPLES = 10
+
+/**
+ * Fallback proxy for `bid_cost` on pending rows. Mirrors the hardcoded
+ * constant in `user-swaps-parts.tsx` and the post-2026-04-08 realized
+ * distribution's p75 — used when the analytics query can't produce a
+ * value (zero rows in window).
+ */
+const FALLBACK_BID_COST_ETH = 0.00004
+
 // ---------------------------------------------------------------------------
 // Auth helper
 // ---------------------------------------------------------------------------
@@ -308,6 +333,109 @@ async function computeSurplusRateEstimate(): Promise<number> {
   return rounded
 }
 
+// ---------------------------------------------------------------------------
+// Bid cost p75
+// ---------------------------------------------------------------------------
+
+/**
+ * Computes the p75 of realized bid_cost (in ETH) across processed rows
+ * since the 2026-04-08 regime change, 30-day window. Used by the
+ * dashboard's MilesCell proxy in lieu of the historically hardcoded
+ * `ESTIMATED_BID_COST_ETH` constant. p75 to mirror the surplus-rate
+ * cron's under-promise philosophy.
+ */
+async function computeBidCostEstimate(): Promise<number> {
+  const client = getAnalyticsClient()
+
+  const rows = await client.execute("fastswap/get-bid-costs", {})
+  const values = rows
+    .map((row) => Number(row[0]))
+    .filter((v) => Number.isFinite(v) && v > 0)
+    .sort((a, b) => a - b)
+
+  if (values.length === 0) {
+    console.warn("[cron/miles-estimate-gas] No bid cost samples returned — using fallback")
+    return FALLBACK_BID_COST_ETH
+  }
+
+  const p75Index = Math.floor(values.length * 0.75)
+  const p75 = values[p75Index]
+  // Round to 8 decimal places (0.01 µETH) — same precision as sweep overhead.
+  const rounded = Math.round(p75 * 1e8) / 1e8
+
+  console.log(
+    `[cron/miles-estimate-gas] bidCost — count: ${values.length}  ` +
+      `p25: ${(values[Math.floor(values.length * 0.25)] * 1e6).toFixed(2)} µETH  ` +
+      `p50: ${(values[Math.floor(values.length * 0.5)] * 1e6).toFixed(2)} µETH  ` +
+      `p75: ${(rounded * 1e6).toFixed(2)} µETH (chosen)  ` +
+      `p95: ${(values[Math.floor(values.length * 0.95)] * 1e6).toFixed(2)} µETH`
+  )
+
+  return rounded
+}
+
+// ---------------------------------------------------------------------------
+// Sweep overhead by token
+// ---------------------------------------------------------------------------
+
+/**
+ * Per-token sweep overhead map: lowercased L1 token address → ETH overhead.
+ *
+ * Mirrors the backend's `costEstimator.Get` semantics in
+ * `mev-commit/tools/fastswap-miles/cost_estimator.go`:
+ *   - per-token p25 over the last 14 days when sample size ≥ 10
+ *   - per-token p75 when sample size < 10 (low-data fallback)
+ *   - `default` is a network-wide p25 across all tokens — used when the
+ *     frontend's selected output token isn't in the map at all
+ *   - falls back to `LAST_RESORT_SWEEP_OVERHEAD_ETH` if the network query
+ *     itself returns nothing usable
+ *
+ * Returned values are ETH (float) so the route handler can ship the map
+ * straight to Edge Config without extra encoding.
+ */
+async function computeSweepOverheadByToken(): Promise<Record<string, number>> {
+  const client = getAnalyticsClient()
+
+  const rows = await client.execute("fastswap/get-sweep-overhead-by-token", {})
+
+  // `default` mirrors the backend's `costEstimateLastResort` exactly — for
+  // tokens the backend has no historical data on, both estimators must
+  // agree on the same fallback or the frontend will over-promise miles
+  // (frontend uses a small `default`, backend deducts 0.001 ETH) and the
+  // user gets fewer miles than the badge said.
+  const map: Record<string, number> = { default: LAST_RESORT_SWEEP_OVERHEAD_ETH }
+
+  for (const row of rows) {
+    const token = String(row[0] ?? "").toLowerCase()
+    const n = Number(row[1])
+    const p25 = Number(row[2])
+    const p75 = Number(row[3])
+
+    if (!token || token === "null") continue
+    if (!Number.isFinite(n) || n <= 0) continue
+    if (!Number.isFinite(p25) || !Number.isFinite(p75)) continue
+
+    const overhead = n >= SWEEP_OVERHEAD_MIN_SAMPLES ? p25 : p75
+    if (!Number.isFinite(overhead) || overhead < 0) continue
+
+    // Round to 8 decimal places (0.01 µETH) to keep Edge Config JSON tight.
+    map[token] = Math.round(overhead * 1e8) / 1e8
+  }
+
+  console.log(
+    `[cron/miles-estimate-gas] sweepOverhead — ${Object.keys(map).length - 1} tokens, default=${(map.default * 1e6).toFixed(0)} µETH (last-resort), sample=${JSON.stringify(
+      Object.fromEntries(
+        Object.entries(map)
+          .filter(([k]) => k !== "default")
+          .slice(0, 3)
+          .map(([k, v]) => [k.slice(0, 8) + "…", `${(v * 1e6).toFixed(1)}µETH`])
+      )
+    )}`
+  )
+
+  return map
+}
+
 // ---------------------------------------------------------------------------
 // Route handler
 // ---------------------------------------------------------------------------
@@ -327,7 +455,7 @@ async function computeSurplusRateEstimate(): Promise<number> {
  * 4. Returns a JSON summary of the result.
  *
  * ### Schedule
- * Configured in `vercel.json` to run daily at 00:00 UTC.
+ * Configured in `vercel.json` to run hourly at minute 0.
  * Can also be triggered manually from the Vercel Dashboard → Cron Jobs tab.
  */
 export async function GET(request: Request) {
@@ -339,14 +467,16 @@ export async function GET(request: Request) {
 
   try {
     // --- Step 2: Fetch the new values ----------------------------------------
-    const [gasAverages, surplusRate] = await Promise.all([
+    const [gasAverages, surplusRate, sweepOverheadByToken, bidCostEth] = await Promise.all([
       computeGasAverages(),
       computeSurplusRateEstimate(),
+      computeSweepOverheadByToken(),
+      computeBidCostEstimate(),
     ])
     const { gasLimitAvg, gasUsedAvg } = gasAverages
 
     console.log(
-      `[cron/miles-estimate-gas] Computed: gasLimit=${gasLimitAvg}, gasUsed=${gasUsedAvg}, surplusRate=${(surplusRate * 100).toFixed(2)}%`
+      `[cron/miles-estimate-gas] Computed: gasLimit=${gasLimitAvg}, gasUsed=${gasUsedAvg}, surplusRate=${(surplusRate * 100).toFixed(2)}%, bidCostEth=${bidCostEth}, sweepOverheadTokens=${Object.keys(sweepOverheadByToken).length - 1} (default=${sweepOverheadByToken.default})`
     )
 
     // --- Step 3: Write to Edge Config ---------------------------------------
@@ -370,6 +500,16 @@ export async function GET(request: Request) {
         key: "miles_estimate_surplus_rate",
         value: surplusRate,
       },
+      {
+        operation: "upsert",
+        key: "miles_estimate_sweep_overhead_eth_by_token",
+        value: sweepOverheadByToken,
+      },
+      {
+        operation: "upsert",
+        key: "miles_estimate_bid_cost_eth",
+        value: bidCostEth,
+      },
     ])
 
     console.log(
@@ -384,6 +524,8 @@ export async function GET(request: Request) {
         gasLimitAverage: gasLimitAvg,
         gasUsedAverage: gasUsedAvg,
         surplusRate,
+        sweepOverheadByToken,
+        bidCostEth,
       },
       vercelResponse: result,
     })
diff --git a/src/components/dashboard/UserSwapsModal.tsx b/src/components/dashboard/UserSwapsModal.tsx
index 9ae6611d..9caa76c9 100644
--- a/src/components/dashboard/UserSwapsModal.tsx
+++ b/src/components/dashboard/UserSwapsModal.tsx
@@ -11,7 +11,7 @@ import {
 } from "@/components/ui/dialog"
 import { Skeleton } from "@/components/ui/skeleton"
 import { useUserSwaps } from "@/hooks/use-user-swaps"
-import { useSurplusRate } from "@/hooks/use-surplus-rate"
+import { useMilesEstimateConfig } from "@/hooks/use-miles-estimate-config"
 import { SwapsTableBody } from "./user-swaps-parts"
 
 type Props = {
@@ -82,7 +82,7 @@ function UserSwapsModalBody({ address }: { address: string }) {
     page,
     pageSize: MODAL_PAGE_SIZE,
   })
-  const surplusRate = useSurplusRate()
+  const { surplusRate, bidCostEth } = useMilesEstimateConfig()
 
   const { totalPages, total } = pagination
 
@@ -123,7 +123,7 @@ function UserSwapsModalBody({ address }: { address: string }) {
             No Fast Swaps yet. Make your first swap to start earning miles.
           </div>
         ) : (
-          <SwapsTableBody swaps={swaps} surplusRate={surplusRate} />
+          <SwapsTableBody swaps={swaps} surplusRate={surplusRate} bidCostEth={bidCostEth} />
         )}
       </div>
 
diff --git a/src/components/dashboard/UserSwapsTable.tsx b/src/components/dashboard/UserSwapsTable.tsx
index e543d518..9bb8c421 100644
--- a/src/components/dashboard/UserSwapsTable.tsx
+++ b/src/components/dashboard/UserSwapsTable.tsx
@@ -5,7 +5,7 @@ import { Loader2 } from "lucide-react"
 import { Card } from "@/components/ui/card"
 import { Skeleton } from "@/components/ui/skeleton"
 import { useUserSwaps } from "@/hooks/use-user-swaps"
-import { useSurplusRate } from "@/hooks/use-surplus-rate"
+import { useMilesEstimateConfig } from "@/hooks/use-miles-estimate-config"
 import { SwapsTableBody } from "./user-swaps-parts"
 import { UserSwapsModal } from "./UserSwapsModal"
 
@@ -36,7 +36,7 @@ export function UserSwapsTable({ address, isConnected }: Props) {
     page: 1,
     pageSize: RECENT_LIMIT,
   })
-  const surplusRate = useSurplusRate()
+  const { surplusRate, bidCostEth } = useMilesEstimateConfig()
 
   return (
     <>
@@ -77,7 +77,7 @@ export function UserSwapsTable({ address, isConnected }: Props) {
           </div>
         ) : (
           <>
-            <SwapsTableBody swaps={swaps} surplusRate={surplusRate} />
+            <SwapsTableBody swaps={swaps} surplusRate={surplusRate} bidCostEth={bidCostEth} />
             <div className="flex justify-center pt-4 mt-2 border-t border-white/5">
               <button
                 type="button"
diff --git a/src/components/dashboard/user-swaps-parts.tsx b/src/components/dashboard/user-swaps-parts.tsx
index b8352857..f04431d7 100644
--- a/src/components/dashboard/user-swaps-parts.tsx
+++ b/src/components/dashboard/user-swaps-parts.tsx
@@ -129,17 +129,11 @@ const MILES_PER_ETH = 100_000
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 
 /**
- * Proxy for bid_cost on pending rows. The indexer writes surplus and gas_cost
- * immediately but leaves bid_cost NULL until the sweep finalizer runs, so the
- * dashboard can't read the realized value.
- *
- * Set to p75 of realized bid_cost across processed rows since 2026-04-08 (the
- * day the bid-cost reduction landed). That picks a slightly-conservative
- * constant: it over-estimates cost vs. the median, which under-promises miles,
- * matching the same under-promise philosophy the cron uses for surplus rate.
- *
- * Post-fix distribution (n=745): p25=3.01e-5, p50=3.38e-5, p75=3.95e-5,
- * p95=5.38e-5. Tight enough that a single constant is fine.
+ * Cold-load fallback for the bid-cost proxy. The Edge-Config-driven value
+ * (`miles_estimate_bid_cost_eth`, daily cron) is preferred when present —
+ * this constant only kicks in until the first `/api/config/gas-estimate`
+ * fetch returns. p75 of post-2026-04-08 realized distribution, matching
+ * the cron's `FALLBACK_BID_COST_ETH`.
  */
 const ESTIMATED_BID_COST_ETH = 0.00004
 
@@ -177,7 +171,7 @@ type MilesEstimate = {
  * anything; the caller then shows the swap-time stash if available, else
  * "TBD".
  */
-function estimateMiles(row: UserSwapRow, surplusRate: number): MilesEstimate {
+function estimateMiles(row: UserSwapRow, surplusRate: number, bidCostEth: number): MilesEstimate {
   if (!row.amountOut) return { miles: null, source: null }
 
   // Dashboard only handles ETH-output rows in the realized path because
@@ -201,7 +195,7 @@ function estimateMiles(row: UserSwapRow, surplusRate: number): MilesEstimate {
       const isEthInput = row.tokenIn.address.toLowerCase() === ZERO_ADDRESS
       const gasCostEth = isEthInput ? 0 : gasNum / 1e18
 
-      const netMev = surplusEth - ESTIMATED_BID_COST_ETH - gasCostEth
+      const netMev = surplusEth - bidCostEth - gasCostEth
       if (netMev <= 0) return { miles: 0, source: "realized" }
       const userMev = netMev * USER_MEV_SHARE
       return { miles: Math.floor(userMev * MILES_PER_ETH), source: "realized" }
@@ -237,12 +231,14 @@ function estimateMiles(row: UserSwapRow, surplusRate: number): MilesEstimate {
 export function MilesCell({
   row,
   surplusRate = DEFAULT_SURPLUS_RATE,
+  bidCostEth = ESTIMATED_BID_COST_ETH,
 }: {
   row: UserSwapRow
   surplusRate?: number
+  bidCostEth?: number
 }) {
   if (!row.processed) {
-    const recomputed = estimateMiles(row, surplusRate)
+    const recomputed = estimateMiles(row, surplusRate, bidCostEth)
     const stashed = getEstimatedMilesForHash(row.txHash)
 
     // Prefer the on-chain recompute over the swap-time stash. The recompute
@@ -359,9 +355,11 @@ export function StatusCell({ row }: { row: UserSwapRow }) {
 export function SwapsTableBody({
   swaps,
   surplusRate,
+  bidCostEth,
 }: {
   swaps: UserSwapRow[]
   surplusRate?: number
+  bidCostEth?: number
 }) {
   return (
     <Table>
@@ -425,7 +423,7 @@ export function SwapsTableBody({
               </span>
             </TableCell>
             <TableCell className="text-right px-2 md:px-4">
-              <MilesCell row={row} surplusRate={surplusRate} />
+              <MilesCell row={row} surplusRate={surplusRate} bidCostEth={bidCostEth} />
             </TableCell>
             <TableCell className="text-right hidden md:table-cell px-4">
               <a
diff --git a/src/components/swap/SwapForm.tsx b/src/components/swap/SwapForm.tsx
index 69e8a71a..6bd1016f 100644
--- a/src/components/swap/SwapForm.tsx
+++ b/src/components/swap/SwapForm.tsx
@@ -63,6 +63,7 @@ export function SwapForm() {
     isEthOutput,
     baseFeePerGas,
     isPermitPath: !!isPermitPath && !form.isWrapUnwrap,
+    outputTokenAddress: form.toToken?.address ?? null,
     enabled:
       !form.isWrapUnwrap &&
       !!form.amount &&
diff --git a/src/hooks/__tests__/miles-math.test.ts b/src/hooks/__tests__/miles-math.test.ts
index 08b46b83..c8c1dfbd 100644
--- a/src/hooks/__tests__/miles-math.test.ts
+++ b/src/hooks/__tests__/miles-math.test.ts
@@ -41,14 +41,17 @@ const usdc = (whole: number) => BigInt(Math.round(whole * 1e6))
 interface CostInputs {
   bidCostEth: number
   gasCostEth: number
-  sweepMultiplier: number // 1 for ETH output, 2.5 for non-ETH
+  /**
+   * Additive sweep overhead in ETH for non-ETH output. Mirrors the backend's
+   * per-token p25 cost estimate (`cost_estimator.go`) — zero for ETH/WETH
+   * output, otherwise drawn from the Edge Config map.
+   */
+  sweepOverheadEth: number
 }
 
 /** Forward: given the surplus (ETH) the contract retains, compute miles. */
 function forwardMiles(surplusEth: number, c: CostInputs): number {
-  const totalBidCost = c.bidCostEth * c.sweepMultiplier
-  const totalGasCost = c.gasCostEth * c.sweepMultiplier
-  const netMev = surplusEth - totalBidCost - totalGasCost
+  const netMev = surplusEth - c.bidCostEth - c.gasCostEth - c.sweepOverheadEth
   if (netMev <= 0) return 0
   const userMev = netMev * USER_MEV_SHARE
   return Math.floor(userMev * MILES_PER_ETH)
@@ -70,12 +73,10 @@ function milesToSlippage(
   slippageMax: number = DEFAULT_SLIPPAGE_MAX
 ): number | null {
   if (target <= 0 || outputInEth <= 0) return null
-  const totalBidCost = c.bidCostEth * c.sweepMultiplier
-  const totalGasCost = c.gasCostEth * c.sweepMultiplier
   const userMevEth = target / MILES_PER_ETH
   const netMevEth = userMevEth / USER_MEV_SHARE
   const FLOOR_EPSILON = 5e-7
-  const K = netMevEth + totalBidCost + totalGasCost + FLOOR_EPSILON
+  const K = netMevEth + c.bidCostEth + c.gasCostEth + c.sweepOverheadEth + FLOOR_EPSILON
   const requiredRaw = currentSlippagePct + 100 * (K / outputInEth - lastEffectiveRate)
   const required = Math.ceil(requiredRaw / SLIPPAGE_STEP) * SLIPPAGE_STEP
   if (required > slippageMax + SLIPPAGE_TOLERANCE) return null
@@ -115,22 +116,23 @@ function maxMilesAtCap(
 // Realistic cost values for tests:
 //   priorityFee ≈ 0.06 gwei × gasLimit 450k = 27_000 gwei = 2.7e-5 ETH
 //   baseFee     ≈ 1.5 gwei × gasUsed 180k = 270_000 gwei = 2.7e-4 ETH
+//   sweepOverheadEth ≈ backend `costEstimateLastResort` = 0.001 ETH
 const DEFAULT_COSTS: CostInputs = {
   bidCostEth: 2.7e-5,
   gasCostEth: 0, // ETH path doesn't deduct gasCost
-  sweepMultiplier: 1, // ETH output (no sweep)
+  sweepOverheadEth: 0, // ETH output skips the sweep step
 }
 
 const PERMIT_COSTS: CostInputs = {
   bidCostEth: 2.7e-5,
   gasCostEth: 2.7e-4,
-  sweepMultiplier: 2.5, // non-ETH output requires sweep
+  sweepOverheadEth: 0.001, // non-ETH output: backend last-resort default
 }
 
 const ZERO_COSTS: CostInputs = {
   bidCostEth: 0,
   gasCostEth: 0,
-  sweepMultiplier: 1,
+  sweepOverheadEth: 0,
 }
 
 // ──────────────────────────────────────────────────────────────────────────
@@ -139,7 +141,7 @@ const ZERO_COSTS: CostInputs = {
 describe("forward miles — known cases", () => {
   it("gives zero miles when net MEV is negative", () => {
     const surplus = 0.000001 // tiny
-    const c: CostInputs = { bidCostEth: 0.001, gasCostEth: 0, sweepMultiplier: 1 }
+    const c: CostInputs = { bidCostEth: 0.001, gasCostEth: 0, sweepOverheadEth: 0 }
     expect(forwardMiles(surplus, c)).toBe(0)
   })
 
@@ -304,7 +306,7 @@ describe("maxAchievableMiles is consistent with the forward formula", () => {
     const expensive: CostInputs = {
       bidCostEth: 0.001,
       gasCostEth: 0,
-      sweepMultiplier: 1,
+      sweepOverheadEth: 0,
     }
     const max = maxMilesAtCap(
       outputInEth,
@@ -321,13 +323,13 @@ describe("maxAchievableMiles is consistent with the forward formula", () => {
 
   it("returns 0 for a small permit-path swap (~$2 trade replicating real screenshot)", () => {
     // Replicates the case where a tiny ERC20→USDC swap can't earn miles
-    // even at 50% slippage because the 2.5× sweep multiplier on bid+gas
-    // costs exceeds 0.5×outputInEth. Surfaces the "Swap too small to earn
-    // miles at current gas" message in the calc.
+    // even at 50% slippage because the additive sweep overhead exceeds
+    // 0.5×outputInEth. Surfaces the "Swap too small to earn miles at
+    // current gas" message in the calc.
     //
     // ~$2 trade @ $3000 ETH → outputInEth ≈ 0.000667 ETH.
-    // Permit path costs: bidCost=2.7e-5, gasCost=2.7e-4, sweep 2.5x
-    // → totals 0.74e-3 ETH, dwarfing the 0.5×0.000667 = 3.3e-4 ETH ceiling.
+    // Permit-path costs: bid 2.7e-5 + gas 2.7e-4 + sweep overhead 1e-3
+    // ≈ 1.3e-3 ETH, dwarfing the 0.5×0.000667 = 3.3e-4 ETH ceiling.
     const usdcOut = 1.95 // $1.95
     const outputInEth = (usdcOut * 1) / 3000
     const max = maxMilesAtCap(
diff --git a/src/hooks/use-estimated-miles.ts b/src/hooks/use-estimated-miles.ts
index b25cb1a9..33140fcc 100644
--- a/src/hooks/use-estimated-miles.ts
+++ b/src/hooks/use-estimated-miles.ts
@@ -102,13 +102,49 @@ export function computeSurplusEth(args: {
 }
 /**
  * Fallback surplus rate — used until Edge Config value is fetched.
- * Updated daily by the miles-estimate-gas cron job: p25 of
+ * Updated hourly by the miles-estimate-gas cron job: p25 of
  * `surplus / user_amt_out` across all processed swaps (both eth_weth and
  * erc20→erc20) over the last 30 days. p25 rather than p50 because the
  * realized distribution is bimodal — see the cron for rationale.
  */
 const DEFAULT_SURPLUS_RATE = 0.0056
 
+/**
+ * Cold-load + unknown-token fallback for the per-token sweep overhead.
+ * Mirrors the backend's `costEstimateLastResort` constant in
+ * `mev-commit/tools/fastswap-miles/cost_estimator.go` so frontend and
+ * backend produce identical estimates on tokens with no historical sweep
+ * data. Conservative — ~$3.50 in ETH at recent prices — which intentionally
+ * under-promises miles for tiny swaps on novel tokens.
+ */
+const DEFAULT_SWEEP_OVERHEAD_ETH = 0.001
+
+/**
+ * Per-token sweep overhead map, keyed by lowercased L1 token address.
+ * The `default` entry is used for any output token not present in the map.
+ * Populated from Edge Config (`miles_estimate_sweep_overhead_eth_by_token`)
+ * by the daily cron. Same SQL the backend's `costEstimator.Refresh` runs.
+ */
+export type SweepOverheadByToken = Record<string, number>
+
+/**
+ * Look up the per-token sweep overhead estimate, in ETH, for a given output
+ * token address. Case insensitive (backend stores lowercased keys).
+ * Falls back to the map's `default` entry, then to `DEFAULT_SWEEP_OVERHEAD_ETH`.
+ */
+function sweepOverheadForToken(
+  byToken: SweepOverheadByToken | null,
+  tokenAddress: string | null
+): number {
+  if (byToken != null && tokenAddress != null) {
+    const direct = byToken[tokenAddress.toLowerCase()]
+    if (typeof direct === "number" && direct >= 0) return direct
+    const fallback = byToken.default
+    if (typeof fallback === "number" && fallback >= 0) return fallback
+  }
+  return DEFAULT_SWEEP_OVERHEAD_ETH
+}
+
 interface UseEstimatedMilesParams {
   amountOut: string
   slippage: string
@@ -132,7 +168,23 @@ interface UseEstimatedMilesParams {
   ethPrice: number | null
   isEthOutput: boolean
   baseFeePerGas: bigint | null
+  /**
+   * True when user gas should be deducted from the miles formula —
+   * equivalent to "not the ETH-input direct path." Maps to the backend's
+   * `userPaysGas := input_token == 0x0` check inversely: when
+   * `isPermitPath = true`, the relayer paid L1 gas and miles math
+   * subtracts it; when `false`, the user paid out of their own wallet and
+   * miles math does not deduct it (matches `awardUpfrontERC20Miles` and
+   * `processMiles` in `fastswap-miles/miles.go`).
+   */
   isPermitPath: boolean
+  /**
+   * Lowercased L1 address of the output token. Used to look up the
+   * per-token sweep overhead estimate from Edge Config. Pass `null` for
+   * unknown / not-yet-selected outputs; the lookup falls through to the
+   * map's `default` entry and ultimately to `DEFAULT_SWEEP_OVERHEAD_ETH`.
+   */
+  outputTokenAddress: string | null
   enabled: boolean
   /** True while Barter validation is in flight for the current swap inputs.
    *  Used to freeze `estimatedMiles` and `maxAchievableMiles` at their last
@@ -191,6 +243,7 @@ export function useEstimatedMiles({
   isEthOutput,
   baseFeePerGas,
   isPermitPath,
+  outputTokenAddress,
   enabled,
   isBarterValidating,
   swapIdentityKey,
@@ -199,11 +252,14 @@ export function useEstimatedMiles({
   const [avgGasLimit, setAvgGasLimit] = useState<bigint>(DEFAULT_AVG_GAS_LIMIT)
   const [avgGasUsed, setAvgGasUsed] = useState<bigint>(DEFAULT_AVG_GAS_USED)
   const [surplusRate, setSurplusRate] = useState(DEFAULT_SURPLUS_RATE)
+  const [sweepOverheadByToken, setSweepOverheadByToken] = useState<SweepOverheadByToken | null>(
+    null
+  )
   const [milesCalcMaxSlippagePct, setMilesCalcMaxSlippagePct] = useState(
     DEFAULT_MILES_CALC_MAX_SLIPPAGE_PCT
   )
 
-  // Fetch gas estimates and surplus rate from Edge Config (updated daily by cron).
+  // Fetch gas estimates and surplus rate from Edge Config (updated hourly by cron).
   // Runs on mount — not gated on `enabled` so data is ready before the first quote arrives.
   useEffect(() => {
     let cancelled = false
@@ -223,6 +279,9 @@ export function useEstimatedMiles({
           if (typeof data.surplusRate === "number" && data.surplusRate > 0) {
             setSurplusRate(data.surplusRate)
           }
+          if (data.sweepOverheadByToken != null && typeof data.sweepOverheadByToken === "object") {
+            setSweepOverheadByToken(data.sweepOverheadByToken as SweepOverheadByToken)
+          }
           if (
             typeof data.milesCalcMaxSlippagePct === "number" &&
             data.milesCalcMaxSlippagePct > 0
@@ -285,12 +344,14 @@ export function useEstimatedMiles({
   const avgGasLimitRef = useRef<bigint>(DEFAULT_AVG_GAS_LIMIT)
   const avgGasUsedRef = useRef<bigint>(DEFAULT_AVG_GAS_USED)
   const surplusRateRef = useRef(DEFAULT_SURPLUS_RATE)
+  const sweepOverheadByTokenRef = useRef<SweepOverheadByToken | null>(null)
   const milesCalcMaxSlippagePctRef = useRef(DEFAULT_MILES_CALC_MAX_SLIPPAGE_PCT)
   priorityFeeRef.current = priorityFee
   baseFeeRef.current = baseFeePerGas
   avgGasLimitRef.current = avgGasLimit
   avgGasUsedRef.current = avgGasUsed
   surplusRateRef.current = surplusRate
+  sweepOverheadByTokenRef.current = sweepOverheadByToken
   milesCalcMaxSlippagePctRef.current = milesCalcMaxSlippagePct
 
   // Track last successful miles so transient states don't flash null.
@@ -394,24 +455,23 @@ export function useEstimatedMiles({
       formulaSource = "edge-config-fallback"
     }
 
-    // Bid cost: priority fee × avg gas limit (bid = priorityFee × txn.Gas())
+    // Bid cost: priority fee × avg gas limit (bid = priorityFee × txn.Gas()).
+    // This is the user's single tx bid — additive, not scaled.
     const bidCostEth = Number(curPriorityFee * curAvgGasLimit) / 1e18
 
-    // Gas cost: only deducted on permit path (relayer pays actual gas used, not limit)
+    // User L1 gas: only deducted when the relayer paid (permit / ERC20 input).
+    // ETH-input swaps go through `executeWithETH` and the user pays out of
+    // their own wallet, so the miles formula does not subtract it. Mirrors
+    // `userPaysGas` in `fastswap-miles/miles.go` exactly.
     const gasCostEth = isPermitPath ? Number(curBaseFee * curAvgGasUsed) / 1e18 : 0
 
-    // Sweep overhead: non-ETH output requires a sweep tx (batched fastswap).
-    // 2.5x is a conservative proxy — batches are effectively size-1 at current
-    // volume, so each user eats the whole sweep gas share. Daily p50 of
-    // realized (bid + overhead) / bid varies widely (0.9–2.9 over the last
-    // 10 days), so any fixed multiplier is a bandaid. 2.5 covers the median
-    // of "bad" days (p50 ≈ 1.9) while staying tolerable on cheap days.
-    // TODO: replace with an Edge Config-driven sweep overhead term computed
-    // from `surplus_eth - net_profit_eth - bid_cost` on recent finalized rows
-    // — same pattern as `miles_estimate_surplus_rate`.
-    const sweepMultiplier = isEthOutput ? 1 : 2.5
-    const totalBidCost = bidCostEth * sweepMultiplier
-    const totalGasCost = gasCostEth * sweepMultiplier
+    // Sweep overhead: per-token p25 of realized sweep gas, in ETH, from
+    // Edge Config. The backend's `costEstimator` writes the same value and
+    // subtracts it inside `awardUpfrontERC20Miles`. ETH/WETH output bypasses
+    // sweeping entirely (the `eth_weth` path), so the term is zero there.
+    const sweepOverheadEth = isEthOutput
+      ? 0
+      : sweepOverheadForToken(sweepOverheadByTokenRef.current, outputTokenAddress)
 
     // Snapshot the effective surplus rate so the inverse calculator can use
     // the SAME rate the forward just produced (especially when barter's
@@ -420,7 +480,7 @@ export function useEstimatedMiles({
       lastEffectiveSurplusRateRef.current = slippageAmountEth / outputInEth
     }
 
-    const netMevEth = slippageAmountEth - totalBidCost - totalGasCost
+    const netMevEth = slippageAmountEth - bidCostEth - gasCostEth - sweepOverheadEth
 
     const userMevEth = netMevEth > 0 ? netMevEth * USER_MEV_SHARE : 0
     const miles = netMevEth > 0 ? Math.floor(userMevEth * MILES_PER_ETH) : 0
@@ -447,13 +507,12 @@ export function useEstimatedMiles({
         `  Step 4: Gas cost${isPermitPath ? " (relayer pays actual gasUsed on permit path)" : " (user pays on ETH path = 0)"}\n` +
         `    gasCostEth = ${isPermitPath ? `${curBaseFee.toString()} wei × ${curAvgGasUsed.toString()} gasUsed / 1e18 = ` : ""}${gasCostEth.toFixed(8)} ETH\n` +
         (!isEthOutput
-          ? `\n  Step 4b: Sweep overhead (non-ETH output, ${sweepMultiplier}x multiplier)\n` +
-            `    totalBidCost = ${bidCostEth.toFixed(8)} × ${sweepMultiplier} = ${totalBidCost.toFixed(8)} ETH\n` +
-            `    totalGasCost = ${gasCostEth.toFixed(8)} × ${sweepMultiplier} = ${totalGasCost.toFixed(8)} ETH\n`
+          ? `\n  Step 4b: Sweep overhead (non-ETH output, per-token p25 from Edge Config)\n` +
+            `    sweepOverheadEth = ${sweepOverheadEth.toFixed(8)} ETH (token=${outputTokenAddress ?? "unknown"})\n`
           : "") +
         `\n` +
         `  Step 5: Net MEV\n` +
-        `    netMevEth = ${slippageAmountEth.toFixed(8)} - ${totalBidCost.toFixed(8)} - ${totalGasCost.toFixed(8)} = ${netMevEth.toFixed(8)} ETH\n` +
+        `    netMevEth = ${slippageAmountEth.toFixed(8)} - ${bidCostEth.toFixed(8)} - ${gasCostEth.toFixed(8)} - ${sweepOverheadEth.toFixed(8)} = ${netMevEth.toFixed(8)} ETH\n` +
         `\n` +
         `  Step 6: User share & miles\n` +
         `    userMevEth = ${netMevEth.toFixed(8)} × ${USER_MEV_SHARE} (${USER_MEV_SHARE * 100}% share) = ${userMevEth.toFixed(8)} ETH\n` +
@@ -479,6 +538,7 @@ export function useEstimatedMiles({
     ethPrice,
     isEthOutput,
     isPermitPath,
+    outputTokenAddress,
   ])
 
   // Update ref outside useMemo to avoid React error #300 (state mutation during render)
@@ -529,13 +589,13 @@ export function useEstimatedMiles({
 
       const bidCostEth = Number(curPriorityFee * curAvgGasLimit) / 1e18
       const gasCostEth = isPermitPath ? Number(curBaseFee * curAvgGasUsed) / 1e18 : 0
-      const sweepMultiplier = isEthOutput ? 1 : 2.5
-      const totalBidCost = bidCostEth * sweepMultiplier
-      const totalGasCost = gasCostEth * sweepMultiplier
+      const sweepOverheadEth = isEthOutput
+        ? 0
+        : sweepOverheadForToken(sweepOverheadByTokenRef.current, outputTokenAddress)
 
       const userMevEth = targetMiles / MILES_PER_ETH
       const netMevEth = userMevEth / USER_MEV_SHARE
-      const slippageAmountEth = netMevEth + totalBidCost + totalGasCost
+      const slippageAmountEth = netMevEth + bidCostEth + gasCostEth + sweepOverheadEth
       const outputInEth = slippageAmountEth / effectiveSurplusRate
       if (!Number.isFinite(outputInEth) || outputInEth <= 0) return null
 
@@ -544,7 +604,15 @@ export function useEstimatedMiles({
         : (outputInEth * (ethPrice as number)) / (toTokenPrice as number)
       return Number.isFinite(result) && result > 0 ? result : null
     },
-    [isEthOutput, isPermitPath, toTokenPrice, ethPrice, slippage, barterPreGasOutputAmount]
+    [
+      isEthOutput,
+      isPermitPath,
+      toTokenPrice,
+      ethPrice,
+      slippage,
+      barterPreGasOutputAmount,
+      outputTokenAddress,
+    ]
   )
 
   // Slippage-only planner. Holds the user's swap size constant (their typed
@@ -579,9 +647,9 @@ export function useEstimatedMiles({
 
       const bidCostEth = Number(curPriorityFee * curAvgGasLimit) / 1e18
       const gasCostEth = isPermitPath ? Number(curBaseFee * curAvgGasUsed) / 1e18 : 0
-      const sweepMultiplier = isEthOutput ? 1 : 2.5
-      const totalBidCost = bidCostEth * sweepMultiplier
-      const totalGasCost = gasCostEth * sweepMultiplier
+      const sweepOverheadEth = isEthOutput
+        ? 0
+        : sweepOverheadForToken(sweepOverheadByTokenRef.current, outputTokenAddress)
 
       const userMevEth = targetMiles / MILES_PER_ETH
       const netMevEth = userMevEth / USER_MEV_SHARE
@@ -589,7 +657,7 @@ export function useEstimatedMiles({
       // doesn't kick the miles count down by 1 due to float precision when
       // the exact slippage produces userMev × 100_000 = target − ε.
       const FLOOR_EPSILON = 5e-7
-      const K = netMevEth + totalBidCost + totalGasCost + FLOOR_EPSILON
+      const K = netMevEth + bidCostEth + gasCostEth + sweepOverheadEth + FLOOR_EPSILON
 
       // The forward calc (when barter is available) computes:
       //   surplus = barterPreGas − uniswap × (1 − s/100)
@@ -617,7 +685,7 @@ export function useEstimatedMiles({
       }
 
       // Edge-Config-driven cap on what slippage the calc will plan against.
-      // Read from a ref so daily refreshes don't invalidate this useCallback.
+      // Read from a ref so hourly refreshes don't invalidate this useCallback.
       const SLIPPAGE_MAX = milesCalcMaxSlippagePctRef.current
       // Mirror useSwapSlippage's autoBase floors.
       const autoBase = isPermitPath ? 1 : 0.5
@@ -653,7 +721,7 @@ export function useEstimatedMiles({
         requiresChange,
       }
     },
-    [amountOut, slippage, isEthOutput, isPermitPath, toTokenPrice, ethPrice]
+    [amountOut, slippage, isEthOutput, isPermitPath, toTokenPrice, ethPrice, outputTokenAddress]
   )
 
   // Upper bound: forward-compute miles at the user's CURRENT swap size
@@ -681,9 +749,9 @@ export function useEstimatedMiles({
 
     const bidCostEth = Number(priorityFee * avgGasLimit) / 1e18
     const gasCostEth = isPermitPath ? Number(baseFeePerGas * avgGasUsed) / 1e18 : 0
-    const sweepMultiplier = isEthOutput ? 1 : 2.5
-    const totalBidCost = bidCostEth * sweepMultiplier
-    const totalGasCost = gasCostEth * sweepMultiplier
+    const sweepOverheadEth = isEthOutput
+      ? 0
+      : sweepOverheadForToken(sweepOverheadByToken, outputTokenAddress)
 
     // Edge-Config-driven cap (default 50%). Mirrors what the inverse planner
     // uses so the max miles displayed in the badge are exactly what Apply at
@@ -713,7 +781,7 @@ export function useEstimatedMiles({
     if (surplusEth == null) {
       surplusEth = (SLIPPAGE_MAX / 100) * outputInEth
     }
-    const netMev = surplusEth - totalBidCost - totalGasCost
+    const netMev = surplusEth - bidCostEth - gasCostEth - sweepOverheadEth
     if (netMev <= 0) return 0
     const userMev = netMev * USER_MEV_SHARE
     return Math.floor(userMev * MILES_PER_ETH)
@@ -731,6 +799,8 @@ export function useEstimatedMiles({
     toTokenDecimals,
     isBarterValidating,
     milesCalcMaxSlippagePct,
+    sweepOverheadByToken,
+    outputTokenAddress,
   ])
 
   // Hold the previous max while validation is in flight so the displayed
diff --git a/src/hooks/use-miles-estimate-config.ts b/src/hooks/use-miles-estimate-config.ts
new file mode 100644
index 00000000..b6ccca05
--- /dev/null
+++ b/src/hooks/use-miles-estimate-config.ts
@@ -0,0 +1,71 @@
+"use client"
+
+import { useEffect, useState } from "react"
+
+const DEFAULT_SURPLUS_RATE = 0.0056
+/**
+ * Mirrors `DEFAULT_BID_COST_ETH` in `/api/config/gas-estimate` and the
+ * historically-hardcoded constant in `user-swaps-parts.tsx`. Used as the
+ * cold-load fallback until the Edge Config fetch returns.
+ */
+const DEFAULT_BID_COST_ETH = 0.00004
+
+export type MilesEstimateConfig = {
+  /** p25 of `surplus / user_amt_out` over 30 days, from Edge Config. */
+  surplusRate: number
+  /**
+   * p75 of realized `bid_cost / 1e18` since 2026-04-08, from Edge Config.
+   * Proxies the NULL `bid_cost` on pending dashboard rows in `MilesCell`.
+   */
+  bidCostEth: number
+}
+
+/**
+ * Fetches the miles-estimator config bundle (surplus rate + bid cost) from
+ * `/api/config/gas-estimate`. Both values are written by the hourly cron and
+ * persisted in Edge Config. Returns the default fallbacks until the fetch
+ * completes.
+ *
+ * The dashboard uses both values: `surplusRate` drives the population-prior
+ * fallback formula in `MilesCell`, and `bidCostEth` proxies the NULL
+ * `bid_cost` on pending rows for the realized-data path. Bundling them
+ * into one hook avoids two network calls per dashboard mount.
+ */
+export function useMilesEstimateConfig(): MilesEstimateConfig {
+  const [config, setConfig] = useState<MilesEstimateConfig>({
+    surplusRate: DEFAULT_SURPLUS_RATE,
+    bidCostEth: DEFAULT_BID_COST_ETH,
+  })
+
+  useEffect(() => {
+    let cancelled = false
+
+    const fetchConfig = async () => {
+      try {
+        const res = await fetch("/api/config/gas-estimate")
+        if (!res.ok) return
+        const data = await res.json()
+        if (cancelled) return
+        setConfig((prev) => ({
+          surplusRate:
+            typeof data.surplusRate === "number" && data.surplusRate > 0
+              ? data.surplusRate
+              : prev.surplusRate,
+          bidCostEth:
+            typeof data.bidCostEth === "number" && data.bidCostEth > 0
+              ? data.bidCostEth
+              : prev.bidCostEth,
+        }))
+      } catch {
+        // Defaults already set; nothing to do.
+      }
+    }
+
+    fetchConfig()
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
+  return config
+}
diff --git a/src/hooks/use-surplus-rate.ts b/src/hooks/use-surplus-rate.ts
deleted file mode 100644
index c2876797..00000000
--- a/src/hooks/use-surplus-rate.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-"use client"
-
-import { useState, useEffect } from "react"
-
-const DEFAULT_SURPLUS_RATE = 0.0056
-
-/**
- * Fetches the surplus rate from Edge Config (p25 across all processed swaps,
- * updated daily by cron). Returns the default fallback until the fetch completes.
- */
-export function useSurplusRate(): number {
-  const [rate, setRate] = useState(DEFAULT_SURPLUS_RATE)
-
-  useEffect(() => {
-    let cancelled = false
-
-    const fetchRate = async () => {
-      try {
-        const res = await fetch("/api/config/gas-estimate")
-        if (!res.ok) return
-        const data = await res.json()
-        if (!cancelled && typeof data.surplusRate === "number" && data.surplusRate > 0) {
-          setRate(data.surplusRate)
-        }
-      } catch {
-        // Fallback is already set
-      }
-    }
-
-    fetchRate()
-    return () => {
-      cancelled = true
-    }
-  }, [])
-
-  return rate
-}
diff --git a/src/lib/analytics/queries.ts b/src/lib/analytics/queries.ts
index fb7201e8..b33dbeeb 100644
--- a/src/lib/analytics/queries.ts
+++ b/src/lib/analytics/queries.ts
@@ -555,6 +555,71 @@ ORDER BY block_timestamp DESC
 LIMIT :limit
 `.trim()
 
+// Realized bid cost samples for the dashboard MilesCell proxy.
+//
+// The indexer writes `surplus` and `gas_cost` immediately but leaves
+// `bid_cost` NULL until the sweep finalizer runs, so the dashboard has to
+// estimate it on pending rows. Returns realized `bid_cost / 1e18` values
+// since 2026-04-08 (the day the bid-cost regime change landed — earlier
+// data has 2× higher values and would bias the percentile up).
+//
+// 7-day window for reactivity: the backend reads real bid costs from chain
+// events with zero lag, so a tight window minimizes the frontend lag during
+// gas regime shifts. ~30+ swaps/day yields 200+ samples — plenty for p75.
+//
+// The caller picks p75 — same under-promise philosophy as
+// `GET_FASTSWAP_SURPLUS_RATES`. Tight distribution post-fix means a single
+// scalar estimate is a reasonable proxy.
+export const GET_FASTSWAP_BID_COSTS = `
+SELECT CAST(bid_cost AS DOUBLE) / 1e18 AS bid_cost_eth
+FROM mevcommit_57173.fastswap_miles
+WHERE processed = 1
+  AND bid_cost IS NOT NULL
+  AND CAST(bid_cost AS DOUBLE) > 0
+  AND block_timestamp >= '2026-04-08'
+  AND block_timestamp >= NOW() - INTERVAL 7 DAY
+`.trim()
+
+// Per-token sweep overhead samples for the upfront miles estimator.
+//
+// Mirrors the backend's `costEstimator.Refresh` query in
+// `mev-commit/tools/fastswap-miles/cost_estimator.go` line-for-line — same
+// WHERE clauses, same 14-day lookback, same percentile selection. Keeping
+// the SQL identical is what locks the frontend estimate in step with what
+// `awardUpfrontERC20Miles` will subtract on the backend; any backend filter
+// change must be mirrored here.
+//
+// Per-row overhead = `surplus_eth − net_profit_eth − bid_cost/1e18`.
+// Restricted to ETH-input rows because ERC20-input rows have user_gas baked
+// into (surplus_eth − net_profit_eth), and the miles formula deducts
+// user_gas separately — including ERC20-input samples here would inflate
+// the estimate and double-deduct downstream.
+//
+// Returns `(output_token, n, p25, p75)` so the cron caller can pick the
+// percentile (p25 when `n ≥ 10`, p75 otherwise) per token.
+export const GET_FASTSWAP_SWEEP_OVERHEAD_BY_TOKEN = `
+SELECT
+  output_token,
+  COUNT(*) AS n,
+  percentile_approx(per_row_oh, 0.25) AS p25,
+  percentile_approx(per_row_oh, 0.75) AS p75
+FROM (
+  SELECT
+    output_token,
+    surplus_eth - net_profit_eth - CAST(bid_cost AS DOUBLE) / 1e18 AS per_row_oh
+  FROM mevcommit_57173.fastswap_miles
+  WHERE processed = 1
+    AND swap_type = 'erc20'
+    AND miles > 0
+    AND surplus_eth > 0
+    AND surplus_eth IS NOT NULL
+    AND surplus_eth < 1.0
+    AND input_token = '0x0000000000000000000000000000000000000000'
+    AND block_timestamp >= NOW() - INTERVAL 14 DAY
+) t
+GROUP BY output_token
+`.trim()
+
 // Surplus rate samples for miles estimation.
 // Computes `surplus / user_amt_out` — both columns are in the SAME output-token
 // units (smallest denomination), so decimals cancel and the ratio is dimensionless.
@@ -649,6 +714,8 @@ export const QUERIES = {
   "l1/get-recent-swap-tx-hashes": GET_RECENT_L1_SWAP_TX_HASHES,
   "fastswap/get-recent-tx-hashes": GET_RECENT_FASTSWAP_TX_HASHES,
   "fastswap/get-surplus-rates": GET_FASTSWAP_SURPLUS_RATES,
+  "fastswap/get-sweep-overhead-by-token": GET_FASTSWAP_SWEEP_OVERHEAD_BY_TOKEN,
+  "fastswap/get-bid-costs": GET_FASTSWAP_BID_COSTS,
 
   // FastSwap miles domain
   "fastswap/get-user-recent-swaps": GET_USER_RECENT_SWAPS,
diff --git a/vercel.json b/vercel.json
index db64f970..d1888b23 100644
--- a/vercel.json
+++ b/vercel.json
@@ -7,7 +7,7 @@
   "crons": [
     {
       "path": "/api/cron/update-edge-config/miles-estimate-gas",
-      "schedule": "0 0 * * *"
+      "schedule": "0 * * * *"
     }
   ]
 }