diff --git a/src/assets/tokens/PINTO_wstETH.png b/src/assets/tokens/PINTO_wstETH.png
new file mode 100644
index 000000000..2e4402765
Binary files /dev/null and b/src/assets/tokens/PINTO_wstETH.png differ
diff --git a/src/assets/tokens/wstETH.png b/src/assets/tokens/wstETH.png
new file mode 100644
index 000000000..f7772f6dc
Binary files /dev/null and b/src/assets/tokens/wstETH.png differ
diff --git a/src/components/DevPage.tsx b/src/components/DevPage.tsx
index 0e5b637e9..a722981e0 100644
--- a/src/components/DevPage.tsx
+++ b/src/components/DevPage.tsx
@@ -1180,8 +1180,8 @@ const ViewFunctionCaller = () => {
                 className="h-10 px-3 py-2 text-sm border rounded-md bg-white"
               >
                 <option value="">-- Select a function --</option>
-                {viewFunctions.map((fn) => (
-                  <option key={fn.name} value={fn.name}>
+                {viewFunctions.map((fn, i) => (
+                  <option key={`${fn.name}-view-funciton-caller-${i.toString()}`} value={fn.name}>
                     {fn.name}
                     {fn.inputs && fn.inputs.length > 0 && ` (${fn.inputs.length} params)`}
                   </option>
@@ -1204,7 +1204,10 @@ const ViewFunctionCaller = () => {
                 <div className="text-sm font-medium">Function Parameters:</div>
                 <div className="flex flex-col gap-3 p-4 border rounded-lg bg-gray-50">
                   {selectedFunctionObj.inputs.map((input, idx) => (
-                    <div key={idx} className="flex items-center gap-2">
+                    <div
+                      key={`${idx.toString()}-view-function-caller-input-${input.name ?? ""}`}
+                      className="flex items-center gap-2"
+                    >
                       <Label className="text-xs text-gray-600 whitespace-nowrap min-w-[120px]">
                         {input.name || `param${idx}`} ({input.type}):
                       </Label>
diff --git a/src/components/charts/AdvancedChart.tsx b/src/components/charts/AdvancedChart.tsx
index 4bce088df..8cd184b9d 100644
--- a/src/components/charts/AdvancedChart.tsx
+++ b/src/components/charts/AdvancedChart.tsx
@@ -153,10 +153,10 @@ export const AdvancedChart = () => {
   const filtered = useMemo(() => {
     const output: TVChartFormattedData[][] = [];
     if (selectedCharts.length === 0) return output;
-    selectedCharts.forEach((selection, selectedIndex) => {
+    selectedCharts.forEach((selection) => {
       const selectedChart = chartSetupData[selection];
       const _output: TVChartFormattedData[] = [];
-      seasonsData.data.forEach((seasonData, index) => {
+      seasonsData.data.forEach((seasonData) => {
         // Verify a datapoint is available for this season (some data, like tractor, is not since season 1)
         if (selectedChart.priceScaleKey in seasonData) {
           const formatValue = selectedChart.valueFormatter;
diff --git a/src/components/charts/LineChart.tsx b/src/components/charts/LineChart.tsx
index 75430e6a8..3dc32f676 100644
--- a/src/components/charts/LineChart.tsx
+++ b/src/components/charts/LineChart.tsx
@@ -18,7 +18,7 @@ import { LineChartHorizontalReferenceLine, plugins } from "./chartHelpers";
 Chart.register(LineController, LineElement, LinearScale, LogarithmicScale, CategoryScale, PointElement, Filler);
 
 export type LineChartData = {
-  values: number[];
+  values: Array<number | null>;
 } & Record<string, any>;
 
 export type MakeGradientFunction = (
@@ -96,8 +96,14 @@ const LineChart = React.memo(
 
     const [yTickMin, yTickMax] = useMemo(() => {
       // Otherwise calculate based on data
-      const maxData = data.reduce((acc, next) => Math.max(acc, ...next.values), Number.MIN_SAFE_INTEGER);
-      const minData = data.reduce((acc, next) => Math.min(acc, ...next.values), Number.MAX_SAFE_INTEGER);
+      const maxData = data.reduce(
+        (acc, next) => Math.max(acc, ...next.values.filter((v): v is number => v !== null)),
+        Number.MIN_SAFE_INTEGER,
+      );
+      const minData = data.reduce(
+        (acc, next) => Math.min(acc, ...next.values.filter((v): v is number => v !== null)),
+        Number.MAX_SAFE_INTEGER,
+      );
 
       const maxTick = maxData === minData && maxData === 0 ? 1 : maxData;
       let minTick = minData - (maxData - minData) * 0.1;
diff --git a/src/components/charts/MarketPerformanceChart.tsx b/src/components/charts/MarketPerformanceChart.tsx
index 75c2c8abe..c3ba8ada8 100644
--- a/src/components/charts/MarketPerformanceChart.tsx
+++ b/src/components/charts/MarketPerformanceChart.tsx
@@ -165,20 +165,32 @@ const MarketPerformanceChart = ({ season, size, className }: MarketPerformanceCh
       const chartData: LineChartData[] = [];
       const tokens: (Token | undefined)[] = [];
       const chartStrokeGradients: StrokeGradientFunction[] = [];
-      for (const token of ["NET", "WETH", "cbETH", "cbBTC", "WSOL"]) {
+      const allTokens = ["NET", "WETH", "cbETH", "wstETH", "cbBTC", "WSOL"];
+      const tokensPresent: string[] = [];
+      for (const token of allTokens) {
+        if (allData[token]?.length > 0) {
+          tokensPresent.push(token);
+        }
+      }
+      for (const token of tokensPresent) {
+        const missingDatapoints = allData.NET.length - allData[token].length;
         for (let i = 0; i < allData[token].length; i++) {
-          chartData[i] ??= {
+          chartData[i + missingDatapoints] ??= {
             timestamp: allData[token][i].timestamp,
             values: [],
           };
           if (dataType !== DataType.PRICE) {
-            chartData[i].values.push(allData[token][i].value);
+            chartData[i + missingDatapoints].values.push(allData[token][i].value);
           } else {
-            chartData[i].values.push(
+            chartData[i + missingDatapoints].values.push(
               transformValue(allData[token][i].value, minValues[token], maxValues[token], priceTransformRanges[token]),
             );
           }
         }
+        for (let i = 0; i < missingDatapoints; i++) {
+          // Datapoint was missing for this token but present for other tokens
+          chartData[i].values.push(null);
+        }
         const tokenObj = tokenConfig.find((t) => t.symbol === token);
         tokens.push(tokenObj);
         chartStrokeGradients.push(gradientFunctions.solid(tokenObj?.color ?? "green"));
@@ -298,6 +310,8 @@ const MarketPerformanceChart = ({ season, size, className }: MarketPerformanceCh
                 {chartDataset.tokens.map((token, idx) => {
                   const tokenSymbol = token?.symbol ?? "NET";
                   const isNetToken = tokenSymbol === "NET";
+                  const missingDatapoints = allData.NET.length - allData[tokenSymbol].length;
+                  const value = allData[tokenSymbol][displayIndex - missingDatapoints]?.value;
                   return (
                     <div
                       key={`${tokenSymbol}-value`}
@@ -324,7 +338,7 @@ const MarketPerformanceChart = ({ season, size, className }: MarketPerformanceCh
                       <div style={{ color: token?.color }} className={`${!token?.color && "text-pinto-green-3"}`}>
                         {tokenSymbol === "NET" && "Total: "}
                         <p className="inline-block w-[7.1ch] text-right">
-                          {displayValueFormatter(allData[tokenSymbol][displayIndex].value)}
+                          {typeof value === "number" ? displayValueFormatter(value) : "-"}
                         </p>
                       </div>
                       {idx < Object.keys(allData).length - 1 && (
diff --git a/src/components/charts/TVChart.tsx b/src/components/charts/TVChart.tsx
index da839ad39..a75c131e1 100644
--- a/src/components/charts/TVChart.tsx
+++ b/src/components/charts/TVChart.tsx
@@ -16,9 +16,7 @@ import {
   createChart,
 } from "lightweight-charts";
 import { MutableRefObject, useEffect, useMemo, useRef, useState } from "react";
-import { GearIcon } from "../Icons";
 import TooltipSimple from "../TooltipSimple";
-import { ResponsivePopover } from "../ui/ResponsivePopover";
 
 export type TVChartFormattedData = {
   time: Time;
diff --git a/src/components/nav/ChartSelectPanel.tsx b/src/components/nav/ChartSelectPanel.tsx
index c9dc7660a..6e468245a 100644
--- a/src/components/nav/ChartSelectPanel.tsx
+++ b/src/components/nav/ChartSelectPanel.tsx
@@ -6,10 +6,10 @@ import { useDebouncedEffect } from "@/utils/useDebounce";
 import { cn } from "@/utils/utils";
 import { useAtom } from "jotai";
 import { isEqual } from "lodash";
-import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { memo, useCallback, useEffect, useMemo, useState } from "react";
 import { renderAnnouncement } from "../AnnouncementBanner";
 import { ChevronDownIcon, SearchIcon } from "../Icons";
-import { MIN_ADV_SEASON, chartSeasonInputsAtom, selectedChartsAtom } from "../charts/AdvancedChart";
+import { chartSeasonInputsAtom, selectedChartsAtom } from "../charts/AdvancedChart";
 import { Input } from "../ui/Input";
 import { ScrollArea } from "../ui/ScrollArea";
 import { Separator } from "../ui/Separator";
@@ -105,10 +105,11 @@ const ChartSelectPanel = memo(() => {
       } else {
         // When selecting, initialize season input to min value
         const chartData = chartSetupData.find((chart) => chart.index === selection);
-        if (chartData && chartData.inputOptions === "SEASON") {
+        const opts = chartData?.inputOptions;
+        if (opts && opts.type === "SEASON") {
           setInternalSeasonInputs((prev) => ({
             ...prev,
-            [chartData.id]: MIN_ADV_SEASON,
+            [chartData.id]: opts.minSeason,
           }));
         }
         selectedItems.push(selection);
@@ -159,7 +160,15 @@ const ChartSelectPanel = memo(() => {
     () => {
       const clampedInputs = {};
       for (const chartId in rawSeasonInputs) {
-        clampedInputs[chartId] = Math.max(MIN_ADV_SEASON, Math.min(currentSeason, rawSeasonInputs[chartId]));
+        const chartData = chartSetupData.find((chart) => chart.id === chartId);
+        if (!chartData || !chartData.inputOptions) {
+          // Should be unreachable (season input cannot change for chart that didn't configure seasons)
+          continue;
+        }
+        clampedInputs[chartId] = Math.max(
+          chartData.inputOptions.minSeason,
+          Math.min(currentSeason, rawSeasonInputs[chartId]),
+        );
       }
       setInternalSeasonInputs(clampedInputs);
     },
@@ -230,7 +239,7 @@ const ChartSelectPanel = memo(() => {
                             <div className="pinto-sm-light text-pinto-gray-4">{data.shortDescription}</div>
                           </div>
                         </div>
-                        {isSelected && data.inputOptions === "SEASON" && (
+                        {isSelected && data.inputOptions?.type === "SEASON" && (
                           <div className="mt-2 flex items-center gap-2" onClick={(e) => e.stopPropagation()}>
                             <label
                               htmlFor={`season-input-${data.id}`}
@@ -241,7 +250,7 @@ const ChartSelectPanel = memo(() => {
                             <Input
                               id={`season-input-${data.id}`}
                               type="number"
-                              min={MIN_ADV_SEASON}
+                              min={data.inputOptions?.minSeason}
                               max={currentSeason}
                               value={rawSeasonInputs[data.id] || ""}
                               onChange={(e) => handleSeasonInputChange(data.id, e.target.value)}
diff --git a/src/components/nav/PriceButton.tsx b/src/components/nav/PriceButton.tsx
index be58800ba..c9d8678e5 100644
--- a/src/components/nav/PriceButton.tsx
+++ b/src/components/nav/PriceButton.tsx
@@ -12,6 +12,7 @@ import { PoolData, usePriceData, useTwaDeltaBLPQuery, useTwaDeltaBQuery } from "
 import useTokenData from "@/state/useTokenData";
 import { withTracking } from "@/utils/analytics";
 import { formatter } from "@/utils/format";
+import { stringEq } from "@/utils/string";
 import { getTokenIndex } from "@/utils/token";
 import { Token } from "@/utils/types";
 import { cn } from "@/utils/utils";
@@ -19,7 +20,7 @@ import { HTMLAttributes, memo, useMemo, useState } from "react";
 import { Link } from "react-router-dom";
 import { useChainId } from "wagmi";
 import { renderAnnouncement } from "../AnnouncementBanner";
-import { InlineCenterSpan, Row } from "../Container";
+import { InlineCenterSpan } from "../Container";
 import { ExternalLinkIcon, ForwardArrowIcon } from "../Icons";
 import TooltipSimple from "../TooltipSimple";
 import { Card, CardContent, CardFooter, CardHeader } from "../ui/Card";
@@ -38,7 +39,7 @@ function PriceButtonPanel() {
   const { data: twaDeltaBMap } = useTwaDeltaBLPQuery();
 
   const whitelistedPools = useMemo(() => {
-    return priceData.pools.filter((pool) => pool.pool.isWhitelisted);
+    return priceData.pools.filter((pool) => pool.pool && pool.pool.isWhitelisted);
   }, [priceData.pools]);
 
   const mainTokenBalances = useMemo(() => {
@@ -301,14 +302,18 @@ const PoolGroup = ({
         if (props.showPrices) {
           return (
             <>
-              <PoolPriceDisplay key={`${pool.pool.address}_prices_${i}`} pool={pool} priceData={props.priceData} />
+              <PoolPriceDisplay
+                key={`${props.title}_${pool.pool.address}_prices_${i}`}
+                pool={pool}
+                priceData={props.priceData}
+              />
             </>
           );
         }
 
         return (
           <PoolCard
-            key={`${pool.pool.address}_card_${i}`}
+            key={`${props.title}_${pool.pool.address}_card_${i}`}
             pool={pool}
             chainId={props.chainId}
             priceData={props.priceData}
@@ -329,8 +334,16 @@ interface PoolPriceDisplayProps {
 
 const PoolPriceDisplay = ({ pool, priceData }: PoolPriceDisplayProps) => {
   const backingTokenIndex = pool.tokens.findIndex((token: Token) => !token.isMain);
+
+  if (backingTokenIndex === -1) {
+    return null;
+  }
+
   const tokenToShow = priceData.tokenPrices.get(pool.tokens[backingTokenIndex]);
-  if (!tokenToShow) return null;
+
+  if (!tokenToShow) {
+    return null;
+  }
 
   return (
     <div className="flex flex-row justify-between">
@@ -375,7 +388,7 @@ const PoolCard = ({ pool, chainId, priceData, expandAll, useTwa, twaDeltaBMap }:
   const token0BalanceUsd = pool.balances[0].mul(token0Price ?? TokenValue.ZERO) || 0n;
   const token1BalanceUsd = pool.balances[1].mul(token1Price ?? TokenValue.ZERO) || 0n;
   const mainTokenIndex = pool.tokens.findIndex((token: Token) => token.isMain);
-  const deltaBar = pool.balances[mainTokenIndex].gt(0)
+  const deltaBar = pool.balances[mainTokenIndex]?.gt(0)
     ? Number(pool.deltaB.abs().div(pool.balances[mainTokenIndex]).mul(100).toHuman()).toFixed(2)
     : "0";
 
diff --git a/src/constants/slots.ts b/src/constants/slots.ts
index 246c4d612..5453ebcb2 100644
--- a/src/constants/slots.ts
+++ b/src/constants/slots.ts
@@ -6,6 +6,7 @@ import {
   USDC_TOKEN,
   WETH_TOKEN,
   WSOL_TOKEN,
+  WSTETH_TOKEN,
 } from "@/constants/tokens";
 import { AddressMap } from "@/utils/types";
 import { ChainLookup } from "@/utils/types.generic";
@@ -15,6 +16,7 @@ export const addressAllowanceSlotMap: ChainLookup<AddressMap<number>> = {
   [base.id]: {
     [MAIN_TOKEN[base.id].address.toLowerCase()]: 1,
     [WETH_TOKEN[base.id].address.toLowerCase()]: 4,
+    [WSTETH_TOKEN[base.id].address.toLowerCase()]: 2,
     [CBETH_TOKEN[base.id].address.toLowerCase()]: 52,
     [USDC_TOKEN[base.id].address.toLowerCase()]: 10,
     [CBBTC_TOKEN[base.id].address.toLowerCase()]: 10,
diff --git a/src/constants/tokens.ts b/src/constants/tokens.ts
index 1c62fe63d..82686f977 100644
--- a/src/constants/tokens.ts
+++ b/src/constants/tokens.ts
@@ -5,12 +5,14 @@ import pintoWethIcon from "@/assets/tokens/PINTO_WETH.png";
 import pintoWsolIcon from "@/assets/tokens/PINTO_WSOL.png";
 import pintoCbbtcIcon from "@/assets/tokens/PINTO_cbBTC.png";
 import pintoCbethIcon from "@/assets/tokens/PINTO_cbETH.png";
+import pintoWstethIcon from "@/assets/tokens/PINTO_wstETH.png";
 import spectrasPintoLPIcon from "@/assets/tokens/SPECTRA-sPINTO-LP.png";
 import spectrasPintoPTIcon from "@/assets/tokens/SPECTRA-sPINTO-PT.png";
 import spectrasPintoYTIcon from "@/assets/tokens/SPECTRA-sPINTO-YT.png";
 import wsolIcon from "@/assets/tokens/WSOL.png";
 import crsPintoIcon from "@/assets/tokens/crsPINTO.png";
 import sPintoIcon from "@/assets/tokens/sPINTO.png";
+import wstETHIcon from "@/assets/tokens/wstETH.png";
 import { Token, Token3PIntegration } from "@/utils/types";
 import { ChainLookup } from "@/utils/types.generic";
 import { arbitrum, base } from "viem/chains";
@@ -174,8 +176,47 @@ export const WSOL_TOKEN: ChainLookup<Token> = {
   },
 } as const;
 
+export const WSTETH_TOKEN: ChainLookup<Token> = {
+  [base.id]: {
+    chainId: base.id,
+    name: "Wrapped liquid staked Ether 2.0",
+    symbol: "wstETH",
+    address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
+    decimals: 18,
+    displayDecimals: 2,
+    isLPUnderlying: true,
+    isCompositeLPWhitelisted: true,
+    logoURI: wstETHIcon,
+    color: "#00A3FF",
+  },
+};
+
+const defaultLPTokenIndicies = {
+  tokenIndicies: {
+    main: 0,
+    pair: 1,
+  },
+} as const;
+
 // -------------------- LP TOKENS --------------------
 
+export const PINTO_WSTETH_TOKEN: ChainLookup<Token> = {
+  [base.id]: {
+    chainId: base.id,
+    name: "PINTOWSTETH LP",
+    symbol: "PINTOWSTETH",
+    address: "0x3e1155245FF9a6a019Bc35827e801c6ED2CE91b9", // temp address
+    decimals: 18,
+    displayDecimals: 2,
+    isLP: true,
+    isWhitelisted: true,
+    logoURI: pintoWstethIcon,
+    color: "#00A3FF",
+    tokens: [MAIN_TOKEN[base.id].address, WSTETH_TOKEN[base.id].address],
+    ...defaultLPTokenIndicies,
+  },
+} as const;
+
 export const PINTO_WSOL_TOKEN: ChainLookup<Token> = {
   [base.id]: {
     chainId: base.id,
@@ -189,6 +230,7 @@ export const PINTO_WSOL_TOKEN: ChainLookup<Token> = {
     logoURI: pintoWsolIcon,
     color: "#9945FF",
     tokens: [MAIN_TOKEN[base.id].address, WSOL_TOKEN[base.id].address],
+    ...defaultLPTokenIndicies,
   },
 } as const;
 
@@ -205,6 +247,7 @@ export const PINTO_WETH_TOKEN: ChainLookup<Token> = {
     logoURI: pintoWethIcon,
     color: "#8C8C8C",
     tokens: [MAIN_TOKEN[base.id].address, WETH_TOKEN[base.id].address],
+    ...defaultLPTokenIndicies,
   },
 } as const;
 
@@ -221,6 +264,7 @@ export const PINTO_CBETH_TOKEN: ChainLookup<Token> = {
     logoURI: pintoCbethIcon,
     color: "#0052FF",
     tokens: [MAIN_TOKEN[base.id].address, CBETH_TOKEN[base.id].address],
+    ...defaultLPTokenIndicies,
   },
 } as const;
 
@@ -237,6 +281,7 @@ export const PINTO_USDC_TOKEN: ChainLookup<Token> = {
     logoURI: pintoUsdcIcon,
     color: "#2775CA",
     tokens: [MAIN_TOKEN[base.id].address, USDC_TOKEN[base.id].address],
+    ...defaultLPTokenIndicies,
   },
 } as const;
 
@@ -253,6 +298,7 @@ export const PINTO_CBBTC_TOKEN: ChainLookup<Token> = {
     logoURI: pintoCbbtcIcon,
     color: "#F7931A",
     tokens: [MAIN_TOKEN[base.id].address, CBBTC_TOKEN[base.id].address],
+    ...defaultLPTokenIndicies,
   },
 } as const;
 
@@ -367,6 +413,7 @@ export const LP_TOKENS: ChainLookup<Token[]> = {
     PINTO_CBETH_TOKEN[base.id],
     PINTO_CBBTC_TOKEN[base.id],
     PINTO_WSOL_TOKEN[base.id],
+    PINTO_WSTETH_TOKEN[base.id],
   ],
 } as const;
 
@@ -399,6 +446,7 @@ export const UNDERLYING_TOKENS: ChainLookup<Token[]> = {
     CBETH_TOKEN[base.id],
     CBBTC_TOKEN[base.id],
     WSOL_TOKEN[base.id],
+    WSTETH_TOKEN[base.id],
   ],
 } as const;
 
@@ -446,7 +494,7 @@ export const tokens: { [chainId: number]: Token[] } = {
 export const PINTO = MAIN_TOKEN[defaultChain];
 
 // Native Chain Token
-export const ETH = NATIVE_TOKEN[defaultChain][1];
+export const ETH = NATIVE_TOKEN[defaultChain];
 
 // Well LP Tokens
 export const PINTOWETH = LP_TOKENS[defaultChain][0];
@@ -454,6 +502,7 @@ export const PINTOCBETH = LP_TOKENS[defaultChain][1];
 export const PINTOUSDC = LP_TOKENS[defaultChain][2];
 export const PINTOCBBTC = LP_TOKENS[defaultChain][3];
 export const PINTOWSOL = LP_TOKENS[defaultChain][4];
+export const PINTOWSTETH = LP_TOKENS[defaultChain][5];
 
 // Underlying Tokens
 export const WETH = UNDERLYING_TOKENS[defaultChain][0];
@@ -461,3 +510,4 @@ export const USDC = UNDERLYING_TOKENS[defaultChain][1];
 export const CBETH = UNDERLYING_TOKENS[defaultChain][2];
 export const CBBTC = UNDERLYING_TOKENS[defaultChain][3];
 export const WSOL = UNDERLYING_TOKENS[defaultChain][4];
+export const WSTETH = UNDERLYING_TOKENS[defaultChain][5];
diff --git a/src/hooks/swap/useSwapSummary.ts b/src/hooks/swap/useSwapSummary.ts
index b77ace324..7bb10dc12 100644
--- a/src/hooks/swap/useSwapSummary.ts
+++ b/src/hooks/swap/useSwapSummary.ts
@@ -60,7 +60,13 @@ export default function useSwapSummary(quote: BeanSwapNodeQuote | undefined): Sw
 
       if (node instanceof WellSyncSwapNode) {
         addLiquidityRoute = route;
-        addLiquiditySlippage = quote.usdIn.sub(quote.usdOut).div(quote.usdIn).mul(100).toNumber();
+        const usdOut = quote.usdOut.eq(0) ? TV.ONE : quote.usdOut;
+        const usdIn = quote.usdIn.eq(0) ? TV.ONE : quote.usdIn;
+        if (usdIn.isZero || usdOut.isZero) {
+          addLiquiditySlippage = undefined;
+        } else {
+          addLiquiditySlippage = usdIn.sub(usdOut).div(usdIn).mul(100).toNumber();
+        }
         routes.push(route);
       } else {
         if (node instanceof ZeroXSwapNode) {
@@ -69,7 +75,7 @@ export default function useSwapSummary(quote: BeanSwapNodeQuote | undefined): Sw
 
           if (fee?.feeToken) {
             const feeTokenUSD = tokenPrices.get(fee.feeToken);
-            if (feeTokenUSD) {
+            if (feeTokenUSD && !node.usdIn.isZero && !node.usdIn.isZero) {
               const feeUSD = fee.fee.mul(feeTokenUSD.instant);
               const feePct = feeUSD.div(node.usdIn).mul(100).toNumber();
               route.exchangeFee = feeUSD.toNumber();
diff --git a/src/lib/Swap/price-cache.ts b/src/lib/Swap/price-cache.ts
index 9c98ec773..ef8f7a649 100644
--- a/src/lib/Swap/price-cache.ts
+++ b/src/lib/Swap/price-cache.ts
@@ -8,7 +8,7 @@ import { resolveChainId } from "@/utils/chain";
 import { getTokenIndex, tokensEqual } from "@/utils/token";
 import { Token } from "@/utils/types";
 import { multicall } from "@wagmi/core";
-import { ContractFunctionParameters } from "viem";
+import { ContractFunctionParameters, MulticallReturnType } from "viem";
 import { readContract } from "viem/actions";
 
 const TWO_MINS = 1000 * 60 * 2;
@@ -77,21 +77,21 @@ export class SwapPriceCache {
     const diff = now - this.#lastFetchedTimestamp;
 
     if (force || diff > TWO_MINS) {
-      const { priceMap, wellPriceMap } = await this.#fetchPrices();
+      const { priceMap, wellPriceMap } = await this.fetchPrices();
       this.#priceMap = priceMap;
       this.#wellPriceMap = wellPriceMap;
       this.#lastFetchedTimestamp = now;
     }
   }
 
-  async #fetchPrices() {
-    const { tokens, contracts, price: priceContract } = this.#buildMulticall();
+  private async fetchPrices() {
+    const { tokens, contracts, price: priceContract } = this.buildMulticall();
 
     const [prices, redemptionForOneMainToken] = await Promise.all([
       // all token prices
       multicall(this.#context.config, {
         contracts: [...contracts, priceContract],
-        allowFailure: false,
+        allowFailure: true,
       }),
       // silo wrapped token redemption for 1 main token
       readContract(this.#context.config.getClient({ chainId: this.#context.chainId }), {
@@ -105,30 +105,39 @@ export class SwapPriceCache {
     const priceMap = new Map<Token, TV>();
     const wellPriceMap = new Map<Token, TV>();
 
-    for (const [index, price] of prices.entries()) {
-      const token = tokens[index];
+    // price result is the last element in the prices array
+    const priceResult = prices[prices.length - 1];
+
+    const tokenPrices = [...prices].slice(0, contracts.length);
+
+    // set the token prices into the map
+    for (const [index, token] of tokens.entries()) {
+      const price = tokenPrices[index];
+      const result = price.result;
+
+      if (result && typeof result === "bigint") {
+        priceMap.set(token, TV.fromBigInt(result, 6));
 
-      if (typeof price === "bigint") {
         if (token.isWrappedNative) {
-          priceMap.set(this.#context.native, TV.fromBlockchain(price, 6));
+          priceMap.set(this.#context.native, TV.fromBlockchain(result, 6));
         }
-        const mainTokenPrice = TV.fromBlockchain(price, 6);
-        priceMap.set(token, mainTokenPrice);
-        priceMap.set(this.#context.siloWrappedToken, mainTokenPrice);
-      } else if (price.price) {
-        priceMap.set(this.#context.mainToken, TV.fromBlockchain(price.price, 6));
-
-        price.ps.forEach((pool) => {
-          const well = this.#context.tokenMap[getTokenIndex(pool.pool)];
-          if (well) {
-            wellPriceMap.set(well, TV.fromBlockchain(pool.price, 6));
-            priceMap.set(well, TV.fromBlockchain(pool.lpUsd, 6));
-          }
-        });
       }
     }
 
-    this.#updatePriceMapWithSiloWrappedToken(redemptionForOneMainToken, priceMap);
+    if (priceResult.result && typeof priceResult.result === "object") {
+      const result = priceResult.result;
+      priceMap.set(this.#context.mainToken, TV.fromBlockchain(result.price, 6));
+
+      result.ps.forEach((pool) => {
+        const well = this.#context.tokenMap[getTokenIndex(pool.pool)];
+        if (well) {
+          wellPriceMap.set(well, TV.fromBlockchain(pool.price, 6));
+          priceMap.set(well, TV.fromBlockchain(pool.lpUsd, 6));
+        }
+      });
+    }
+
+    this.updatePriceMapWithSiloWrappedToken(redemptionForOneMainToken, priceMap);
 
     return {
       priceMap,
@@ -136,7 +145,7 @@ export class SwapPriceCache {
     };
   }
 
-  #buildMulticall() {
+  private buildMulticall() {
     const tokens = Object.keys(this.#context.underlying2LP).map((token) => {
       return this.#context.tokenMap[getTokenIndex(token)];
     });
@@ -156,22 +165,14 @@ export class SwapPriceCache {
       args: [],
     };
 
-    const siloWrappedExchangeRate: ContractFunctionParameters<typeof siloedPintoABI> = {
-      address: this.#context.siloWrappedToken.address,
-      abi: siloedPintoABI,
-      functionName: "previewRedeem",
-      args: [BigInt(10 ** this.#context.siloWrappedToken.decimals)],
-    };
-
     return {
       tokens,
       contracts: contracts,
-      siloWrappedExchangeRate,
       price,
     };
   }
 
-  #updatePriceMapWithSiloWrappedToken(amount: bigint, priceMap: Map<Token, TV>): void {
+  private updatePriceMapWithSiloWrappedToken(amount: bigint, priceMap: Map<Token, TV>): void {
     const baseAmount = TV.fromHuman(1, this.#context.mainToken.decimals);
     const redemptionAmount = TV.fromBigInt(amount, this.#context.mainToken.decimals);
     const mainTokenUSD = priceMap.get(this.#context.mainToken);
diff --git a/src/lib/siloConvert/SiloConvert.cache.ts b/src/lib/siloConvert/SiloConvert.cache.ts
index e7614ff31..27fc91184 100644
--- a/src/lib/siloConvert/SiloConvert.cache.ts
+++ b/src/lib/siloConvert/SiloConvert.cache.ts
@@ -1,5 +1,6 @@
 import { Clipboard } from "@/classes/Clipboard";
 import { TV } from "@/classes/TokenValue";
+import { diamondABI } from "@/constants/abi/diamondABI";
 import { diamondPriceABI } from "@/constants/abi/diamondPriceABI";
 import { abiSnippets } from "@/constants/abiSnippets";
 import { MAIN_TOKEN } from "@/constants/tokens";
@@ -13,13 +14,21 @@ import { beanstalkPriceAddress } from "@/generated/contractHooks";
 import { AdvancedPipeWorkflow } from "@/lib/farm/workflow";
 import { SiloConvertContext } from "@/lib/siloConvert/types";
 import { ExchangeWell } from "@/lib/well/ExchangeWell";
-import { PoolData } from "@/state/usePriceData";
+import { BasePoolData, PoolData } from "@/state/usePriceData";
 import { resolveChainId } from "@/utils/chain";
+import { stringEq } from "@/utils/string";
 import { getChainToken, getChainTokenMap, getTokenIndex } from "@/utils/token";
 import { tokensEqual } from "@/utils/token";
 import { AdvancedPipeCall, Token } from "@/utils/types";
 import { AddressLookup, HashString } from "@/utils/types.generic";
-import { Address, decodeFunctionResult, encodeFunctionData } from "viem";
+import {
+  Address,
+  ContractFunctionParameters,
+  MulticallReturnType,
+  decodeFunctionResult,
+  encodeFunctionData,
+} from "viem";
+import { multicall } from "viem/actions";
 
 /**
  * Extended pool data for the SiloConvertCache.
@@ -92,6 +101,11 @@ export class SiloConvertPriceCache {
   /** The last time the cache was updated. */
   lastUpdateTimestamp: number = 0;
 
+  /**
+   * A set of well addresses that failed to return any form of price data from the price / diamond contract
+   */
+  private invalidWells: Set<string> = new Set();
+
   constructor(context: SiloConvertContext) {
     this.context = context;
     this.lp2Pair = getLpTokensToPairs(context.chainId);
@@ -171,6 +185,14 @@ export class SiloConvertPriceCache {
     return well.pair.price;
   }
 
+  getIsWellAvailable(well: Address) {
+    if (this.invalidWells.has(getTokenIndex(well))) {
+      return false;
+    }
+
+    return true;
+  }
+
   /**
    * Returns the Extended Well data for a given Well address.
    */
@@ -196,7 +218,8 @@ export class SiloConvertPriceCache {
     console.debug("[SiloConvertCache/update] updating cache...");
     const diff = Date.now() - this.lastUpdateTimestamp;
     if (force || this.lastUpdateTimestamp === 0 || diff > REFETCH_INTERVAL) {
-      const priceResult = await this.fetch();
+      const priceResult = await this.fetchMulticall();
+      this.invalidWells = priceResult.erroredWells;
       this.priceStruct = priceResult;
       this.lastUpdateTimestamp = Date.now();
       console.debug("[PipelineConvert/Cache/update]: ", this);
@@ -236,15 +259,19 @@ export class SiloConvertPriceCache {
   }
 
   getPriceCallStructs(): AdvancedPipeCall[] {
+    const availWells = Object.values(this.dewhitelistedLP).filter((tk) => this.getIsWellAvailable(tk.address));
+
     return [
       encodePrice(this.context.chainId),
-      ...Object.values(this.dewhitelistedLP).map((tk) => encodeGetWell(this.context.chainId, tk.address)),
+      ...availWells.map((tk) => encodeGetWell(this.context.chainId, tk.address)),
     ];
   }
 
   decodePriceCallResults(results: HashString[]) {
+    const availWells = Object.values(this.dewhitelistedLP).filter((tk) => this.getIsWellAvailable(tk.address));
+
     // +1 for the price call
-    const expectedLength = Object.keys(this.dewhitelistedLP).length + 1;
+    const expectedLength = availWells.length + 1;
 
     if (results.length < expectedLength) {
       throw new Error(`Cannot decode price call results. Expected ${expectedLength} results but got ${results.length}`);
@@ -255,7 +282,7 @@ export class SiloConvertPriceCache {
 
     priceResult.pools = { ...priceResult.pools };
 
-    Object.values(this.dewhitelistedLP).forEach((tk, idx) => {
+    availWells.forEach((tk, idx) => {
       const res = decodeGetWell(dewhitelistedLPResults[idx]);
       priceResult.pools[getTokenIndex(tk.address)] = res;
     });
@@ -292,73 +319,174 @@ export class SiloConvertPriceCache {
     return advPipe;
   }
 
-  /**
-   * Fetches the relevant pool data from on chain
-   */
-  async fetch(): Promise<ExtendedPriceResult> {
-    console.debug("[SiloConvertCache/fetch] fetching price data...");
+  async fetchMulticall() {
+    const client = this.context.wagmiConfig.getClient({ chainId: this.context.chainId });
     const tokenMap = getChainTokenMap(this.context.chainId);
-    const mainToken = MAIN_TOKEN[resolveChainId(this.context.chainId)];
 
-    const advPipe = this.constructPriceAdvPipe();
+    const erroredWells: Set<string> = new Set();
+
+    const calls = this.getMultiCallPriceContracts();
 
-    // Fetch price contract data & price oracle data
+    const { priceCalls, dewhitelistedWellLPCalls, lpPairTokenPriceCalls } = calls;
+
+    const datas = await multicall(client, {
+      contracts: [...priceCalls, ...dewhitelistedWellLPCalls, ...lpPairTokenPriceCalls],
+      allowFailure: true,
+    });
 
-    const advPipeResult = await advPipe.readStatic();
-    const sliceIdx = Object.keys(this.dewhitelistedLP).length + 1;
-    const priceFragments = advPipeResult.slice(0, sliceIdx);
-    const tokenUsdData = advPipeResult.slice(sliceIdx, advPipeResult.length);
+    const [priceData, ...remaining] = datas;
+    const dewhitelistedLPData = remaining.slice(0, dewhitelistedWellLPCalls.length) as MulticallReturnType<
+      typeof dewhitelistedWellLPCalls,
+      true
+    >;
+    const lpPairTokenPriceData = remaining.slice(dewhitelistedWellLPCalls.length, remaining.length);
 
-    const priceResult = this.decodePriceCallResults(priceFragments);
+    const priceResult = priceData.result;
+
+    if (!priceResult || typeof priceResult !== "object" || !("ps" in priceResult)) {
+      throw new Error("[SiloConvertCache/fetchMulticall] Price data error");
+    }
 
     const map: AddressLookup<ExtendedPoolData> = {};
 
+    const dwLPs = Object.values(this.dewhitelistedLP);
+
+    const dwLPData = dewhitelistedLPData
+      .map((d, i) => {
+        if (d.result && typeof d.result === "object") {
+          return d.result;
+        }
+
+        console.debug(
+          `[SiloConvertCache/fetchMulticall] Error decoding dewhitelisted LP data for ${dwLPs[i]?.address}. Adding to erroredWells set.`,
+        );
+        const erroredWell = Object.values(this.dewhitelistedLP)[i]?.address;
+        erroredWells.add(Object.values(this.dewhitelistedLP)[i]?.address);
+        return undefined;
+      })
+      .filter((d) => d !== undefined);
+
+    const reducedPs = priceResult.ps.reduce<AddressLookup<BasePoolData<Address, bigint>>>((prev, curr) => {
+      prev[getTokenIndex(curr.pool)] = {
+        ...curr,
+        tokens: [curr.tokens[0], curr.tokens[1]] satisfies Address[],
+        balances: [curr.balances[0], curr.balances[1]] satisfies bigint[],
+      };
+      return prev;
+    }, {});
+
     for (const [index, [lpTokenIndex, pairToken]] of Object.entries(this.lp2Pair).entries()) {
-      const pairPriceBigInt = decodeFunctionResult({
-        abi: abiSnippets.price.getTokenUsdPrice,
-        functionName: "getTokenUsdPrice",
-        data: tokenUsdData[index],
-      });
+      const data = lpPairTokenPriceData[index];
+      const result = data.result;
+
+      if (!result || typeof result !== "bigint") {
+        continue;
+      }
 
-      const poolResult = priceResult.pools[lpTokenIndex];
-      const wellTokens = poolResult?.tokens.map((t) => getChainToken(this.context.chainId, t));
+      let poolResult = reducedPs[getTokenIndex(lpTokenIndex)];
 
       if (!poolResult) {
-        throw new Error(`Pool result not found for ${lpTokenIndex}`);
+        const mayPoolResult = dwLPData.find((d) => stringEq(d.pool, lpTokenIndex));
+        if (mayPoolResult) {
+          poolResult = {
+            ...mayPoolResult,
+            tokens: [mayPoolResult.tokens[0], mayPoolResult.tokens[1]] satisfies Address[],
+            balances: [mayPoolResult.balances[0], mayPoolResult.balances[1]] satisfies bigint[],
+          };
+        } else {
+          erroredWells.add(lpTokenIndex);
+          console.debug(
+            `[SiloConvertCache/fetchMulticall] No pool result found for ${lpTokenIndex}. Adding to erroredWells set.`,
+          );
+          continue;
+        }
       }
+
+      const wellTokens = poolResult.tokens.map((t) => getChainToken(this.context.chainId, t));
       if (!wellTokens.length) {
-        throw new Error(`No well tokens found with address: ${lpTokenIndex}`);
+        erroredWells.add(lpTokenIndex);
+        console.debug(
+          `[SiloConvertCache/fetchMulticall] No well tokens found with address: ${lpTokenIndex}. Adding to erroredWells set.`,
+        );
+        continue;
       }
 
-      const poolPrice = TV.fromBigInt(poolResult.price, mainToken.decimals);
+      const pairPrice = TV.fromBigInt(result, pairToken.decimals);
+      const poolPrice = TV.fromBigInt(poolResult.price, 6);
 
       const pairData = {
         token: pairToken,
         index: wellTokens[0].isMain ? 1 : 0,
-        price: TV.fromBigInt(pairPriceBigInt, mainToken.decimals),
+        price: pairPrice,
       };
 
       map[lpTokenIndex] = {
         pool: tokenMap[lpTokenIndex],
-        price: poolPrice,
+        price: TV.fromBigInt(poolResult.price, 6),
         pair: pairData,
         tokens: wellTokens,
         liquidity: TV.fromBigInt(poolResult.liquidity, 6),
-        lpUsd: TV.fromBigInt(poolResult.lpUsd, mainToken.decimals),
-        lpBdv: TV.fromBigInt(poolResult.lpBdv, mainToken.decimals),
-        deltaB: TV.fromBigInt(poolResult.deltaB, mainToken.decimals),
+        lpUsd: TV.fromBigInt(poolResult.lpUsd, 6),
+        lpBdv: TV.fromBigInt(poolResult.lpBdv, 6),
+        deltaB: TV.fromBigInt(poolResult.deltaB, 6),
         balances: wellTokens.map((t, i) => TV.fromBigInt(poolResult.balances[i], t.decimals)),
         prices: wellTokens.map((t) => (t.isMain ? poolPrice : pairData.price)),
       };
     }
 
+    if (!dewhitelistedLPData.length || !lpPairTokenPriceData.length) {
+      throw new Error("No dewhitelistedLPData or lpPairTokenPriceData found");
+    }
+
     return {
       deltaB: TV.fromBigInt(priceResult.deltaB, 6),
       price: TV.fromBigInt(priceResult.price, 6),
       liquidity: TV.fromBigInt(priceResult.liquidity, 6),
       pools: map,
+      erroredWells,
     };
   }
+
+  /**
+   *
+   * constructs the contracts for the price multicall
+   */
+  private getMultiCallPriceContracts() {
+    const priceAddress = beanstalkPriceAddress[resolveChainId(this.context.chainId)];
+
+    // Put this in an array so TS doesn't complain about the type mismatch when not in an array
+    const priceCalls: ContractFunctionParameters<typeof diamondPriceABI, "view", "price">[] = [
+      {
+        address: priceAddress,
+        abi: diamondPriceABI,
+        functionName: "price",
+        args: [],
+      },
+    ];
+    const dewhitelistedWellLPCalls: ContractFunctionParameters<typeof diamondPriceABI, "view", "getWell">[] =
+      Object.values(this.dewhitelistedLP).map((dwlp) => {
+        return {
+          address: priceAddress,
+          abi: diamondPriceABI,
+          functionName: "getWell",
+          args: [dwlp.address],
+        };
+      });
+    const lpPairTokenPriceCalls = Object.values(this.lp2Pair).map((data) => {
+      return {
+        address: this.context.diamond,
+        abi: diamondABI,
+        functionName: "getTokenUsdPrice",
+        args: [data.address],
+      } as const;
+    });
+
+    return {
+      priceCalls,
+      dewhitelistedWellLPCalls,
+      lpPairTokenPriceCalls,
+    } as const;
+  }
 }
 
 /**
diff --git a/src/lib/siloConvert/SiloConvert.ts b/src/lib/siloConvert/SiloConvert.ts
index 9173560c8..48f8594a5 100644
--- a/src/lib/siloConvert/SiloConvert.ts
+++ b/src/lib/siloConvert/SiloConvert.ts
@@ -295,28 +295,43 @@ export class SiloConvert {
       throw e;
     });
 
-    const simulationsRawResults = await Promise.all(
-      quotedRoutes.map((route) =>
-        route.workflow
-          .simulate({
-            account: this.context.account,
-            after: this.priceCache.constructPriceAdvPipe({ noTokenPrices: true }),
-          })
-          .catch((e) => {
-            logError("[SiloConvert/quote] FAILED to simulate routes : ", e);
-            throw new SimulationError("quote", e instanceof Error ? e.message : "Unknown error", {
-              routes,
-              quotedRoutes,
-            });
-          })
-          .then((r) => {
-            console.debug("[SiloConvert/quote] simulated route!: ", route, r);
-            return r;
-          }),
-      ),
-    );
+    const runSimulate = (getPrices: boolean, warn?: boolean) => {
+      return Promise.all(
+        quotedRoutes.map((route) =>
+          route.workflow
+            .simulate({
+              account: this.context.account,
+              after: getPrices ? this.priceCache.constructPriceAdvPipe({ noTokenPrices: true }) : undefined,
+            })
+            .catch((e) => {
+              logError("[SiloConvert/quote] FAILED to simulate routes : ", e, warn);
+              throw new SimulationError("quote", e instanceof Error ? e.message : "Unknown error", {
+                routes,
+                quotedRoutes,
+              });
+            })
+            .then((r) => {
+              console.debug("[SiloConvert/quote] simulated route!: ", route, r);
+              return r;
+            }),
+        ),
+      );
+    };
+
+    let didSucceedWithPrices = true;
+
+    const simulationsRawResults = await runSimulate(true, true).catch((e) => {
+      didSucceedWithPrices = false;
+      logError("[SiloConvert/quote] RETRYING to simulate routes w/o prices: ", e, true);
+      return runSimulate(false, false).catch((e) => {
+        throw new SimulationError("quote", e instanceof Error ? e.message : "Unknown error", {
+          routes,
+          quotedRoutes,
+        });
+      });
+    });
 
-    console.debug("[SiloConvert/quote] post simulation results: ", {
+    console.log("[SiloConvert/quote] post simulation results: ", {
       quotedRoutes,
       simulationsRawResults,
     });
@@ -333,7 +348,7 @@ export class SiloConvert {
       let decoded: ReturnType<typeof this.decodeRouteAndPriceResults>;
 
       try {
-        decoded = this.decodeRouteAndPriceResults(staticCallResult, route.route);
+        decoded = this.decodeRouteAndPriceResults(staticCallResult, route.route, didSucceedWithPrices);
       } catch (e) {
         logError("[SiloConvert/quote] FAILED to decode route and price results: ", e);
         throw new ConversionQuotationError("Failed to decode route and price results", {
@@ -389,20 +404,22 @@ export class SiloConvert {
   private decodeRouteAndPriceResults(
     rawResponse: HashString[],
     route: SiloConvertRoute<SiloConvertType>,
+    priceCallSuccess: boolean,
   ): Pick<SiloConvertSummary<SiloConvertType>, "results" | "reducedResults" | "postPriceData"> {
     const mainToken = getChainConstant(this.context.chainId, MAIN_TOKEN);
     try {
       const staticCallResult = [...rawResponse];
 
       // price result is the last element in the static call result
-      const priceResult = staticCallResult.pop();
+      const priceResult = !priceCallSuccess ? undefined : staticCallResult.pop();
 
       const decodedConvertResults = decodeConvertResults(staticCallResult, route.convertType);
 
       const decodedPriceCalls = priceResult ? AdvancedPipeWorkflow.decodeResult(priceResult) : undefined;
-      const postPriceData = decodedPriceCalls?.length
-        ? this.priceCache.decodePriceCallResults([...decodedPriceCalls])
-        : undefined;
+      const postPriceData =
+        decodedPriceCalls?.length && priceCallSuccess
+          ? this.priceCache.decodePriceCallResults([...decodedPriceCalls])
+          : undefined;
 
       return {
         postPriceData,
@@ -458,12 +475,12 @@ export class SiloConvert {
   }
 }
 
-function logError(prefix: string, e: unknown) {
+function logError(prefix: string, e: unknown, warn?: boolean) {
   if (e instanceof SiloConvertError) {
-    console.error(prefix, e.toLogObject());
+    console[warn ? "warn" : "error"](prefix, e.toLogObject());
   } else if (e instanceof Error) {
-    console.error(prefix, e.message);
+    console[warn ? "warn" : "error"](prefix, e.message);
   } else {
-    console.error("[SiloConvert] Unknown error: ", e);
+    console[warn ? "warn" : "error"]("[SiloConvert] Unknown error: ", e);
   }
 }
diff --git a/src/lib/siloConvert/siloConvert.strategizer.ts b/src/lib/siloConvert/siloConvert.strategizer.ts
index 8b1e98791..b14b59237 100644
--- a/src/lib/siloConvert/siloConvert.strategizer.ts
+++ b/src/lib/siloConvert/siloConvert.strategizer.ts
@@ -137,7 +137,11 @@ export class Strategizer {
       const sourceWell = source.isLP ? this.cache.getWell(source.address) : undefined;
 
       // if SourceWell exists, target must be main due to validation above.
-      if (sourceWell && !this.maxConvertQuoter.isAggDisabledToken(source)) {
+      if (
+        sourceWell &&
+        !this.maxConvertQuoter.isAggDisabledToken(source) &&
+        this.cache.getIsWellAvailable(source.address)
+      ) {
         routes.push({
           source,
           target,
diff --git a/src/lib/siloConvert/siloConvert.swapQuoter.ts b/src/lib/siloConvert/siloConvert.swapQuoter.ts
index 3e722c120..86f047851 100644
--- a/src/lib/siloConvert/siloConvert.swapQuoter.ts
+++ b/src/lib/siloConvert/siloConvert.swapQuoter.ts
@@ -81,7 +81,7 @@ export class SiloConvertSwapQuoter {
 
     const fee = quote.fees?.zeroExFee;
 
-    if (fee) {
+    if (fee && !usdIn.isZero && !usdOut.isZero) {
       const feeToken = stringEq(fee.token, sellToken.address) ? sellToken : buyToken;
       const feeAmount = TV.fromBlockchain(fee.amount, feeToken.decimals);
       const feeTokenUSD = tokensEqual(feeToken, sellToken) ? sellTokenUSD : buyTokenUSD;
diff --git a/src/pages/Swap.tsx b/src/pages/Swap.tsx
index 7b7fb4028..f3f0b90c3 100644
--- a/src/pages/Swap.tsx
+++ b/src/pages/Swap.tsx
@@ -1,4 +1,3 @@
-import { TokenValue } from "@/classes/TokenValue";
 import { ComboInputField } from "@/components/ComboInputField";
 import DestinationBalanceSelect from "@/components/DestinationBalanceSelect";
 import { UpDownArrowsIcon } from "@/components/Icons";
diff --git a/src/state/seasonal/queries/useSeasonalMarketPerformance.ts b/src/state/seasonal/queries/useSeasonalMarketPerformance.ts
index 75ba5d270..1826b6350 100644
--- a/src/state/seasonal/queries/useSeasonalMarketPerformance.ts
+++ b/src/state/seasonal/queries/useSeasonalMarketPerformance.ts
@@ -1,11 +1,4 @@
 import { subgraphs } from "@/constants/subgraph";
-import {
-  PINTO_CBBTC_TOKEN,
-  PINTO_CBETH_TOKEN,
-  PINTO_USDC_TOKEN,
-  PINTO_WETH_TOKEN,
-  PINTO_WSOL_TOKEN,
-} from "@/constants/tokens";
 import {
   BeanstalkSeasonalMarketPerformanceDocument,
   BeanstalkSeasonalMarketPerformanceQuery,
@@ -13,7 +6,6 @@ import {
 } from "@/generated/gql/pintostalk/graphql";
 import { useLPTokenToNonPintoUnderlyingMap } from "@/hooks/pinto/useTokenMap";
 import useTokenData from "@/state/useTokenData";
-import { useChainConstant } from "@/utils/chain";
 import { PaginationSettings, paginateSubgraph } from "@/utils/paginateSubgraph";
 import {
   SeasonalMarketPerformanceChartData,
@@ -167,35 +159,38 @@ export function useMarketPerformanceCalc(
           }
 
           if (chartType !== SMPChartType.TOKEN_PRICES) {
-            result[symbol] ??= [
-              {
-                season: season.season - 1,
-                value: 0,
-                timestamp: new Date((Number(season.timestamp) - 60 * 60) * 1000),
-              },
-            ];
-            const arr = result[symbol];
-
-            const value =
-              chartType < SMPChartType.USD_CUMULATIVE
-                ? Number(season[CHART_FIELDS[chartType % 2][0]][tokenIdx])
-                : accumulator(chartType)(
-                    arr[arr.length - 1].value,
-                    Number(season[CHART_FIELDS[chartType % 2][0]][tokenIdx]),
-                  );
-            arr.push({
-              season: season.season,
-              value,
-              timestamp: new Date(Number(season.timestamp) * 1000),
-            });
+            const seasonValue = season[CHART_FIELDS[chartType % 2][0]][tokenIdx];
+            if (!!seasonValue) {
+              result[symbol] ??= [
+                {
+                  season: season.season - 1,
+                  value: 0,
+                  timestamp: new Date((Number(season.timestamp) - 60 * 60) * 1000),
+                },
+              ];
+              const arr = result[symbol];
+
+              const value =
+                chartType < SMPChartType.USD_CUMULATIVE
+                  ? Number(seasonValue)
+                  : accumulator(chartType)(arr[arr.length - 1].value, Number(seasonValue));
+              arr.push({
+                season: season.season,
+                value,
+                timestamp: new Date(Number(season.timestamp) * 1000),
+              });
+            }
           } else {
-            result[symbol] ??= [];
-            result[symbol].push({
-              season: season.season,
-              // biome-ignore lint/style/noNonNullAssertion: can't be null given only valid=true is retrieved from sg.
-              value: Number(season.thisSeasonTokenUsdPrices![tokenIdx]),
-              timestamp: new Date(Number(season.timestamp) * 1000),
-            });
+            // biome-ignore lint/style/noNonNullAssertion: can't be null given only valid=true is retrieved from sg.
+            const seasonValue = season.thisSeasonTokenUsdPrices![tokenIdx];
+            if (!!seasonValue) {
+              result[symbol] ??= [];
+              result[symbol].push({
+                season: season.season,
+                value: Number(seasonValue),
+                timestamp: new Date(Number(season.timestamp) * 1000),
+              });
+            }
           }
           ++tokenIdx;
         }
@@ -203,6 +198,7 @@ export function useMarketPerformanceCalc(
     }
     return result;
   }, [seasonalData, chartType, startSeasons, mainToken.address, lpToUnderlyingMap]);
+
   return responseData;
 }
 
diff --git a/src/state/useChartSetupData.ts b/src/state/useChartSetupData.ts
index 6f5412a4c..66f1ab4cf 100644
--- a/src/state/useChartSetupData.ts
+++ b/src/state/useChartSetupData.ts
@@ -2,11 +2,12 @@ import pintoExchangeLogo from "@/assets/misc/pinto-exchange-logo.svg";
 import podIcon from "@/assets/protocol/Pod.png";
 import stalkIcon from "@/assets/protocol/Stalk.png";
 import { TokenValue } from "@/classes/TokenValue";
-import { CBBTC_TOKEN, CBETH_TOKEN, WETH_TOKEN, WSOL_TOKEN } from "@/constants/tokens";
+import { CBBTC_TOKEN, CBETH_TOKEN, WETH_TOKEN, WSOL_TOKEN, WSTETH_TOKEN } from "@/constants/tokens";
 import { chartFormatters, formatNum, formatPct, formatUSD } from "@/utils/format";
 import { Token } from "@/utils/types";
 import { useMemo } from "react";
 import useTokenData from "./useTokenData";
+import { MIN_ADV_SEASON } from "@/components/charts/AdvancedChart";
 
 type ChartType = "Pinto" | "Field" | "Silo" | "Tractor" | "Exchange" | "Inflow" | "Market";
 interface ChartSetupBase {
@@ -72,9 +73,9 @@ interface ChartSetupBase {
   shortTickFormatter: (value: number) => string;
   /**
    * Optinal extra required inputs when using this chart.
-   * START_SEASON: numeric entry for a season number
+   * SEASON: numeric entry for a season number
    */
-  inputOptions?: "SEASON";
+  inputOptions?: { type: "SEASON"; minSeason: number };
 }
 
 export type ChartSetup = ChartSetupBase & {
@@ -1099,7 +1100,7 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
     description: string;
     formatter: (v: number) => string;
     valueAxis?: string;
-    inputOptions?: "SEASON";
+    inputOptions?: { type: "SEASON"; minSeason: number };
   }) => {
     return {
       id,
@@ -1137,6 +1138,15 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       valueAxis: "ethPrice",
       formatter: usdFormatter,
     }),
+    marketEntry({
+      id: "marketPriceWsteth",
+      name: "wstETH Price",
+      icon: WSTETH_TOKEN[mainToken.chainId].logoURI,
+      tooltipTitle: "wstEth Price",
+      description: "wstEth Price",
+      valueAxis: "ethPrice",
+      formatter: usdFormatter,
+    }),
     marketEntry({
       id: "marketPriceCbbtc",
       name: "cbBTC Price",
@@ -1160,7 +1170,7 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       tooltipTitle: "Market: Cumulative Non-Pinto Value Change",
       description: "Change of non-Pinto liquidity USD value since a selectable starting season.",
       formatter: usdFormatter,
-      inputOptions: "SEASON",
+      inputOptions: { type: "SEASON", minSeason: MIN_ADV_SEASON },
     }),
     marketEntry({
       id: "marketCumulativeWethUsd",
@@ -1169,7 +1179,7 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       tooltipTitle: "Market: Cumulative WETH Value Change",
       description: "Change of WETH liquidity USD value since a selectable starting season.",
       formatter: usdFormatter,
-      inputOptions: "SEASON",
+      inputOptions: { type: "SEASON", minSeason: MIN_ADV_SEASON },
     }),
     marketEntry({
       id: "marketCumulativeCbethUsd",
@@ -1178,7 +1188,16 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       tooltipTitle: "Market: Cumulative cbETH Value Change",
       description: "Change of cbETH liquidity USD value since a selectable starting season.",
       formatter: usdFormatter,
-      inputOptions: "SEASON",
+      inputOptions: { type: "SEASON", minSeason: MIN_ADV_SEASON },
+    }),
+    marketEntry({
+      id: "marketCumulativeWstethUsd",
+      name: "Protocol Cumulative wstETH Value Change (USD)",
+      icon: WSTETH_TOKEN[mainToken.chainId].logoURI,
+      tooltipTitle: "Market: Cumulative wstETH Value Change",
+      description: "Change of wstETH liquidity USD value since a selectable starting season.",
+      formatter: usdFormatter,
+      inputOptions: { type: "SEASON", minSeason: 8000 }, // TODO(wsteth): set this to the wsteth deployment season + 1
     }),
     marketEntry({
       id: "marketCumulativeCbbtcUsd",
@@ -1187,7 +1206,7 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       tooltipTitle: "Market: Cumulative cbBTC Value Change",
       description: "Change of cbBTC liquidity USD value since a selectable starting season.",
       formatter: usdFormatter,
-      inputOptions: "SEASON",
+      inputOptions: { type: "SEASON", minSeason: MIN_ADV_SEASON },
     }),
     marketEntry({
       id: "marketCumulativeWsolUsd",
@@ -1196,7 +1215,7 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       tooltipTitle: "Market: Cumulative WSOL Value Change",
       description: "Change of WSOL liquidity USD value since a selectable starting season.",
       formatter: usdFormatter,
-      inputOptions: "SEASON",
+      inputOptions: { type: "SEASON", minSeason: MIN_ADV_SEASON },
     }),
     marketEntry({
       id: "marketSeasonalNonPintoUsd",
@@ -1222,6 +1241,14 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       description: "Change of cbETH liquidity USD value by season.",
       formatter: usdFormatter,
     }),
+    marketEntry({
+      id: "marketSeasonalWstethUsd",
+      name: "Protocol Seasonal wstETH Value Change (USD)",
+      icon: WSTETH_TOKEN[mainToken.chainId].logoURI,
+      tooltipTitle: "Market: Seasonal wstETH Value Change",
+      description: "Change of wstETH liquidity USD value by season.",
+      formatter: usdFormatter,
+    }),
     marketEntry({
       id: "marketSeasonalCbbtcUsd",
       name: "Protocol Seasonal cbBTC Value Change (USD)",
@@ -1245,7 +1272,7 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       tooltipTitle: "Market: Cumulative Non-Pinto Value Change",
       description: "Percentage change of Non-Pinto liquidity value since a selectable starting season.",
       formatter: chartFormatters.percentFormatter(4),
-      inputOptions: "SEASON",
+      inputOptions: { type: "SEASON", minSeason: MIN_ADV_SEASON },
     }),
     marketEntry({
       id: "marketCumulativeWethPercent",
@@ -1254,7 +1281,7 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       tooltipTitle: "Market: Cumulative WETH Value Change",
       description: "Percentage change of WETH liquidity value since a selectable starting season.",
       formatter: chartFormatters.percentFormatter(4),
-      inputOptions: "SEASON",
+      inputOptions: { type: "SEASON", minSeason: MIN_ADV_SEASON },
     }),
     marketEntry({
       id: "marketCumulativeCbethPercent",
@@ -1263,7 +1290,16 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       tooltipTitle: "Market: Cumulative cbETH Value Change",
       description: "Percentage change of cbETH liquidity value since a selectable starting season.",
       formatter: chartFormatters.percentFormatter(4),
-      inputOptions: "SEASON",
+      inputOptions: { type: "SEASON", minSeason: MIN_ADV_SEASON },
+    }),
+    marketEntry({
+      id: "marketCumulativeWstethPercent",
+      name: "Protocol Cumulative wstETH Value Change (%)",
+      icon: WSTETH_TOKEN[mainToken.chainId].logoURI,
+      tooltipTitle: "Market: Cumulative wstETH Value Change",
+      description: "Percentage change of wstETH liquidity value since a selectable starting season.",
+      formatter: chartFormatters.percentFormatter(4),
+      inputOptions: { type: "SEASON", minSeason: 8000 }, // TODO(wsteth): set this to the wsteth deployment season + 1
     }),
     marketEntry({
       id: "marketCumulativeCbbtcPercent",
@@ -1272,7 +1308,7 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       tooltipTitle: "Market: Cumulative cbBTC Value Change",
       description: "Percentage change of cbBTC liquidity value since a selectable starting season.",
       formatter: chartFormatters.percentFormatter(4),
-      inputOptions: "SEASON",
+      inputOptions: { type: "SEASON", minSeason: MIN_ADV_SEASON },
     }),
     marketEntry({
       id: "marketCumulativeWsolPercent",
@@ -1281,7 +1317,7 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       tooltipTitle: "Market: Cumulative WSOL Value Change",
       description: "Percentage change of WSOL liquidity value since a selectable starting season.",
       formatter: chartFormatters.percentFormatter(4),
-      inputOptions: "SEASON",
+      inputOptions: { type: "SEASON", minSeason: MIN_ADV_SEASON },
     }),
     marketEntry({
       id: "marketSeasonalNonPintoPercent",
@@ -1307,6 +1343,14 @@ const createMarketCharts = (mainToken: Token): ChartSetupBase[] => {
       description: "Percentage change of cbETH liquidity value by season.",
       formatter: chartFormatters.percentFormatter(4),
     }),
+    marketEntry({
+      id: "marketSeasonalWstethPercent",
+      name: "Protocol Seasonal wstETH Value Change (%)",
+      icon: WSTETH_TOKEN[mainToken.chainId].logoURI,
+      tooltipTitle: "Market: Seasonal wstETH Value Change",
+      description: "Percentage change of wstETH liquidity value by season.",
+      formatter: chartFormatters.percentFormatter(4),
+    }),
     marketEntry({
       id: "marketSeasonalCbbtcPercent",
       name: "Protocol Seasonal cbBTC Value Change (%)",
diff --git a/src/state/usePriceData.ts b/src/state/usePriceData.ts
index c0b1267e1..12a6e5bb5 100644
--- a/src/state/usePriceData.ts
+++ b/src/state/usePriceData.ts
@@ -70,7 +70,7 @@ const useSelectWellPriceData = () => {
 
       const pool = tokenMap[getTokenIndex(data.pool)];
       const tokens = data.tokens.map((token) => tokenMap[getTokenIndex(token)]);
-      const balances = tokens.map((token, index) => TokenValue.fromBigInt(data.balances[index], token.decimals));
+      const balances = tokens.map((token, index) => TokenValue.fromBigInt(data.balances[index], token?.decimals ?? 0));
 
       return {
         pool,
@@ -247,7 +247,7 @@ export function usePriceData() {
       const combined = [...price.ps, ...deWhitelistedWellsQuery.data];
       for (const wellPriceData of combined) {
         const poolData = selectWellPriceData(wellPriceData);
-        if (poolData) {
+        if (poolData && poolData.pool) {
           pools.push(poolData);
         }
       }
diff --git a/src/state/useSeasonsData.ts b/src/state/useSeasonsData.ts
index 7841ed50a..78c0a60a5 100644
--- a/src/state/useSeasonsData.ts
+++ b/src/state/useSeasonsData.ts
@@ -130,26 +130,31 @@ export interface SeasonsTableData {
   inflowFieldDeltaVolume: number;
   marketPriceWeth: number;
   marketPriceCbeth: number;
+  marketPriceWsteth: number;
   marketPriceCbbtc: number;
   marketPriceWsol: number;
   marketCumulativeNonPintoUsd: number;
   marketCumulativeWethUsd: number;
   marketCumulativeCbethUsd: number;
+  marketCumulativeWstethUsd: number;
   marketCumulativeCbbtcUsd: number;
   marketCumulativeWsolUsd: number;
   marketSeasonalNonPintoUsd: number;
   marketSeasonalWethUsd: number;
   marketSeasonalCbethUsd: number;
+  marketSeasonalWstethUsd: number;
   marketSeasonalCbbtcUsd: number;
   marketSeasonalWsolUsd: number;
   marketCumulativeNonPintoPercent: number;
   marketCumulativeWethPercent: number;
   marketCumulativeCbethPercent: number;
+  marketCumulativeWstethPercent: number;
   marketCumulativeCbbtcPercent: number;
   marketCumulativeWsolPercent: number;
   marketSeasonalNonPintoPercent: number;
   marketSeasonalWethPercent: number;
   marketSeasonalCbethPercent: number;
+  marketSeasonalWstethPercent: number;
   marketSeasonalCbbtcPercent: number;
   marketSeasonalWsolPercent: number;
 }
@@ -158,6 +163,7 @@ const marketStartSeasonToSymbolMappingUsd = {
   marketCumulativeNonPintoUsd: "NET",
   marketCumulativeWethUsd: "WETH",
   marketCumulativeCbethUsd: "cbETH",
+  marketCumulativeWstethUsd: "wstETH",
   marketCumulativeCbbtcUsd: "cbBTC",
   marketCumulativeWsolUsd: "WSOL",
 };
@@ -166,6 +172,7 @@ const marketStartSeasonToSymbolMappingPercent = {
   marketCumulativeNonPintoPercent: "NET",
   marketCumulativeWethPercent: "WETH",
   marketCumulativeCbethPercent: "cbETH",
+  marketCumulativeWstethPercent: "wstETH",
   marketCumulativeCbbtcPercent: "cbBTC",
   marketCumulativeWsolPercent: "WSOL",
 };
@@ -340,15 +347,15 @@ export default function useSeasonsData(
     for (const property in marketPerformanceStartSeasons) {
       const season = marketPerformanceStartSeasons[property];
       if (property in marketStartSeasonToSymbolMappingUsd) {
-        startSeasonsUsd[marketStartSeasonToSymbolMappingUsd[property]] = season - syncOffset;
+        startSeasonsUsd[marketStartSeasonToSymbolMappingUsd[property]] = season;
       } else if (property in marketStartSeasonToSymbolMappingPercent) {
-        startSeasonsPercent[marketStartSeasonToSymbolMappingPercent[property]] = season - syncOffset;
+        startSeasonsPercent[marketStartSeasonToSymbolMappingPercent[property]] = season;
       } else {
         console.warn(`Unknown property provided: ${property}`);
       }
     }
     return [startSeasonsUsd, startSeasonsPercent];
-  }, [marketPerformanceStartSeasons, syncOffset]);
+  }, [marketPerformanceStartSeasons]);
 
   const marketPrices = useMarketPerformanceCalc(useMarketPerformanceQuery.data, SMPChartType.TOKEN_PRICES);
   const marketUsdCumulative = useMarketPerformanceCalc(
@@ -395,13 +402,13 @@ export default function useSeasonsData(
       apy24h?.length || 0,
       tractorSnapshots.length,
       inflowSnapshots.length,
-      marketPerformanceResults.length - syncOffset,
+      marketPerformanceResults.length,
     );
 
     // Special length handling for market performance data which has variable starting seasons
     if (Object.keys(marketPerformanceStartSeasons).length > 0) {
       const minPerfStartSeason = Math.min(...Object.values(startSeasonsUsd), ...Object.values(startSeasonsPercent));
-      maxLength = Math.max(maxLength, toSeason - minPerfStartSeason + 1 - syncOffset);
+      maxLength = Math.max(maxLength, toSeason - minPerfStartSeason + 1);
     }
 
     const transformedData: SeasonsTableData[] = [];
@@ -440,7 +447,8 @@ export default function useSeasonsData(
           18,
         ).toNumber();
         allData.deltaBeans = TokenValue.fromBlockchain(currStalkSeasons.deltaBeans, tokenData.mainToken.decimals);
-        allData.price = TokenValue.fromHuman(currStalkSeasons.price, 4);
+        // No sync offset needed for price
+        allData.price = TokenValue.fromHuman(stalkResults.seasons[idx].price, 4);
         allData.raining = currStalkSeasons.raining;
         allData.rewardBeans = TokenValue.fromHuman(currStalkSeasons.rewardBeans, 2);
         allData.deltaPodDemand = TokenValue.fromBlockchain(currFieldHourlySnapshots.deltaPodDemand, 18);
@@ -503,14 +511,17 @@ export default function useSeasonsData(
       if (beanData && idx + syncOffset < countSubgraphSeasons) {
         const beanHourly = beanResults[idx + syncOffset].beanHourlySnapshot;
         allData.crosses = beanHourly.crosses;
-        allData.marketCap = Number(beanHourly.marketCap);
         allData.supply = TokenValue.fromBlockchain(beanHourly.supply, tokenData.mainToken.decimals);
         allData.supplyInPegLP = TokenValue.fromBlockchain(beanHourly.supply, tokenData.mainToken.decimals);
-        allData.instDeltaB = TokenValue.fromHuman(beanHourly.instDeltaB, tokenData.mainToken.decimals);
-        allData.instPrice = TokenValue.fromHuman(beanHourly.instPrice, tokenData.mainToken.decimals);
-        allData.l2sr = TokenValue.fromHuman(beanHourly.l2sr * 100, 2);
-        allData.twaDeltaB = TokenValue.fromHuman(beanHourly.twaDeltaB, 2);
-        allData.twaPrice = TokenValue.fromHuman(beanHourly.twaPrice, 4);
+
+        // No sync offset needed for some of these
+        const beanHourlyNoSync = beanResults[idx].beanHourlySnapshot;
+        allData.marketCap = Number(beanHourlyNoSync.marketCap);
+        allData.l2sr = TokenValue.fromHuman(beanHourlyNoSync.l2sr * 100, 2);
+        allData.instPrice = TokenValue.fromHuman(beanHourlyNoSync.instPrice, tokenData.mainToken.decimals);
+        allData.instDeltaB = TokenValue.fromHuman(beanHourlyNoSync.instDeltaB, tokenData.mainToken.decimals);
+        allData.twaDeltaB = TokenValue.fromHuman(beanHourlyNoSync.twaDeltaB, 2);
+        allData.twaPrice = TokenValue.fromHuman(beanHourlyNoSync.twaPrice, 4);
 
         if (!allData.season) {
           const season = beanResults[idx].season;
@@ -638,51 +649,52 @@ export default function useSeasonsData(
         }
       }
 
-      if (marketPerformanceData && idx + syncOffset < countSubgraphSeasons) {
-        allData.marketPriceWeth = marketPrices.WETH[marketPrices.WETH.length - 1 - idx - syncOffset].value;
-        allData.marketPriceCbeth = marketPrices.cbETH[marketPrices.cbETH.length - 1 - idx - syncOffset].value;
-        allData.marketPriceCbbtc = marketPrices.cbBTC[marketPrices.cbBTC.length - 1 - idx - syncOffset].value;
-        allData.marketPriceWsol = marketPrices.WSOL[marketPrices.WSOL.length - 1 - idx - syncOffset].value;
+      if (marketPerformanceData && idx < countSubgraphSeasons) {
+        allData.marketPriceWeth = marketPrices.WETH[marketPrices.WETH.length - 1 - idx].value;
+        allData.marketPriceCbeth = marketPrices.cbETH[marketPrices.cbETH.length - 1 - idx].value;
+        allData.marketPriceWsteth = marketPrices.wstETH?.[marketPrices.wstETH.length - 1 - idx]?.value;
+        allData.marketPriceCbbtc = marketPrices.cbBTC[marketPrices.cbBTC.length - 1 - idx].value;
+        allData.marketPriceWsol = marketPrices.WSOL[marketPrices.WSOL.length - 1 - idx].value;
         allData.marketCumulativeNonPintoUsd =
-          marketUsdCumulative.NET?.[marketUsdCumulative.NET.length - 1 - idx - syncOffset]?.value;
-        allData.marketCumulativeWethUsd =
-          marketUsdCumulative.WETH?.[marketUsdCumulative.WETH.length - 1 - idx - syncOffset]?.value;
+          marketUsdCumulative.NET?.[marketUsdCumulative.NET.length - 1 - idx]?.value;
+        allData.marketCumulativeWethUsd = marketUsdCumulative.WETH?.[marketUsdCumulative.WETH.length - 1 - idx]?.value;
         allData.marketCumulativeCbethUsd =
-          marketUsdCumulative.cbETH?.[marketUsdCumulative.cbETH.length - 1 - idx - syncOffset]?.value;
+          marketUsdCumulative.cbETH?.[marketUsdCumulative.cbETH.length - 1 - idx]?.value;
+        allData.marketCumulativeWstethUsd =
+          marketUsdCumulative.wstETH?.[marketUsdCumulative.wstETH.length - 1 - idx]?.value;
         allData.marketCumulativeCbbtcUsd =
-          marketUsdCumulative.cbBTC?.[marketUsdCumulative.cbBTC.length - 1 - idx - syncOffset]?.value;
-        allData.marketCumulativeWsolUsd =
-          marketUsdCumulative.WSOL?.[marketUsdCumulative.WSOL.length - 1 - idx - syncOffset]?.value;
-        allData.marketSeasonalNonPintoUsd =
-          marketUsdSeasonal.NET[marketUsdSeasonal.NET.length - 1 - idx - syncOffset]?.value;
-        allData.marketSeasonalWethUsd =
-          marketUsdSeasonal.WETH[marketUsdSeasonal.WETH.length - 1 - idx - syncOffset]?.value;
-        allData.marketSeasonalCbethUsd =
-          marketUsdSeasonal.cbETH[marketUsdSeasonal.cbETH.length - 1 - idx - syncOffset]?.value;
-        allData.marketSeasonalCbbtcUsd =
-          marketUsdSeasonal.cbBTC[marketUsdSeasonal.cbBTC.length - 1 - idx - syncOffset]?.value;
-        allData.marketSeasonalWsolUsd =
-          marketUsdSeasonal.WSOL[marketUsdSeasonal.WSOL.length - 1 - idx - syncOffset]?.value;
+          marketUsdCumulative.cbBTC?.[marketUsdCumulative.cbBTC.length - 1 - idx]?.value;
+        allData.marketCumulativeWsolUsd = marketUsdCumulative.WSOL?.[marketUsdCumulative.WSOL.length - 1 - idx]?.value;
+        allData.marketSeasonalNonPintoUsd = marketUsdSeasonal.NET[marketUsdSeasonal.NET.length - 1 - idx]?.value;
+        allData.marketSeasonalWethUsd = marketUsdSeasonal.WETH[marketUsdSeasonal.WETH.length - 1 - idx]?.value;
+        allData.marketSeasonalCbethUsd = marketUsdSeasonal.cbETH[marketUsdSeasonal.cbETH.length - 1 - idx]?.value;
+        allData.marketSeasonalWstethUsd = marketUsdSeasonal.wstETH?.[marketUsdSeasonal.wstETH.length - 1 - idx]?.value;
+        allData.marketSeasonalCbbtcUsd = marketUsdSeasonal.cbBTC[marketUsdSeasonal.cbBTC.length - 1 - idx]?.value;
+        allData.marketSeasonalWsolUsd = marketUsdSeasonal.WSOL[marketUsdSeasonal.WSOL.length - 1 - idx]?.value;
         allData.marketCumulativeNonPintoPercent =
-          marketPercentCumulative.NET?.[marketPercentCumulative.NET.length - 1 - idx - syncOffset]?.value;
+          marketPercentCumulative.NET?.[marketPercentCumulative.NET.length - 1 - idx]?.value;
         allData.marketCumulativeWethPercent =
-          marketPercentCumulative.WETH?.[marketPercentCumulative.WETH.length - 1 - idx - syncOffset]?.value;
+          marketPercentCumulative.WETH?.[marketPercentCumulative.WETH.length - 1 - idx]?.value;
         allData.marketCumulativeCbethPercent =
-          marketPercentCumulative.cbETH?.[marketPercentCumulative.cbETH.length - 1 - idx - syncOffset]?.value;
+          marketPercentCumulative.cbETH?.[marketPercentCumulative.cbETH.length - 1 - idx]?.value;
+        allData.marketCumulativeWstethPercent =
+          marketPercentCumulative.wstETH?.[marketPercentCumulative.wstETH.length - 1 - idx]?.value;
         allData.marketCumulativeCbbtcPercent =
-          marketPercentCumulative.cbBTC?.[marketPercentCumulative.cbBTC.length - 1 - idx - syncOffset]?.value;
+          marketPercentCumulative.cbBTC?.[marketPercentCumulative.cbBTC.length - 1 - idx]?.value;
         allData.marketCumulativeWsolPercent =
-          marketPercentCumulative.WSOL?.[marketPercentCumulative.WSOL.length - 1 - idx - syncOffset]?.value;
+          marketPercentCumulative.WSOL?.[marketPercentCumulative.WSOL.length - 1 - idx]?.value;
         allData.marketSeasonalNonPintoPercent =
-          marketPercentSeasonal.NET[marketPercentSeasonal.NET.length - 1 - idx - syncOffset]?.value;
+          marketPercentSeasonal.NET[marketPercentSeasonal.NET.length - 1 - idx]?.value;
         allData.marketSeasonalWethPercent =
-          marketPercentSeasonal.WETH[marketPercentSeasonal.WETH.length - 1 - idx - syncOffset]?.value;
+          marketPercentSeasonal.WETH[marketPercentSeasonal.WETH.length - 1 - idx]?.value;
         allData.marketSeasonalCbethPercent =
-          marketPercentSeasonal.cbETH[marketPercentSeasonal.cbETH.length - 1 - idx - syncOffset]?.value;
+          marketPercentSeasonal.cbETH[marketPercentSeasonal.cbETH.length - 1 - idx]?.value;
+        allData.marketSeasonalWstethPercent =
+          marketPercentSeasonal.wstETH?.[marketPercentSeasonal.wstETH.length - 1 - idx]?.value;
         allData.marketSeasonalCbbtcPercent =
-          marketPercentSeasonal.cbBTC[marketPercentSeasonal.cbBTC.length - 1 - idx - syncOffset]?.value;
+          marketPercentSeasonal.cbBTC[marketPercentSeasonal.cbBTC.length - 1 - idx]?.value;
         allData.marketSeasonalWsolPercent =
-          marketPercentSeasonal.WSOL[marketPercentSeasonal.WSOL.length - 1 - idx - syncOffset]?.value;
+          marketPercentSeasonal.WSOL[marketPercentSeasonal.WSOL.length - 1 - idx]?.value;
 
         if (!allData.season) {
           const season = marketPerformanceResults[marketPerformanceResults.length - 1 - idx].season;
diff --git a/src/state/useTokenData.ts b/src/state/useTokenData.ts
index cbf94bd6f..b2b24fc97 100644
--- a/src/state/useTokenData.ts
+++ b/src/state/useTokenData.ts
@@ -1,6 +1,7 @@
 import { LP_TOKENS, MAIN_TOKEN, NATIVE_TOKEN, S_MAIN_TOKEN, WETH_TOKEN, tokens } from "@/constants/tokens";
 import { useChainConstant, useResolvedChainId } from "@/utils/chain";
-import { Token } from "@/utils/types";
+import { isLPToken } from "@/utils/token";
+import { LPToken, Token } from "@/utils/types";
 import { useMemo } from "react";
 
 export function useWhitelistedTokens() {
@@ -35,19 +36,19 @@ export default function useTokenData() {
   const wrappedNativeToken = useChainConstant(WETH_TOKEN);
 
   return useMemo(() => {
-    const lpTokens: Token[] = [];
+    const lpTokens: LPToken[] = [];
     const preferredTokens: Token[] = [];
     const whitelistedTokens: Token[] = [];
     const deWhitelistedTokens: Token[] = [];
 
-    const siloWrappedToken3p = tokens[chainId].find((token) => token.is3PSiloWrapped) as Token;
+    const siloWrappedToken3p = tokens[chainId].find((token) => token.is3PSiloWrapped);
 
     if (!siloWrappedToken3p) {
       throw new Error("3p wrapped native token not found");
     }
 
     for (const token of tokens[chainId]) {
-      if (token.isLP) {
+      if (isLPToken(token)) {
         lpTokens.push(token);
       }
       if (!token.isNative && !token.isLP) {
diff --git a/src/utils/token.ts b/src/utils/token.ts
index 5f563b3e9..afb0d9ee0 100644
--- a/src/utils/token.ts
+++ b/src/utils/token.ts
@@ -3,7 +3,7 @@ import { PINTO, tokens } from "@/constants/tokens";
 import { Address } from "viem";
 import { resolveChainId } from "./chain";
 import { stringEq } from "./string";
-import { AddressMap, InternalToken, SiloTokenData, Token, TokenDepositData } from "./types";
+import { AddressMap, InternalToken, LPToken, SiloTokenData, Token, TokenDepositData } from "./types";
 import { ChainLookup } from "./types.generic";
 import { exists } from "./utils";
 
@@ -47,6 +47,10 @@ export const tokensEqual = (a: TokenIsh | undefined | null, b: TokenIsh | undefi
   return stringEq(a.address, b.address) && stringEq(a.symbol, b.symbol);
 };
 
+export const isLPToken = (token: Token): token is LPToken => {
+  return !!token.tokens && !!token.tokenIndicies && !!token.isLP;
+};
+
 /**
  * Sort tokens for tables, with configurable sorting modes:
  *
diff --git a/src/utils/types.ts b/src/utils/types.ts
index 8e65bcec4..5b9836481 100644
--- a/src/utils/types.ts
+++ b/src/utils/types.ts
@@ -3,6 +3,7 @@ import { SeasonalChartData } from "@/components/charts/SeasonalChart";
 import { PlotSource } from "@/generated/gql/pintostalk/graphql";
 import { ProtocolIntegration } from "@/state/integrations/types";
 import { APYWindow } from "@/state/seasonal/queries/useSeasonalAPY";
+import { Prettify } from "@/utils/types.generic";
 import { QueryKey, UseQueryOptions } from "@tanstack/react-query";
 import { DateTime } from "luxon";
 import { ReactNode } from "react";
@@ -20,6 +21,16 @@ export enum FarmToMode {
   INTERNAL = "1",
 }
 
+interface LPIndicies {
+  main: number;
+  pair: number;
+}
+
+interface LPTokenIsh {
+  tokens: Address[];
+  tokenIndicies: LPIndicies;
+}
+
 export interface Token {
   name: string;
   symbol: string;
@@ -77,8 +88,17 @@ export interface Token {
    * Description of the token (If Applicable).
    */
   description?: string;
+  /**
+   * The Token indexes of the main & pair token for LPs
+   */
+  tokenIndicies?: {
+    main: number;
+    pair: number;
+  };
 }
 
+export type LPToken = Prettify<Omit<Token, "tokens" | "tokenIndicies"> & LPTokenIsh & { isLP: true }>;
+
 export interface Token3PIntegration extends Token {
   integration: ProtocolIntegration;
 }