diff --git a/app/src/components/common/RowItem/index.tsx b/app/src/components/common/RowItem/index.tsx
index f74a4d6f..17de8fe2 100644
--- a/app/src/components/common/RowItem/index.tsx
+++ b/app/src/components/common/RowItem/index.tsx
@@ -7,15 +7,22 @@ type Props = {
   label: string | React.ReactNode
   value: string | React.ReactNode
   valueColor?: TextColor
+  variant?: 'small' | 'body'
 } & MarginProps &
   LayoutProps
 
-export default function RowItem({ label, value, valueColor = 'text', ...styleProps }: Props) {
+export default function RowItem({ label, value, variant, valueColor = 'text', ...styleProps }: Props) {
   return (
     <Flex justifyContent="space-between" alignItems="center" {...styleProps}>
-      {typeof label === 'string' ? <Text color="secondaryText">{label}</Text> : label}
+      {typeof label === 'string' ? (
+        <Text variant={variant} color="secondaryText">
+          {label}
+        </Text>
+      ) : (
+        label
+      )}
       {typeof value === 'string' ? (
-        <Text textAlign="right" color={valueColor}>
+        <Text variant={variant} textAlign="right" color={valueColor}>
           {value}
         </Text>
       ) : (
diff --git a/app/src/components/rewards/TradingFeeRebateTable/index.tsx b/app/src/components/rewards/TradingFeeRebateTable/index.tsx
deleted file mode 100644
index c40645c7..00000000
--- a/app/src/components/rewards/TradingFeeRebateTable/index.tsx
+++ /dev/null
@@ -1,46 +0,0 @@
-import Flex from '@lyra/ui/components/Flex'
-import Text from '@lyra/ui/components/Text'
-import { LayoutProps, MarginProps } from '@lyra/ui/types'
-import formatNumber from '@lyra/ui/utils/formatNumber'
-import formatPercentage from '@lyra/ui/utils/formatPercentage'
-import { GlobalRewardEpochTradingFeeRebateTier } from '@lyrafinance/lyra-js'
-import React from 'react'
-
-import RowItem from '../../common/RowItem'
-
-type Props = {
-  feeRebateTiers: GlobalRewardEpochTradingFeeRebateTier[]
-  effectiveRebate?: number
-} & MarginProps &
-  LayoutProps
-
-export function TradingFeeRebateTable({ effectiveRebate, feeRebateTiers, ...styleProps }: Props) {
-  return (
-    <Flex flexDirection="column">
-      <RowItem
-        mb={2}
-        label={<Text color="secondaryText">Staked LYRA</Text>}
-        value={<Text color="secondaryText">Rebate</Text>}
-      />
-      <Flex flexDirection="column" {...styleProps}>
-        {feeRebateTiers.map(feeRebateTier => (
-          <RowItem
-            my={2}
-            width="100%"
-            key={feeRebateTier.stakedLyraCutoff}
-            label={
-              <Text color={effectiveRebate === feeRebateTier.feeRebate ? 'primaryText' : 'text'}>
-                {formatNumber(feeRebateTier.stakedLyraCutoff)}
-              </Text>
-            }
-            value={
-              <Text color={effectiveRebate === feeRebateTier.feeRebate ? 'primaryText' : 'text'}>
-                {formatPercentage(feeRebateTier.feeRebate, true)}
-              </Text>
-            }
-          />
-        ))}
-      </Flex>
-    </Flex>
-  )
-}
diff --git a/app/src/constants/ignore.ts b/app/src/constants/ignore.ts
deleted file mode 100644
index a210c96f..00000000
--- a/app/src/constants/ignore.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { Chain } from '@lyrafinance/lyra-js'
-
-import filterNulls from '../utils/filterNulls'
-
-export type IgnoreStrike = {
-  marketName: string
-  strikeId: number
-  chain: Chain
-}
-
-export type IgnoreVault = {
-  marketName: string
-  chain: Chain
-}
-
-export type IgnoreMarket = {
-  marketName: string
-  chain: Chain
-}
-
-export const IGNORE_STRIKE_LIST: IgnoreStrike[] = []
-
-export const IGNORE_VAULTS_LIST: IgnoreVault[] = filterNulls([
-  {
-    marketName: 'sSOL-sUSD',
-    chain: Chain.Optimism,
-  },
-])
-
-export const IGNORE_MARKETS_LIST: IgnoreMarket[] = filterNulls([
-  {
-    marketName: 'sSOL-sUSD',
-    chain: Chain.Optimism,
-  },
-])
diff --git a/app/src/constants/layout.ts b/app/src/constants/layout.ts
index b9bd4353..cc72f71b 100644
--- a/app/src/constants/layout.ts
+++ b/app/src/constants/layout.ts
@@ -5,7 +5,7 @@ export const MOBILE_HEADER_HEIGHT = 42
 export const PAGE_WIDTH = 1300
 export const PAGE_FULL_WIDTH = 1800
 
-export const HEADER_CARD_HEIGHT = 206
+export const HEADER_CARD_HEIGHT = 200
 
 export const VAULTS_CHART_HEIGHT = [120, 250]
 export const VAULTS_INDEX_CHART_HEIGHT = [120, 250]
diff --git a/app/src/containers/common/TotalSupplyHeaderCard/index.tsx b/app/src/containers/common/TotalSupplyHeaderCard/index.tsx
index 23ff79d7..4929b704 100644
--- a/app/src/containers/common/TotalSupplyHeaderCard/index.tsx
+++ b/app/src/containers/common/TotalSupplyHeaderCard/index.tsx
@@ -19,16 +19,15 @@ const TotalSupplyHeaderCard = withSuspense(() => {
   const circulatingSupplyPct = supply ? supply.totalCirculatingSupply / supply.totalSupply : 0
   return supply ? (
     <Card variant="outline" width="100%" height="100%">
-      <CardBody>
-        <Text variant="cardHeading" mb={10}>
-          Circulating Supply
-        </Text>
-        <Flex>
+      <CardBody height="100%">
+        <Text variant="cardHeading">Circulating Supply</Text>
+        <Flex mt="auto">
           <Tooltip
             showInfoIcon
             tooltip={
               <Box width={200}>
                 <RowItem
+                  variant="small"
                   label="Mainnet"
                   value={`${formatTruncatedNumber(supply.mainnetCirculatingSupply)} (${formatPercentage(
                     supply.mainnetCirculatingSupply / supply.totalSupply,
@@ -36,6 +35,7 @@ const TotalSupplyHeaderCard = withSuspense(() => {
                   )})`}
                 />
                 <RowItem
+                  variant="small"
                   label="Optimism"
                   value={`${formatTruncatedNumber(supply.optimismCirculatingSupply)} (${formatPercentage(
                     supply.optimismCirculatingSupply / supply.totalSupply,
@@ -43,6 +43,7 @@ const TotalSupplyHeaderCard = withSuspense(() => {
                   )})`}
                 />
                 <RowItem
+                  variant="small"
                   label="Arbitrum"
                   value={`${formatTruncatedNumber(supply.arbitrumCirculatingSupply)} (${formatPercentage(
                     supply.arbitrumCirculatingSupply / supply.totalSupply,
@@ -52,14 +53,14 @@ const TotalSupplyHeaderCard = withSuspense(() => {
               </Box>
             }
           >
-            <Text>{formatNumber(supply.totalCirculatingSupply)}</Text>
+            <Text variant="small">{formatNumber(supply.totalCirculatingSupply)}</Text>
           </Tooltip>
-          <Text color="secondaryText" ml="auto">
+          <Text variant="small" color="secondaryText" ml="auto">
             {formatNumber(supply.totalSupply)}
           </Text>
         </Flex>
         <LinearProgress my={2} color="primaryText" progress={supply.totalCirculatingSupply / supply.totalSupply} />
-        <Text>{formatPercentage(circulatingSupplyPct, true)}</Text>
+        <Text variant="small">{formatPercentage(circulatingSupplyPct, true)}</Text>
       </CardBody>
     </Card>
   ) : null
diff --git a/app/src/containers/earn/EarnVaultsHeaderCard/index.tsx b/app/src/containers/earn/EarnVaultsHeaderCard/index.tsx
index fa7906ce..59af1c7a 100644
--- a/app/src/containers/earn/EarnVaultsHeaderCard/index.tsx
+++ b/app/src/containers/earn/EarnVaultsHeaderCard/index.tsx
@@ -28,13 +28,10 @@ const EarnVaultsHeaderCard = ({ latestAccountRewardEpoch, totalClaimableRewards,
 
   return (
     <Card variant="outline" width="100%" height="100%">
-      <CardBody height="100%">
-        <Text variant="cardHeading" mb={4}>
-          Vault Rewards
-        </Text>
-        <LabelItem mt="auto" label="Claimable" value={claimableAmounts.join(', ')} />
+      <CardBody height="100%" justifyContent="space-between">
+        <Text variant="cardHeading">Vault Rewards</Text>
+        <LabelItem valueColor="primaryText" label="Claimable" value={claimableAmounts.join(', ')} />
         <RewardsClaimModalButton
-          mt="auto"
           accountRewardEpoch={latestAccountRewardEpoch}
           isDisabled={!hasClaimableAmounts}
           onClick={onClickClaim}
diff --git a/app/src/containers/earn_index/RewardsVaultsSection/RewardsVaultsMarketCard.tsx b/app/src/containers/earn_index/RewardsVaultsSection/RewardsVaultsMarketCard.tsx
index 11b7a2d5..d42301cd 100644
--- a/app/src/containers/earn_index/RewardsVaultsSection/RewardsVaultsMarketCard.tsx
+++ b/app/src/containers/earn_index/RewardsVaultsSection/RewardsVaultsMarketCard.tsx
@@ -54,11 +54,7 @@ const RewardsVaultsMarketCard = ({ vault }: Props) => {
 
   const liquidityTokenBalanceValue = vault.liquidityTokenBalanceValue
 
-  if (!firstRewardToken || !vaultRewards) {
-    return null
-  }
-
-  const isBoosted = (accountRewardEpoch?.stakedLyraBalance ?? 0) > 0
+  const isBoosted = vault.apyMultiplier > 1.01
 
   return (
     <Card
@@ -85,11 +81,10 @@ const RewardsVaultsMarketCard = ({ vault }: Props) => {
                 {formatTokenName(market.baseToken)} Vault · {getNetworkDisplayName(market.lyra.network)}
               </Text>
               {vault.isDeprecated ? (
-                <Text variant="small" ml={2}>
-                  [Deprecated]
+                <Text variant="small" ml={2} color="secondaryText">
+                  Deprecated
                 </Text>
-              ) : null}
-              {vault.market.lyra.version === Version.Newport && vault.market.lyra.network === Network.Optimism ? (
+              ) : vault.market.lyra.version === Version.Newport && vault.market.lyra.network === Network.Optimism ? (
                 <Text ml={2} variant="small" color="primaryText">
                   New
                 </Text>
@@ -136,11 +131,15 @@ const RewardsVaultsMarketCard = ({ vault }: Props) => {
                 <Text mr={2} color="secondaryText">
                   Rewards
                 </Text>
-                <RewardTokenAmounts
-                  color={vaultRewards.amount > 0.001 ? 'primaryText' : 'text'}
-                  tokenAmounts={[vaultRewards]}
-                  hideTokenImages={true}
-                />
+                {vaultRewards ? (
+                  <RewardTokenAmounts
+                    color={vaultRewards.amount > 0.001 ? 'primaryText' : 'text'}
+                    tokenAmounts={[vaultRewards]}
+                    hideTokenImages={true}
+                  />
+                ) : (
+                  <Text color="secondaryText">-</Text>
+                )}
               </Flex>
             </>
           ) : null}
diff --git a/app/src/containers/trade/TradeForm/TradeFormButton.tsx b/app/src/containers/trade/TradeForm/TradeFormButton.tsx
index 28ffdc55..018a44a2 100644
--- a/app/src/containers/trade/TradeForm/TradeFormButton.tsx
+++ b/app/src/containers/trade/TradeForm/TradeFormButton.tsx
@@ -181,7 +181,7 @@ const TradeFormButton = ({ onTrade, trade, ...styleProps }: Props) => {
           const maxCostNum = fromBigNumber(maxCost)
           const minCostNum = fromBigNumber(minCost)
           const totalCostNum = fromBigNumber(totalCost)
-          console.log({
+          console.debug({
             blockTimestamp: market.block.timestamp,
             timeSinceBlock: Date.now() / 1000 - market.block.timestamp,
             maxCostNum,
diff --git a/app/src/containers/vaults/VaultsHistoryCard/index.tsx b/app/src/containers/vaults/VaultsHistoryCard/index.tsx
index 02b15510..dca19499 100644
--- a/app/src/containers/vaults/VaultsHistoryCard/index.tsx
+++ b/app/src/containers/vaults/VaultsHistoryCard/index.tsx
@@ -2,7 +2,7 @@ import Box from '@lyra/ui/components/Box'
 import ToggleButton from '@lyra/ui/components/Button/ToggleButton'
 import ToggleButtonItem from '@lyra/ui/components/Button/ToggleButtonItem'
 import Card from '@lyra/ui/components/Card'
-import CardBody from '@lyra/ui/components/Card/CardBody'
+import CardSection from '@lyra/ui/components/Card/CardSection'
 import Flex from '@lyra/ui/components/Flex'
 import Text from '@lyra/ui/components/Text'
 import Countdown from '@lyra/ui/components/Text/CountdownText'
@@ -77,12 +77,12 @@ const VaultsHistoryCard = ({ vault, latestGlobalRewardEpoch, accountRewardEpochs
   const showDeposits = selectedItem === 'deposits'
   return (
     <Card>
-      <CardBody>
-        <Text mb={6} variant="cardHeading">
+      <CardSection noSpacing>
+        <Text variant="cardHeading" mb={6}>
           History
         </Text>
         <Flex>
-          <ToggleButton mt={4} mb={8}>
+          <ToggleButton>
             {VAULT_HISTORY_TABS.map(item => (
               <ToggleButtonItem
                 key={item.id}
@@ -90,12 +90,12 @@ const VaultsHistoryCard = ({ vault, latestGlobalRewardEpoch, accountRewardEpochs
                 label={item.label}
                 isSelected={selectedItem === item.id}
                 onSelect={id => setSelectedItem(id)}
-                width="100%"
-                textVariant="body"
               />
             ))}
           </ToggleButton>
         </Flex>
+      </CardSection>
+      <CardSection>
         {showRewards ? (
           account && accountEpochsSorted.length > 0 && !latestGlobalRewardEpoch.isDepositPeriod ? (
             <Box overflowX="scroll">
@@ -103,9 +103,6 @@ const VaultsHistoryCard = ({ vault, latestGlobalRewardEpoch, accountRewardEpochs
                 <Text minWidth={MIN_COL_WIDTH} color="secondaryText">
                   Ended
                 </Text>
-                <Text minWidth={MIN_COL_WIDTH} color="secondaryText">
-                  Your Liquidity
-                </Text>
                 <Text minWidth={MIN_COL_WIDTH} ml="auto" color="secondaryText" textAlign={isMobile ? 'left' : 'right'}>
                   Your Rewards
                 </Text>
@@ -123,13 +120,6 @@ const VaultsHistoryCard = ({ vault, latestGlobalRewardEpoch, accountRewardEpochs
                 return (
                   <Flex py={3} key={globalEpoch.id}>
                     <Text minWidth={MIN_COL_WIDTH}>{formatDate(globalEpoch.endTimestamp)}</Text>
-                    <Text minWidth={MIN_COL_WIDTH}>
-                      {formatBalance({
-                        balance: accountEpoch?.vaultTokenBalance(market.address) ?? 0,
-                        symbol: market.liquidityToken.symbol,
-                        decimals: market.liquidityToken.decimals,
-                      })}
-                    </Text>
                     <Box minWidth={MIN_COL_WIDTH} ml="auto" textAlign={isMobile ? 'left' : 'right'}>
                       <Text>{vaultRewards.map(t => formatBalance(t)).join(', ')}</Text>
                       {isLateDistribution ? (
@@ -137,7 +127,7 @@ const VaultsHistoryCard = ({ vault, latestGlobalRewardEpoch, accountRewardEpochs
                           Claiming delayed
                         </Text>
                       ) : isPendingDistribution ? (
-                        <Text variant="body" color="secondaryText">
+                        <Text variant="small" color="secondaryText">
                           Claimable in&nbsp;
                           <Countdown as="span" timestamp={globalEpoch.distributionTimestamp} />
                         </Text>
@@ -148,7 +138,9 @@ const VaultsHistoryCard = ({ vault, latestGlobalRewardEpoch, accountRewardEpochs
               })}
             </Box>
           ) : (
-            <Text color="secondaryText">No Rewards History</Text>
+            <Text variant="small" color="secondaryText">
+              No rewards history.
+            </Text>
           )
         ) : null}
         {showDeposits ? (
@@ -178,10 +170,12 @@ const VaultsHistoryCard = ({ vault, latestGlobalRewardEpoch, accountRewardEpochs
               })}
             </Box>
           ) : (
-            <Text color="secondaryText">No Deposit History</Text>
+            <Text variant="small" color="secondaryText">
+              No deposit history.
+            </Text>
           )
         ) : null}
-      </CardBody>
+      </CardSection>
     </Card>
   )
 }
diff --git a/app/src/containers/vaults/VaultsMarketDropdown/index.tsx b/app/src/containers/vaults/VaultsMarketDropdown/index.tsx
index 83829d79..cce97f86 100644
--- a/app/src/containers/vaults/VaultsMarketDropdown/index.tsx
+++ b/app/src/containers/vaults/VaultsMarketDropdown/index.tsx
@@ -1,7 +1,6 @@
 import DropdownButton from '@lyra/ui/components/Button/DropdownButton'
 import DropdownButtonListItem from '@lyra/ui/components/Button/DropdownButtonListItem'
 import { DropdownIconButtonElement } from '@lyra/ui/components/Button/DropdownIconButton'
-import Flex from '@lyra/ui/components/Flex'
 import Text from '@lyra/ui/components/Text'
 import React, { useCallback, useState } from 'react'
 
@@ -39,13 +38,15 @@ const VaultsMarketDropdown = ({ vaults, selectedVault, ...styleProps }: Props):
           <DropdownButtonListItem
             key={market.address}
             isSelected={market.address === selectedMarket.address}
-            label={`${formatTokenName(market.baseToken)} Vault ${isDeprecated ? '[Deprecated]' : ''}`}
+            label={
+              <Text color="text">
+                {formatTokenName(market.baseToken)} Vault{isDeprecated ? ' · Deprecated' : ''}
+              </Text>
+            }
             sublabel={
-              <Flex flexDirection="column">
-                <Text variant="small" as="span" color="secondaryText">
-                  {getNetworkDisplayName(market.lyra.network)}
-                </Text>
-              </Flex>
+              <Text variant="small" as="span" color="secondaryText">
+                {getNetworkDisplayName(market.lyra.network)}
+              </Text>
             }
             href={getPagePath({
               page: PageId.EarnVaults,
diff --git a/app/src/containers/vaults/VaultsMyLiquidityCard/index.tsx b/app/src/containers/vaults/VaultsMyLiquidityCard/index.tsx
index 7129bc22..118263d8 100644
--- a/app/src/containers/vaults/VaultsMyLiquidityCard/index.tsx
+++ b/app/src/containers/vaults/VaultsMyLiquidityCard/index.tsx
@@ -11,13 +11,11 @@ import formatBalance from '@lyra/ui/utils/formatBalance'
 import formatNumber from '@lyra/ui/utils/formatNumber'
 import formatPercentage from '@lyra/ui/utils/formatPercentage'
 import formatUSD from '@lyra/ui/utils/formatUSD'
-import { Version } from '@lyrafinance/lyra-js'
 import React, { useCallback, useState } from 'react'
 
 import LabelItem from '@/app/components/common/LabelItem'
 import VaultsPendingDepositsTableOrList from '@/app/components/common/VaultsPendingDepositsTableOrList'
 import VaultsPendingWithdrawalsTableOrList from '@/app/components/common/VaultsPendingWithdrawalsTableOrList'
-import { IGNORE_VAULTS_LIST } from '@/app/constants/ignore'
 import { Vault } from '@/app/constants/vault'
 import VaultsBoostFormModal from '@/app/containers/vaults/VaultsBoostFormModal'
 import formatAPY from '@/app/utils/formatAPY'
@@ -79,31 +77,21 @@ const VaultsMyLiquidityCard = ({ vault }: Props) => {
           ) : null}
         </Grid>
         <Grid my={2} sx={{ gridTemplateColumns: ['1fr', '1fr 1fr 1fr 1fr 1fr'], gridColumnGap: 6, gridRowGap: [3, 6] }}>
-          {vault.liquidityToken.balance.gt(0) ? (
+          {!vault.isDeprecated && vault.liquidityToken.balance.gt(0) ? (
             <Button
               onClick={() => setBoostModalOpen(true)}
               label={isMaxBoost ? 'Boosted' : 'Boost'}
               rightIcon={isMaxBoost ? IconType.Check : null}
               variant="primary"
               size="lg"
-              isDisabled={
-                !!IGNORE_VAULTS_LIST.find(
-                  ({ marketName, chain }) => marketName === market.name && chain === market.lyra.chain
-                ) || isMaxBoost
-              }
             />
           ) : null}
-          {vault.market.lyra.version !== Version.Avalon ? (
+          {!vault.isDeprecated ? (
             <Button
               onClick={() => setDepositModalOpen(true)}
               label="Deposit"
               variant={vault.liquidityToken.balance.gt(0) ? 'default' : 'primary'}
               size="lg"
-              isDisabled={
-                !!IGNORE_VAULTS_LIST.find(
-                  ({ marketName, chain }) => marketName === market.name && chain === market.lyra.chain
-                )
-              }
             />
           ) : null}
           {vault.liquidityToken.balance.gt(0) ? (
diff --git a/app/src/hooks/account/useTransaction.tsx b/app/src/hooks/account/useTransaction.tsx
index 8a74ec2e..e3b462ab 100644
--- a/app/src/hooks/account/useTransaction.tsx
+++ b/app/src/hooks/account/useTransaction.tsx
@@ -320,7 +320,7 @@ export default function useTransaction(network: Network) {
       updateToast(toastId, {
         variant: 'info',
         icon: <ToastSpinner />,
-        description: `Your transaction is pending`,
+        description: 'Your transaction is pending.',
         href: txHref,
         hrefLabel: 'View on etherscan',
         target: '_blank',
@@ -371,7 +371,7 @@ export default function useTransaction(network: Network) {
 
           updateToast(toastId, {
             variant: 'success',
-            description: `Your transaction was successful`,
+            description: 'Your transaction was successful.',
             href: txHref,
             hrefLabel: 'View on etherscan',
             target: '_blank',
@@ -384,7 +384,7 @@ export default function useTransaction(network: Network) {
         // Transaction timed out
         updateToast(toastId, {
           variant: 'warning',
-          description: 'Your transaction is taking longer than expected',
+          description: 'Your transaction is taking longer than expected.',
           href: txHref,
           hrefLabel: 'View on etherscan',
           target: '_blank',
diff --git a/app/src/hooks/market/useBoardQuotesSync.ts b/app/src/hooks/market/useBoardQuotesSync.ts
index b2ca84cb..94e37830 100644
--- a/app/src/hooks/market/useBoardQuotesSync.ts
+++ b/app/src/hooks/market/useBoardQuotesSync.ts
@@ -3,32 +3,14 @@ import { Board } from '@lyrafinance/lyra-js'
 import { useMemo } from 'react'
 
 import { ITERATIONS, StrikeQuotesNullable } from '@/app/constants/contracts'
-import { IGNORE_STRIKE_LIST } from '@/app/constants/ignore'
 import getIsQuoteHidden from '@/app/utils/getIsQuoteHidden'
 
 export default function useBoardQuotesSync(board: Board, size: BigNumber): StrikeQuotesNullable[] {
-  const market = board.market()
   return useMemo(
     () =>
       board
         .quoteAllSync(size, { iterations: ITERATIONS })
         .strikes.map(({ callBid, callAsk, putBid, putAsk, strike }) => {
-          const quoteStrikeId = strike.id
-          const isIgnored = !!IGNORE_STRIKE_LIST.find(
-            ({ strikeId, marketName, chain }) =>
-              quoteStrikeId === strikeId &&
-              market.name.toLowerCase() === marketName.toLowerCase() &&
-              market.lyra.chain === chain
-          )
-          if (isIgnored) {
-            return {
-              callBid: null,
-              callAsk: null,
-              putBid: null,
-              putAsk: null,
-              strike,
-            }
-          }
           const hideCallBid = callBid.disabledReason
             ? getIsQuoteHidden(callBid.disabledReason) || callBid.premium.isZero()
             : false
@@ -49,6 +31,6 @@ export default function useBoardQuotesSync(board: Board, size: BigNumber): Strik
             strike,
           }
         }),
-    [board, market, size]
+    [board, size]
   )
 }
diff --git a/app/src/hooks/rewards/useEarnPageData.ts b/app/src/hooks/rewards/useEarnPageData.ts
index 929d44f8..3152b382 100644
--- a/app/src/hooks/rewards/useEarnPageData.ts
+++ b/app/src/hooks/rewards/useEarnPageData.ts
@@ -1,16 +1,17 @@
-import { AccountRewardEpoch, GlobalRewardEpoch, Network } from '@lyrafinance/lyra-js'
+import { AccountBalances, AccountRewardEpoch, GlobalRewardEpoch, Market, Network, Version } from '@lyrafinance/lyra-js'
 import { useCallback } from 'react'
 
 import { FetchId } from '@/app/constants/fetch'
 import { Vault } from '@/app/constants/vault'
 import fetchLyraBalances, { LyraBalances } from '@/app/utils/common/fetchLyraBalances'
+import fetchVault from '@/app/utils/fetchVault'
 import getLyraSDK from '@/app/utils/getLyraSDK'
+import { lyraAvalon } from '@/app/utils/lyra'
 import fetchLyraStaking, { LyraStaking } from '@/app/utils/rewards/fetchLyraStaking'
 
 import useWallet from '../account/useWallet'
 import useWalletAccount from '../account/useWalletAccount'
 import useFetch, { useMutate } from '../data/useFetch'
-import { fetchVaults } from '../vaults/useVaultsPageData'
 
 export type LatestRewardEpoch = {
   global: GlobalRewardEpoch
@@ -31,60 +32,136 @@ export type RewardsPageData = {
   lyraBalances: LyraBalances
 }
 
-export const fetchEarnPageData = async (walletAddress: string | null): Promise<RewardsPageData> => {
-  const [globalRewardEpochs, accountRewardEpochs, vaults, lyraStaking, lyraBalances] = await Promise.all([
-    Promise.all(Object.values(Network).map(network => getLyraSDK(network).globalRewardEpochs())),
-    walletAddress
-      ? Promise.all(Object.values(Network).map(network => getLyraSDK(network).accountRewardEpochs(walletAddress)))
-      : [],
-    fetchVaults(walletAddress ?? undefined),
+const fetchEarnPageNetworkData = async (
+  walletAddress?: string
+): Promise<
+  {
+    network: Network
+    vaults: Vault[]
+    balances: AccountBalances[]
+    lyraBalances: LyraBalances
+    globalRewardEpochs: GlobalRewardEpoch[]
+    accountRewardEpochs: AccountRewardEpoch[]
+    latestGlobalRewardEpoch: GlobalRewardEpoch
+    latestAccountRewardEpoch?: AccountRewardEpoch
+  }[]
+> => {
+  return await Promise.all(
+    Object.values(Network).map(async network => {
+      const lyra = getLyraSDK(network)
+
+      const fetchMarkets = async (): Promise<Market[]> =>
+        network === Network.Optimism
+          ? // TODO: @xuwu remove avalon version
+            (await Promise.all([lyra.markets(), lyraAvalon.markets()])).flat()
+          : await lyra.markets()
+
+      const fetchBalances = async (): Promise<AccountBalances[]> =>
+        walletAddress
+          ? network === Network.Optimism
+            ? // TODO: @xuwu remove avalon version
+              (
+                await Promise.all([
+                  lyra.account(walletAddress).balances(),
+                  lyraAvalon.account(walletAddress).balances(),
+                ])
+              ).flat()
+            : await lyra.account(walletAddress).balances()
+          : []
+
+      const fetchAccountRewardEpochs = async (): Promise<AccountRewardEpoch[]> =>
+        walletAddress ? lyra.accountRewardEpochs(walletAddress) : []
+
+      const [lyraBalances, markets, balances, globalRewardEpochs, accountRewardEpochs] = await Promise.all([
+        fetchLyraBalances(walletAddress),
+        fetchMarkets(),
+        fetchBalances(),
+        lyra.globalRewardEpochs(),
+        fetchAccountRewardEpochs(),
+      ])
+
+      let latestGlobalRewardEpoch: GlobalRewardEpoch
+      const currGlobalRewardEpoch = globalRewardEpochs.find(e => e.isCurrent)
+      if (currGlobalRewardEpoch) {
+        latestGlobalRewardEpoch = currGlobalRewardEpoch
+      } else if (globalRewardEpochs.length > 0) {
+        // If no current epoch is available, use latest epoch less than current timestamp
+        latestGlobalRewardEpoch = globalRewardEpochs.sort((a, b) => b.endTimestamp - a.endTimestamp)[0]
+      } else {
+        throw new Error('No global epochs for network')
+      }
+
+      const latestAccountRewardEpoch = accountRewardEpochs.find(
+        e => e.globalEpoch.startTimestamp === latestGlobalRewardEpoch.startTimestamp
+      )
+
+      const vaults = await Promise.all(
+        markets.map(market =>
+          // TODO: @xuwu remove avalon version
+          market.lyra.version === Version.Avalon
+            ? fetchVault(network, market, balances, lyraBalances, walletAddress)
+            : fetchVault(
+                network,
+                market,
+                balances,
+                lyraBalances,
+                walletAddress,
+                latestGlobalRewardEpoch,
+                latestAccountRewardEpoch
+              )
+        )
+      )
+
+      return {
+        network,
+        vaults,
+        balances,
+        lyraBalances,
+        globalRewardEpochs,
+        accountRewardEpochs,
+        latestGlobalRewardEpoch,
+        latestAccountRewardEpoch,
+      }
+    })
+  )
+}
+
+export const fetchEarnPageData = async (walletAddress?: string): Promise<RewardsPageData> => {
+  const [pageNetworkData, lyraStaking] = await Promise.all([
+    fetchEarnPageNetworkData(walletAddress),
     fetchLyraStaking(walletAddress),
-    fetchLyraBalances(walletAddress),
   ])
 
-  const networkEpochsMap = Object.values(Network).reduce((map, network, idx) => {
-    const networkGlobalEpochs = globalRewardEpochs[idx] ?? []
-    const networkAccountRewardEpochs = accountRewardEpochs[idx] ?? []
-
-    let latestGlobalRewardEpoch: GlobalRewardEpoch
-    const currGlobalRewardEpoch = networkGlobalEpochs.find(e => e.isCurrent)
-    if (currGlobalRewardEpoch) {
-      latestGlobalRewardEpoch = currGlobalRewardEpoch
-    } else if (networkGlobalEpochs.length > 0) {
-      // If no current epoch is available, use latest epoch less than current timestamp
-      latestGlobalRewardEpoch = networkGlobalEpochs.sort((a, b) => b.endTimestamp - a.endTimestamp)[0]
-    } else {
-      throw new Error('No global epochs for network')
-    }
-
-    const latestAccountRewardEpoch = networkAccountRewardEpochs.find(
-      e => e.globalEpoch.startTimestamp === latestGlobalRewardEpoch.startTimestamp
-    )
-
-    return {
-      ...map,
-      [network]: {
-        globalRewardEpochs: networkGlobalEpochs,
-        accountRewardEpochs: networkAccountRewardEpochs,
-        latestRewardEpoch: {
-          global: latestGlobalRewardEpoch,
-          account: latestAccountRewardEpoch,
+  const networkEpochsMap = pageNetworkData.reduce(
+    (map, { network, globalRewardEpochs, accountRewardEpochs, latestGlobalRewardEpoch, latestAccountRewardEpoch }) => {
+      return {
+        ...map,
+        [network]: {
+          globalRewardEpochs,
+          accountRewardEpochs,
+          latestRewardEpoch: {
+            global: latestGlobalRewardEpoch,
+            account: latestAccountRewardEpoch,
+          },
         },
-      },
-    }
-  }, {} as Record<Network, NetworkRewardsData>)
+      }
+    },
+    {} as Record<Network, NetworkRewardsData>
+  )
+
+  const vaults = pageNetworkData.flatMap(({ vaults }) => vaults)
 
   return {
     epochs: networkEpochsMap,
     vaults,
-    lyraBalances,
+    lyraBalances: pageNetworkData[0].lyraBalances,
     lyraStaking,
   }
 }
 
 export default function useEarnPageData(): RewardsPageData | null {
   const account = useWalletAccount()
-  const [rewardsPageData] = useFetch(FetchId.RewardsPageData, [account], fetchEarnPageData)
+  const [rewardsPageData] = useFetch(FetchId.RewardsPageData, account ? [account] : [], fetchEarnPageData)
   return rewardsPageData
 }
 
diff --git a/app/src/hooks/vaults/useVaultsPageData.ts b/app/src/hooks/vaults/useVaultsPageData.ts
deleted file mode 100644
index 30a2cb8e..00000000
--- a/app/src/hooks/vaults/useVaultsPageData.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import { Network, Version } from '@lyrafinance/lyra-js'
-import { useCallback } from 'react'
-
-import { FetchId } from '@/app/constants/fetch'
-import { IGNORE_VAULTS_LIST } from '@/app/constants/ignore'
-import { Vault } from '@/app/constants/vault'
-import fetchVault from '@/app/utils/fetchVault'
-import getLyraSDK from '@/app/utils/getLyraSDK'
-import { lyraAvalon } from '@/app/utils/lyra'
-
-import useWallet from '../account/useWallet'
-import useFetch, { useMutate } from '../data/useFetch'
-
-export const fetchVaults = async (walletAddress?: string): Promise<Vault[]> => {
-  const vaults = await Promise.all(
-    Object.values(Network).map(async network => {
-      const lyra = getLyraSDK(network, Version.Newport)
-      let markets = await lyra.markets()
-      if (network === Network.Optimism) {
-        markets = markets.concat(await lyraAvalon.markets())
-      }
-      return await Promise.all(markets.map(market => fetchVault(network, market, walletAddress)))
-    })
-  )
-  return vaults
-    .flat()
-    .filter(
-      vault =>
-        !IGNORE_VAULTS_LIST.find(
-          ({ marketName, chain }) => marketName === vault.market.name && chain === vault.market.lyra.chain
-        ) || vault.liquidityToken.balance.gt(0)
-    )
-}
-
-const EMPTY: Vault[] = []
-
-export default function useVaultsPageData(): Vault[] {
-  const { account } = useWallet()
-  const [vaultStats] = useFetch(FetchId.VaultsTableData, [account], fetchVaults, { refreshInterval: 30 * 1000 })
-  return vaultStats ?? EMPTY
-}
-
-export function useMutateVaultsPageData() {
-  const { account } = useWallet()
-  const mutate = useMutate(FetchId.VaultsTableData, fetchVaults)
-  return useCallback(() => mutate(account), [mutate, account])
-}
diff --git a/app/src/page_helpers/LeaderboardHistoryPageHelper/index.tsx b/app/src/page_helpers/LeaderboardHistoryPageHelper/index.tsx
index 5613999b..3cc7be11 100644
--- a/app/src/page_helpers/LeaderboardHistoryPageHelper/index.tsx
+++ b/app/src/page_helpers/LeaderboardHistoryPageHelper/index.tsx
@@ -65,9 +65,6 @@ const LeaderboardHistoryPageHelper = ({ data }: Props): JSX.Element => {
                   <Text minWidth={MIN_COL_WIDTH} color="secondaryText">
                     Ended
                   </Text>
-                  <Text minWidth={MIN_COL_WIDTH} color="secondaryText">
-                    Your Fees
-                  </Text>
                   <Text
                     minWidth={MIN_COL_WIDTH}
                     ml="auto"
@@ -93,22 +90,12 @@ const LeaderboardHistoryPageHelper = ({ data }: Props): JSX.Element => {
                   return (
                     <Flex py={3} key={globalEpoch.id}>
                       <Text minWidth={MIN_COL_WIDTH}>{formatDate(globalEpoch.endTimestamp)}</Text>
-                      <Text minWidth={MIN_COL_WIDTH}>
-                        {formatBalance(
-                          {
-                            balance: accountEpoch.tradingFees,
-                            symbol: market.quoteToken.symbol,
-                            decimals: market.quoteToken.decimals,
-                          },
-                          { showDollars: true }
-                        )}
-                      </Text>
                       <Box minWidth={MIN_COL_WIDTH} ml="auto" textAlign={isMobile ? 'left' : 'right'}>
                         <Text>{accountEpoch.tradingRewards.map(t => formatBalance(t)).join(', ')}</Text>
                         {isLateDistribution ? (
                           <Text color="secondaryText">Claiming delayed</Text>
                         ) : isPendingDistribution ? (
-                          <Text color="secondaryText">
+                          <Text color="secondaryText" variant="small">
                             Claimable in&nbsp;
                             <Countdown as="span" timestamp={globalEpoch.distributionTimestamp} />
                           </Text>
diff --git a/app/src/page_helpers/common/Page/PageDesktop.tsx b/app/src/page_helpers/common/Page/PageDesktop.tsx
index 5b4397bd..934318d3 100644
--- a/app/src/page_helpers/common/Page/PageDesktop.tsx
+++ b/app/src/page_helpers/common/Page/PageDesktop.tsx
@@ -31,7 +31,7 @@ export default function PageDesktop({
         flexDirection="column"
       >
         {title || headerCard ? (
-          <Box mt={7}>
+          <Box mt={2}>
             <Flex height={HEADER_CARD_HEIGHT} alignItems="center">
               <Box>
                 <Text variant="title" mb={subtitle ? 2 : 0}>
@@ -52,7 +52,7 @@ export default function PageDesktop({
           </Box>
         ) : null}
         {showBackButton ? (
-          <Flex mt={!(title || headerCard) ? 7 : 0}>
+          <Flex mt={!(title || headerCard) ? 6 : 0}>
             <IconButton
               variant="light"
               icon={IconType.ArrowLeft}
diff --git a/app/src/page_helpers/common/Page/PageGrid.tsx b/app/src/page_helpers/common/Page/PageGrid.tsx
index 82ec01b2..32312096 100644
--- a/app/src/page_helpers/common/Page/PageGrid.tsx
+++ b/app/src/page_helpers/common/Page/PageGrid.tsx
@@ -11,7 +11,7 @@ type Props = {
 export default function PageGrid({ children, rightColumn }: Props): JSX.Element {
   const isMobile = useIsMobile()
   return (
-    <Flex pt={[8, 12]} flexGrow={1} width="100%">
+    <Flex pt={6} flexGrow={1} width="100%">
       <Flex pb={[0, 12]} flexGrow={1} pr={rightColumn && !isMobile ? 6 : 0} flexDirection="column">
         <Grid
           flexGrow={1}
diff --git a/app/src/utils/CachedStaticJsonRpcProvider.ts b/app/src/utils/CachedStaticJsonRpcProvider.ts
index 7be13274..b28d3502 100644
--- a/app/src/utils/CachedStaticJsonRpcProvider.ts
+++ b/app/src/utils/CachedStaticJsonRpcProvider.ts
@@ -1,14 +1,12 @@
-import { FilterByBlockHash } from '@ethersproject/abstract-provider'
-import { Block, BlockTag, Filter, Log, StaticJsonRpcProvider, TransactionRequest } from '@ethersproject/providers'
+import { Block, BlockTag, StaticJsonRpcProvider, TransactionRequest } from '@ethersproject/providers'
 import { Deferrable } from 'ethers/lib/utils'
 
 // Enables retries, caching
 export default class CachedStaticJsonRpcProvider extends StaticJsonRpcProvider {
   callPromiseCache: Record<string, Promise<string>> = {}
-  logsPromiseCache: Record<string, Promise<Log[]>> = {}
   blockPromiseCache: Record<string, Promise<Block>> = {}
-  // Refresh latest block every 1 second
-  latestBlockCacheTimeout = 1 * 1000
+  // Refresh latest block every 5 seconds
+  latestBlockCacheTimeout = 5 * 1000
   latestBlockUpdateTimestamp: number = 0
 
   async call(
@@ -21,19 +19,6 @@ export default class CachedStaticJsonRpcProvider extends StaticJsonRpcProvider {
     return this.callPromiseCache[key]
   }
 
-  async getLogs(filter: Filter | FilterByBlockHash | Promise<Filter | FilterByBlockHash>): Promise<Log[]> {
-    const resolvedFilter = await filter
-    let key: string
-    if ((resolvedFilter as any)?.toBlock === 'latest') {
-      const { number: blockNumber } = await this.getBlock('latest')
-      key = [blockNumber, JSON.stringify(resolvedFilter)].join()
-    } else {
-      key = JSON.stringify(resolvedFilter)
-    }
-    this.logsPromiseCache[key] = this.logsPromiseCache[key] ?? super.getLogs(filter)
-    return this.logsPromiseCache[key]
-  }
-
   async getBlock(_blockHashOrBlockTag: BlockTag | Promise<BlockTag>, skipLatestBlockCache?: boolean): Promise<Block> {
     const blockHashOrBlockTag = await _blockHashOrBlockTag
     if (blockHashOrBlockTag === 'latest') {
diff --git a/app/src/utils/fetchMarkets.ts b/app/src/utils/fetchMarkets.ts
index 42412acb..ec115e8a 100644
--- a/app/src/utils/fetchMarkets.ts
+++ b/app/src/utils/fetchMarkets.ts
@@ -1,6 +1,6 @@
 import { Market, Network } from '@lyrafinance/lyra-js'
 
-import { IGNORE_MARKETS_LIST } from '../constants/ignore'
+import { DEPRECATED_VAULTS_LIST } from '../constants/deprecated'
 import getLyraSDK from './getLyraSDK'
 import { lyraAvalon } from './lyra'
 
@@ -12,5 +12,5 @@ export default async function fetchMarkets(networks?: Network[]): Promise<Market
   }
   return networkMarkets
     .flat()
-    .filter(m => !IGNORE_MARKETS_LIST.find(i => i.marketName === m.name && i.chain === m.lyra.chain))
+    .filter(m => !DEPRECATED_VAULTS_LIST.find(i => i.chain === m.lyra.chain && i.version === m.lyra.version))
 }
diff --git a/app/src/utils/fetchVault.ts b/app/src/utils/fetchVault.ts
index e70bf4d4..22273173 100644
--- a/app/src/utils/fetchVault.ts
+++ b/app/src/utils/fetchVault.ts
@@ -1,27 +1,41 @@
-import { AccountRewardEpoch, Market, Network, RewardEpochTokenAmount } from '@lyrafinance/lyra-js'
+import {
+  AccountBalances,
+  AccountRewardEpoch,
+  GlobalRewardEpoch,
+  Market,
+  Network,
+  RewardEpochTokenAmount,
+} from '@lyrafinance/lyra-js'
 
 import { ONE_BN, UNIT, ZERO_ADDRESS, ZERO_BN } from '../constants/bn'
 import { DEPRECATED_VAULTS_LIST } from '../constants/deprecated'
+import { AppNetwork } from '../constants/networks'
 import { Vault } from '../constants/vault'
 import getAverageCostPerLPToken from '../hooks/vaults/getAverageCostPerLPToken'
-import fetchLyraBalances from './common/fetchLyraBalances'
+import { LyraBalances } from './common/fetchLyraBalances'
+import { getStkLyraBalanceForNetwork } from './common/getLyraBalanceForNetwork'
 import fromBigNumber from './fromBigNumber'
 import getEmptyMarketBalances from './getEmpyMarketBalances'
 import getLyraSDK from './getLyraSDK'
 
 const EMPTY_APY: RewardEpochTokenAmount[] = []
 
-const fetchVault = async (network: Network, market: Market, walletAddress?: string): Promise<Vault> => {
+const fetchVault = async (
+  network: Network,
+  market: Market,
+  balances: AccountBalances[],
+  lyraBalances: LyraBalances,
+  walletAddress?: string,
+  latestGlobalRewardEpoch?: GlobalRewardEpoch,
+  latestAccountRewardEpoch?: AccountRewardEpoch
+): Promise<Vault> => {
   const lyra = getLyraSDK(network, market.lyra.version)
   const account = lyra.account(walletAddress ?? ZERO_ADDRESS)
 
-  const [marketLiquidity, globalRewardEpoch, balances, lyraBalances, deposits, withdrawals] = await Promise.all([
+  const [marketLiquidity, deposits, withdrawals] = await Promise.all([
     market.liquidity(),
-    lyra.latestGlobalRewardEpoch(),
-    account.balances(),
-    fetchLyraBalances(walletAddress),
-    lyra.deposits(market.address, account.address),
-    lyra.withdrawals(market.address, account.address),
+    market.deposits(account.address),
+    market.withdrawals(account.address),
   ])
 
   const isDeprecated = DEPRECATED_VAULTS_LIST.some(
@@ -34,20 +48,19 @@ const fetchVault = async (network: Network, market: Market, walletAddress?: stri
   const pendingDeposits = deposits.filter(d => d.isPending)
   const pendingWithdrawals = withdrawals.filter(w => w.isPending)
 
-  let accountRewardEpoch: AccountRewardEpoch | null = null
-  if (walletAddress && globalRewardEpoch) {
-    accountRewardEpoch = await globalRewardEpoch.accountRewardEpoch(walletAddress)
-  }
-
-  const minApy = globalRewardEpoch?.minVaultApy(market.address) ?? EMPTY_APY
-  const maxApy = globalRewardEpoch?.maxVaultApy(market.address) ?? EMPTY_APY
-  const apy = accountRewardEpoch?.vaultApy(market.address) ?? minApy
-  const apyMultiplier = accountRewardEpoch?.vaultApyMultiplier(market.address) ?? 1
+  const minApy = latestGlobalRewardEpoch?.minVaultApy(market.address) ?? EMPTY_APY
+  const maxApy = latestGlobalRewardEpoch?.maxVaultApy(market.address) ?? EMPTY_APY
 
+  const stkLyraBalance = getStkLyraBalanceForNetwork(lyraBalances, AppNetwork.Ethereum)
   const liquidityToken = marketBalances.liquidityToken
+  const liquidityTokenBalance = fromBigNumber(liquidityToken.balance)
+
+  const apy = latestGlobalRewardEpoch?.vaultApy(market.address, stkLyraBalance, liquidityTokenBalance) ?? minApy
+  const apyMultiplier =
+    latestGlobalRewardEpoch?.vaultApyMultiplier(market.address, stkLyraBalance, liquidityTokenBalance) ?? 1
 
   const tvl = fromBigNumber(marketLiquidity.tvl)
-  const liquidityTokenBalanceValue = fromBigNumber(marketLiquidity.tokenPrice) * fromBigNumber(liquidityToken.balance)
+  const liquidityTokenBalanceValue = fromBigNumber(marketLiquidity.tokenPrice) * liquidityTokenBalance
 
   const utilization = marketLiquidity.utilization
 
@@ -56,13 +69,14 @@ const fetchVault = async (network: Network, market: Market, walletAddress?: stri
   const pnl = liquidityTokenBalanceValue - fromBigNumber(avgValue)
   const pnlPercent =
     avgCostPerToken.gt(0) && pnl !== 0 ? marketLiquidity.tokenPrice.mul(UNIT).div(avgCostPerToken).sub(ONE_BN) : ZERO_BN
+
   return {
     market,
     marketLiquidity,
     marketBalances,
     lyraBalances,
-    globalRewardEpoch,
-    accountRewardEpoch,
+    globalRewardEpoch: latestGlobalRewardEpoch ?? null,
+    accountRewardEpoch: latestAccountRewardEpoch ?? null,
     tvl,
     liquidityTokenBalanceValue,
     liquidityToken,
diff --git a/app/src/utils/getPageHeartbeat.ts b/app/src/utils/getPageHeartbeat.ts
index 14c94434..84075f66 100644
--- a/app/src/utils/getPageHeartbeat.ts
+++ b/app/src/utils/getPageHeartbeat.ts
@@ -3,8 +3,8 @@ import { Network } from '@lyrafinance/lyra-js'
 export default function getPageHeartbeat(network: Network) {
   switch (network) {
     case Network.Arbitrum:
-      return 5 * 1000 // 5 seconds
+      return 10 * 1000 // 10 seconds
     case Network.Optimism:
-      return 15 * 1000 // 15 seconds
+      return 30 * 1000 // 30 seconds
   }
 }
diff --git a/app/src/utils/getVaultsHistoryCSV.ts b/app/src/utils/getVaultsHistoryCSV.ts
index 59fa3c34..dfadfadb 100644
--- a/app/src/utils/getVaultsHistoryCSV.ts
+++ b/app/src/utils/getVaultsHistoryCSV.ts
@@ -26,7 +26,7 @@ export const getVaultsHistoryCSV = (rows: Vault[]) => {
       const date = new Date(event.depositTimestamp * 1000)
       datetime = date.toISOString()
       timestamp = event.depositTimestamp
-      transactionHash = event.__processed?.transactionHash ?? ''
+      transactionHash = event.transactionHash ?? ''
       action = 'deposit'
     } else if (event instanceof LiquidityWithdrawal) {
       const date = new Date(event.withdrawalTimestamp * 1000)
diff --git a/app/src/utils/lyra.ts b/app/src/utils/lyra.ts
index f3403de4..01cc448a 100644
--- a/app/src/utils/lyra.ts
+++ b/app/src/utils/lyra.ts
@@ -1,4 +1,4 @@
-import Lyra, { Chain, Version } from '@lyrafinance/lyra-js'
+import Lyra, { Network, Version } from '@lyrafinance/lyra-js'
 
 import { LyraNetwork } from '../constants/networks'
 import CachedStaticJsonRpcProvider from './CachedStaticJsonRpcProvider'
@@ -9,51 +9,63 @@ const optimismNetworkConfig = getNetworkConfig(LyraNetwork.Optimism)
 const optimismProvider = new CachedStaticJsonRpcProvider(optimismNetworkConfig.rpcUrl, optimismNetworkConfig.chainId)
 
 const arbitrumNetworkConfig = getNetworkConfig(LyraNetwork.Arbitrum)
-export const arbitrumProvider = new CachedStaticJsonRpcProvider(
-  arbitrumNetworkConfig.rpcUrl,
-  arbitrumNetworkConfig.chainId
-)
+const arbitrumProvider = new CachedStaticJsonRpcProvider(arbitrumNetworkConfig.rpcUrl, arbitrumNetworkConfig.chainId)
 
-const getLyraSubgraphURI = (chain: Chain, version: Version = Version.Newport): string | undefined => {
+const getLyraSubgraphURI = (network: Network, version: Version): string | undefined => {
   const SATSUMA_API_KEY = process.env.REACT_APP_SATSUMA_API_KEY
   if (!SATSUMA_API_KEY) {
     // Use SDK default
     return
   }
-  switch (chain) {
-    case Chain.Optimism:
-      switch (version) {
-        case Version.Avalon:
-          return `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/optimism-mainnet/api`
-        case Version.Newport:
-        default:
-          return `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/optimism-mainnet-newport/api`
-      }
-    case Chain.OptimismGoerli:
-      return `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/optimism-goerli/api`
-    case Chain.Arbitrum:
-      return `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/arbitrum-mainnet/api`
-    case Chain.ArbitrumGoerli:
-      return `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/arbitrum-goerli/api`
+  switch (network) {
+    case Network.Optimism:
+      return isMainnet()
+        ? version === Version.Avalon
+          ? `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/optimism-mainnet/api`
+          : `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/optimism-mainnet-newport/api`
+        : `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/optimism-goerli/api`
+    case Network.Arbitrum:
+      return isMainnet()
+        ? `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/arbitrum-mainnet/api`
+        : `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/arbitrum-goerli/api`
+  }
+}
+
+const getLyraGovSubgraphURI = (network: Network): string | undefined => {
+  const SATSUMA_API_KEY = process.env.REACT_APP_SATSUMA_API_KEY
+  if (!SATSUMA_API_KEY) {
+    // Use SDK default
+    return
+  }
+  switch (network) {
+    case Network.Optimism:
+      return `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/optimism-governance/api`
+    case Network.Arbitrum:
+      return `https://subgraph.satsuma-prod.com/${SATSUMA_API_KEY}/lyra/arbitrum-governance/api`
   }
 }
 
 export const lyraOptimism = new Lyra({
   provider: optimismProvider,
   apiUri: process.env.REACT_APP_API_URL,
-  subgraphUri: getLyraSubgraphURI(isMainnet() ? Chain.Optimism : Chain.OptimismGoerli, Version.Newport),
+  subgraphUri: getLyraSubgraphURI(Network.Optimism, Version.Newport),
+  govSubgraphUri: getLyraGovSubgraphURI(Network.Optimism),
   version: Version.Newport,
 })
 
+// TODO: @xuwu remove avalon version
 export const lyraAvalon = new Lyra({
   provider: optimismProvider,
   apiUri: process.env.REACT_APP_API_URL,
-  subgraphUri: getLyraSubgraphURI(isMainnet() ? Chain.Optimism : Chain.OptimismGoerli, Version.Avalon),
+  subgraphUri: getLyraSubgraphURI(Network.Optimism, Version.Avalon),
+  govSubgraphUri: getLyraGovSubgraphURI(Network.Optimism),
   version: Version.Avalon,
 })
 
 export const lyraArbitrum = new Lyra({
   provider: arbitrumProvider,
   apiUri: process.env.REACT_APP_API_URL,
-  subgraphUri: getLyraSubgraphURI(isMainnet() ? Chain.Arbitrum : Chain.ArbitrumGoerli, Version.Newport),
+  subgraphUri: getLyraSubgraphURI(Network.Arbitrum, Version.Newport),
+  govSubgraphUri: getLyraGovSubgraphURI(Network.Arbitrum),
+  version: Version.Newport,
 })
diff --git a/sdk/src/account_reward_epoch/index.ts b/sdk/src/account_reward_epoch/index.ts
index c6b529ba..369d5e05 100644
--- a/sdk/src/account_reward_epoch/index.ts
+++ b/sdk/src/account_reward_epoch/index.ts
@@ -1,6 +1,5 @@
 import { BigNumber, PopulatedTransaction } from 'ethers'
 
-import { AccountBalances, AccountLiquidityTokenBalance } from '../account'
 import { Deployment, LyraGlobalContractId } from '../constants/contracts'
 import { MIN_REWARD_AMOUNT } from '../constants/rewards'
 import { GlobalRewardEpoch, RewardEpochToken } from '../global_reward_epoch'
@@ -10,7 +9,6 @@ import buildTx from '../utils/buildTx'
 import fetchAccountRewardEpochData, { AccountRewardEpochData } from '../utils/fetchAccountRewardEpochData'
 import fetchClaimAddedEvents from '../utils/fetchClaimAddedEvents'
 import fetchClaimEvents from '../utils/fetchClaimEvents'
-import fetchStkLyraBalance from '../utils/fetchStkLyraBalance'
 import findMarketX from '../utils/findMarketX'
 import fromBigNumber from '../utils/fromBigNumber'
 import getGlobalContract from '../utils/getGlobalContract'
@@ -44,14 +42,10 @@ export class AccountRewardEpoch {
   account: string
   globalEpoch: GlobalRewardEpoch
   accountEpoch: AccountRewardEpochData
-  stakedLyraBalance: number
-  tradingFeeRebate: number
-  tradingFees: number
   tradingRewards: RewardEpochTokenAmount[]
   isTradingRewardsDistributed: boolean
   totalClaimableRewards: RewardEpochTokenAmount[]
   totalClaimableTradingRewards: RewardEpochTokenAmount[]
-  private vaultTokenBalancesMap: Record<string, AccountLiquidityTokenBalance>
   private totalClaimableVaultRewardsMap: Record<string, RewardEpochTokenAmount[]>
   private distributedVaultRewardsMap: Record<string, RewardEpochTokenAmount[]>
   private calculatedVaultRewardsMap: Record<string, RewardEpochTokenAmount[]>
@@ -62,8 +56,6 @@ export class AccountRewardEpoch {
     account: string,
     accountEpoch: AccountRewardEpochData,
     globalEpoch: GlobalRewardEpoch,
-    balances: AccountBalances[],
-    stkLyraBalance: number,
     claimAddedEvents: ClaimAddedEvent[],
     claimEvents: ClaimEvent[],
     rewardTokens: RewardEpochToken[],
@@ -73,33 +65,14 @@ export class AccountRewardEpoch {
     this.account = account
     this.globalEpoch = globalEpoch
     this.accountEpoch = accountEpoch
-    const avgStkLyraBalance =
-      globalEpoch.progressDays > 0 ? accountEpoch.stakingRewards.stkLyraDays / globalEpoch.progressDays : 0
-    this.stakedLyraBalance = globalEpoch.isComplete ? avgStkLyraBalance : stkLyraBalance
 
-    this.vaultTokenBalancesMap = balances.reduce(
-      (lpTokenBalances, balance) => ({
-        ...lpTokenBalances,
-        [balance.baseAsset.symbol]: balance.liquidityToken,
-      }),
-      {}
-    )
-
-    this.tradingFeeRebate = globalEpoch.tradingFeeRebate(this.stakedLyraBalance)
     const hasNewRewards = !!accountEpoch.tradingRewards.newRewards
     const oldTradingRewardTokens = accountEpoch.tradingRewards?.rewards?.trading ?? []
     const newTradingRewardTokens = accountEpoch?.tradingRewards?.newRewards?.tokens ?? []
-    const oldTradingRewardFees = accountEpoch.tradingRewards.fees ?? 0
-    const newTradingRewardFees = accountEpoch.tradingRewards?.newRewards?.points?.fees ?? 0
-    const integratorTradingFees = accountEpoch.integratorTradingRewards?.fees ?? 0
-    this.tradingFees =
-      integratorTradingFees > 0 ? integratorTradingFees : hasNewRewards ? newTradingRewardFees : oldTradingRewardFees
     const tradingRewardTokens = hasNewRewards ? newTradingRewardTokens : oldTradingRewardTokens
-    this.tradingRewards =
-      tradingRewardTokens && tradingRewardTokens.length > 0 ? tradingRewardTokens : globalEpoch.tradingRewards(0, 0)
     const distributedTradingRewards = getDistributedTradingRewards(globalEpoch, claimAddedEvents)
     this.isTradingRewardsDistributed = !!distributedTradingRewards.find(d => d.amount > 0)
-    this.tradingRewards = this.isTradingRewardsDistributed ? distributedTradingRewards : this.tradingRewards
+    this.tradingRewards = this.isTradingRewardsDistributed ? distributedTradingRewards : tradingRewardTokens
 
     this.totalClaimableRewards = totalClaimableRewards
     this.totalClaimableTradingRewards = getTotalClaimableTradingRewards(rewardTokens, claimAddedEvents, claimEvents)
@@ -138,19 +111,16 @@ export class AccountRewardEpoch {
 
   // Getters
 
-  static async getByOwner(lyra: Lyra, address: string): Promise<AccountRewardEpoch[]> {
+  static async getByOwner(lyra: Lyra, owner: string): Promise<AccountRewardEpoch[]> {
     if (lyra.deployment !== Deployment.Mainnet) {
       return []
     }
-    const [accountEpochDatas, globalEpochs, stkLyraBalance, balances, claimAddedEvents, claimEvents] =
-      await Promise.all([
-        fetchAccountRewardEpochData(lyra, address),
-        GlobalRewardEpoch.getAll(lyra),
-        fetchStkLyraBalance(lyra, address),
-        lyra.account(address).balances(),
-        fetchClaimAddedEvents(lyra, lyra.chain, address),
-        fetchClaimEvents(lyra, lyra.chain, address),
-      ])
+    const [accountEpochDatas, globalEpochs, claimAddedEvents, claimEvents] = await Promise.all([
+      fetchAccountRewardEpochData(lyra, owner),
+      GlobalRewardEpoch.getAll(lyra),
+      fetchClaimAddedEvents(lyra, owner),
+      fetchClaimEvents(lyra, owner),
+    ])
 
     const uniqueRewardTokens = getUniqueBy(
       globalEpochs.flatMap(e => e.rewardTokens),
@@ -163,7 +133,7 @@ export class AccountRewardEpoch {
       uniqueRewardTokens.map(({ address: tokenAddress }) => ({
         contract: distributorContract,
         function: 'claimableBalances',
-        args: [address, tokenAddress],
+        args: [owner, tokenAddress],
       }))
     )
     const totalClaimableBalances = (returnData as BigNumber[])
@@ -185,11 +155,9 @@ export class AccountRewardEpoch {
         }
         return new AccountRewardEpoch(
           lyra,
-          address,
+          owner,
           accountEpochData,
           globalEpoch,
-          balances,
-          stkLyraBalance,
           claimAddedEvents,
           claimEvents,
           uniqueRewardTokens,
@@ -220,46 +188,6 @@ export class AccountRewardEpoch {
 
   // Dynamic Fields
 
-  vaultApy(marketAddressOrName: string): RewardEpochTokenAmount[] {
-    const vaultTokenBalance = this.vaultTokenBalance(marketAddressOrName)
-    if (vaultTokenBalance === 0) {
-      return this.globalEpoch.minVaultApy(marketAddressOrName)
-    } else {
-      return this.globalEpoch.vaultApy(marketAddressOrName, this.stakedLyraBalance, vaultTokenBalance)
-    }
-  }
-
-  vaultMaxBoost(marketAddressOrName: string): number {
-    const vaultTokenBalance = this.vaultTokenBalance(marketAddressOrName)
-    if (vaultTokenBalance === 0) {
-      return this.globalEpoch.vaultMaxBoost(marketAddressOrName, 0)
-    } else {
-      return this.globalEpoch.vaultMaxBoost(marketAddressOrName, vaultTokenBalance)
-    }
-  }
-
-  vaultApyMultiplier(marketAddressOrName: string): number {
-    const vaultTokenBalance = this.vaultTokenBalance(marketAddressOrName)
-    if (vaultTokenBalance === 0) {
-      return 1
-    } else {
-      return this.globalEpoch.vaultApyMultiplier(marketAddressOrName, this.stakedLyraBalance, vaultTokenBalance)
-    }
-  }
-
-  vaultTokenBalance(marketAddressOrName: string): number {
-    const market = findMarketX(this.globalEpoch.markets, marketAddressOrName)
-    const marketKey = market.baseToken.symbol
-    const boostedLpDays: number = this.accountEpoch.mmvRewards
-      ? this.accountEpoch.mmvRewards[marketKey]?.boostedLpDays ?? 0
-      : 0
-    const avgVaultTokenBalance = this.globalEpoch.progressDays > 0 ? boostedLpDays / this.globalEpoch.progressDays : 0
-    const currVaultTokenBalance = fromBigNumber(this.vaultTokenBalancesMap[marketKey].balance)
-    // Uses average for historical epochs, realtime for current epoch
-    const vaultTokenBalance = this.globalEpoch.isComplete ? avgVaultTokenBalance : currVaultTokenBalance
-    return vaultTokenBalance
-  }
-
   vaultRewards(marketAddressOrName: string): RewardEpochTokenAmount[] {
     const market = findMarketX(this.globalEpoch.markets, marketAddressOrName)
     const marketKey = market.baseToken.symbol
diff --git a/sdk/src/constants/queries.ts b/sdk/src/constants/queries.ts
index 6dc38c4a..d8a38f54 100644
--- a/sdk/src/constants/queries.ts
+++ b/sdk/src/constants/queries.ts
@@ -316,6 +316,12 @@ export const LIQUIDITY_DEPOSIT_FRAGMENT = `
     market {
       id
     }
+    cbEvents(first:1, orderBy:cbTimestamp, orderDirection:desc) {
+      cbTimestamp
+      ivVarianceCrossed
+      skewVarianceCrossed
+      liquidityVarianceCrossed
+    }
   }
   user
   pendingDepositsAndWithdrawals(where: {
@@ -389,6 +395,13 @@ export const CLAIM_FRAGMENT = `
   timestamp
 `
 
+export const CIRCUIT_BREAKER_FRAGMENT = `
+  cbTimestamp
+  ivVarianceCrossed
+  skewVarianceCrossed
+  liquidityVarianceCrossed
+`
+
 export type TradeQueryResult = {
   timestamp: number
   blockNumber: number
@@ -641,6 +654,13 @@ export enum SnapshotPeriod {
   SevenDays = 604800,
 }
 
+export type CircuitBreakerQueryResult = {
+  cbTimestamp: number
+  ivVarianceCrossed: boolean
+  skewVarianceCrossed: boolean
+  liquidityVarianceCrossed: boolean
+}
+
 export type LiquidityDepositQueryResult = {
   pool: {
     id: string
diff --git a/sdk/src/global_reward_epoch/index.ts b/sdk/src/global_reward_epoch/index.ts
index 0176cea5..33c98b98 100644
--- a/sdk/src/global_reward_epoch/index.ts
+++ b/sdk/src/global_reward_epoch/index.ts
@@ -8,15 +8,9 @@ import fetchGlobalRewardEpochData, { GlobalRewardEpochData } from '../utils/fetc
 import findMarketX from '../utils/findMarketX'
 import fromBigNumber from '../utils/fromBigNumber'
 import getEffectiveLiquidityTokens, { getMinimumStakedLyra } from '../utils/getEffectiveLiquidityTokens'
-import getEffectiveTradingFeeRebate from '../utils/getEffectiveTradingFeeRebate'
 import getUniqueBy from '../utils/getUniqueBy'
 import isMarketEqual from '../utils/isMarketEqual'
 
-export type GlobalRewardEpochTradingFeeRebateTier = {
-  stakedLyraCutoff: number
-  feeRebate: number
-}
-
 export type GlobalRewardEpochTradingBoostTier = {
   stakingCutoff: number
   tradingCutoff: number
@@ -62,7 +56,6 @@ export class GlobalRewardEpoch {
   isComplete: boolean
   totalAverageStakedLyra: number
   tradingRewardsCap: RewardEpochTokenAmount[]
-  tradingFeeRebateTiers: GlobalRewardEpochTradingFeeRebateTier[]
   tradingBoostTiers: GlobalRewardEpochTradingBoostTier[]
   vaultRewardTokens: RewardEpochToken[]
   tradingRewardTokens: RewardEpochToken[]
@@ -83,10 +76,6 @@ export class GlobalRewardEpoch {
     this.epoch = epoch
     this.markets = markets
     this.marketsLiquidity = marketsLiquidity
-    this.tradingFeeRebateTiers = epoch.tradingRewardConfig?.rebateRateTable?.map(tier => ({
-      stakedLyraCutoff: tier.cutoff,
-      feeRebate: tier.returnRate,
-    }))
     this.tradingBoostTiers = epoch.tradingRewardConfig?.boostRateTable?.map(tier => ({
       stakingCutoff: tier.stakingCutoff,
       tradingCutoff: tier.tradingCutoff,
@@ -289,44 +278,6 @@ export class GlobalRewardEpoch {
     return this.progressDays ? (this.epoch.totalBoostedLpTokenDays[marketKey] ?? 0) / this.progressDays : 0
   }
 
-  tradingFeeRebate(stakedLyraBalance: number): number {
-    const {
-      useRebateTable,
-      rebateRateTable,
-      maxRebatePercentage,
-      netVerticalStretch,
-      verticalShift,
-      vertIntercept,
-      stretchiness,
-    } = this.epoch.tradingRewardConfig
-    return getEffectiveTradingFeeRebate(
-      stakedLyraBalance,
-      useRebateTable,
-      rebateRateTable,
-      maxRebatePercentage,
-      netVerticalStretch,
-      verticalShift,
-      vertIntercept,
-      stretchiness
-    )
-  }
-
-  tradingRewards(tradingFees: number, stakedLyraBalance: number): RewardEpochTokenAmount[] {
-    return this.epoch.tradingRewardConfig.tokens.map(token => {
-      const currentPrice = this.tokenPriceMap[token.address]?.price ?? 0
-      const price = this.isComplete ? token.fixedPrice : Math.max(currentPrice, token.floorTokenPrice)
-      const feeRebate = this.tradingFeeRebate(stakedLyraBalance)
-      const feesRebated = feeRebate * tradingFees
-      const rewardAmount = (feesRebated * token.portion) / price
-      return {
-        amount: isNaN(rewardAmount) ? 0 : rewardAmount,
-        address: token.address,
-        decimals: token.decimals,
-        symbol: token.symbol,
-      }
-    })
-  }
-
   // Edge
 
   async accountRewardEpoch(address: string): Promise<AccountRewardEpoch | null> {
diff --git a/sdk/src/liquidity_deposit/index.ts b/sdk/src/liquidity_deposit/index.ts
index a00e6b5a..cf94d37b 100644
--- a/sdk/src/liquidity_deposit/index.ts
+++ b/sdk/src/liquidity_deposit/index.ts
@@ -7,7 +7,6 @@ import { Market, MarketLiquiditySnapshot } from '../market'
 import buildTx from '../utils/buildTx'
 import fetchLiquidityDepositEventDataByOwner from '../utils/fetchLiquidityDepositEventDataByOwner'
 import getERC20Contract from '../utils/getERC20Contract'
-import getLiquidityDelayReason from '../utils/getLiquidityDelayReason'
 import getLyraMarketContract from '../utils/getLyraMarketContract'
 
 export enum LiquidityDelayReason {
@@ -20,38 +19,55 @@ export type LiquidityDepositFilter = {
   user: string
 }
 
-export type DepositQueuedOrProcessedEvent = {
-  queued?: LiquidityDepositQueuedEvent
-  processed?: LiquidityDepositProcessedEvent
+export type LiquidityDepositEvents =
+  | {
+      isInstant: false
+      isProcessed: false
+      queued: LiquidityDepositQueuedEvent
+    }
+  | {
+      isInstant: true
+      isProcessed: true
+      processed: LiquidityDepositProcessedEvent
+    }
+  | {
+      isInstant: false
+      isProcessed: true
+      queued: LiquidityDepositQueuedEvent
+      processed: LiquidityDepositProcessedEvent
+    }
+
+export type LiquidityCircuitBreaker = {
+  timestamp: number
+  reason: LiquidityDelayReason
 }
 
 export type LiquidityDepositQueuedEvent = {
   depositor: string
   beneficiary: string
-  depositQueueId: BigNumber
+  queueId: number
   amountDeposited: BigNumber
   totalQueuedDeposits: BigNumber
-  timestamp: BigNumber
+  timestamp: number
   transactionHash: string
 }
 
 export type LiquidityDepositProcessedEvent = {
   caller: string
   beneficiary: string
-  depositQueueId: BigNumber
+  queueId: number
   amountDeposited: BigNumber
   tokenPrice: BigNumber
   tokensReceived: BigNumber
-  timestamp: BigNumber
+  timestamp: number
   transactionHash: string
 }
 
 export class LiquidityDeposit {
   lyra: Lyra
-  __queued?: LiquidityDepositQueuedEvent
-  __processed?: LiquidityDepositProcessedEvent
+  __events: LiquidityDepositEvents
   __market: Market
-  queueId?: number
+  queueId: number
   beneficiary: string
   value: BigNumber
   tokenPriceAtDeposit?: BigNumber
@@ -60,73 +76,67 @@ export class LiquidityDeposit {
   depositRequestedTimestamp: number
   depositTimestamp: number
   timeToDeposit: number
+  transactionHash: string
   delayReason: LiquidityDelayReason | null
   constructor(
     lyra: Lyra,
-    market: Market,
     data: {
-      queued?: LiquidityDepositQueuedEvent
-      processed?: LiquidityDepositProcessedEvent
-      cbTimestamp: BigNumber
+      market: Market
+      events: LiquidityDepositEvents
+      circuitBreaker: LiquidityCircuitBreaker | null
       marketLiquidity: MarketLiquiditySnapshot
     }
   ) {
     // Data
     this.lyra = lyra
-    this.__market = market
-    this.__queued = data.queued
-    this.__processed = data.processed
+    this.__market = data.market
+    this.__events = data.events
 
     // Fields
-    const queued = data.queued
-    const processed = data.processed
-    const queuedOrProcessed = queued ?? processed
-    if (!queuedOrProcessed) {
-      throw new Error('No queued or processed event for LiquidityDeposit')
-    }
-    this.queueId = queuedOrProcessed.depositQueueId.toNumber()
+    const queued = !data.events.isInstant ? data.events.queued : null
+    const processed = data.events.isProcessed ? data.events.processed : null
+    const queuedOrProcessed = (data.events.isInstant ? processed : data.events.queued) as
+      | LiquidityDepositQueuedEvent
+      | LiquidityDepositProcessedEvent
+    this.transactionHash = queuedOrProcessed.transactionHash
+    this.queueId = queuedOrProcessed.queueId
     this.beneficiary = queuedOrProcessed.beneficiary
     this.value = queuedOrProcessed.amountDeposited
     this.tokenPriceAtDeposit = processed?.tokenPrice
     this.balance = processed?.tokensReceived
     this.isPending = !processed
-    this.depositRequestedTimestamp = queuedOrProcessed.timestamp.toNumber()
+    this.depositRequestedTimestamp = queuedOrProcessed.timestamp
     this.depositTimestamp = processed
-      ? processed.timestamp.toNumber()
+      ? processed.timestamp
       : queued
-      ? queued.timestamp.add(market.params.depositDelay).toNumber()
+      ? queued.timestamp + data.market.params.depositDelay
       : // Should never happen
         0
-    this.timeToDeposit = Math.max(0, this.depositTimestamp - market.block.timestamp)
+    this.timeToDeposit = Math.max(0, this.depositTimestamp - data.market.block.timestamp)
     this.delayReason =
-      this.timeToDeposit === 0 && this.isPending
-        ? getLiquidityDelayReason(market, data.cbTimestamp, data.marketLiquidity)
+      this.timeToDeposit === 0 &&
+      this.isPending &&
+      data.circuitBreaker &&
+      data.circuitBreaker.timestamp > data.market.block.timestamp
+        ? data.circuitBreaker.reason
         : null
   }
 
   // Getters
 
-  static async getByOwner(lyra: Lyra, marketAddress: string, owner: string): Promise<LiquidityDeposit[]> {
-    const market = await Market.get(lyra, marketAddress)
-    const liquidityPoolContract = getLyraMarketContract(
-      lyra,
-      market.contractAddresses,
-      lyra.version,
-      LyraMarketContractId.LiquidityPool
-    )
-    const [{ events }, cbTimestamp, marketLiquidity] = await Promise.all([
+  static async getByOwner(lyra: Lyra, market: Market, owner: string): Promise<LiquidityDeposit[]> {
+    const [{ events, circuitBreaker }, marketLiquidity] = await Promise.all([
       fetchLiquidityDepositEventDataByOwner(lyra, owner, market),
-      liquidityPoolContract.CBTimestamp(),
       market.liquidity(),
     ])
-    const liquidityDeposits: LiquidityDeposit[] = await Promise.all(
-      events.map(async event => {
-        return new LiquidityDeposit(lyra, market, {
-          ...event,
-          cbTimestamp,
+    const liquidityDeposits = events.map(
+      events =>
+        new LiquidityDeposit(lyra, {
+          market,
+          events,
+          circuitBreaker,
           marketLiquidity,
         })
-      })
     )
     return liquidityDeposits
   }
diff --git a/sdk/src/liquidity_withdrawal/index.ts b/sdk/src/liquidity_withdrawal/index.ts
index 08b4dfa3..5393c885 100644
--- a/sdk/src/liquidity_withdrawal/index.ts
+++ b/sdk/src/liquidity_withdrawal/index.ts
@@ -1,44 +1,52 @@
 import { BigNumber } from '@ethersproject/bignumber'
 import { PopulatedTransaction } from '@ethersproject/contracts'
 
-import { LiquidityDelayReason } from '..'
+import { LiquidityCircuitBreaker, LiquidityDelayReason } from '..'
 import { ZERO_BN } from '../constants/bn'
 import { LyraMarketContractId } from '../constants/contracts'
 import Lyra from '../lyra'
 import { Market, MarketLiquiditySnapshot } from '../market'
 import buildTx from '../utils/buildTx'
 import fetchLiquidityWithdrawalEventDataByOwner from '../utils/fetchLiquidityWithdrawalEventDataByOwner'
-import getLiquidityDelayReason from '../utils/getLiquidityDelayReason'
 import getLyraMarketContract from '../utils/getLyraMarketContract'
 
-export type LiquidityWithdrawalFilter = {
-  user: string
-}
-
-export type WithdrawalQueuedOrProcessedEvent = {
-  queued?: LiquidityWithdrawalQueuedEvent
-  processed?: LiquidityWithdrawalProcessedEvent
-}
+export type LiquidityWithdrawalEvents =
+  | {
+      isInstant: false
+      isProcessed: false
+      queued: LiquidityWithdrawalQueuedEvent
+    }
+  | {
+      isInstant: true
+      isProcessed: true
+      processed: LiquidityWithdrawalProcessedEvent
+    }
+  | {
+      isInstant: false
+      isProcessed: true
+      queued: LiquidityWithdrawalQueuedEvent
+      processed: LiquidityWithdrawalProcessedEvent
+    }
 
 export type LiquidityWithdrawalQueuedEvent = {
   withdrawer: string
   beneficiary: string
-  withdrawalQueueId: BigNumber
+  queueId: number
   amountWithdrawn: BigNumber
   totalQueuedWithdrawals: BigNumber
-  timestamp: BigNumber
+  timestamp: number
   transactionHash: string
 }
 
 export type LiquidityWithdrawalProcessedEvent = {
   caller: string
   beneficiary: string
-  withdrawalQueueId: BigNumber
+  queueId: number
   amountWithdrawn: BigNumber
   tokenPrice: BigNumber
   quoteReceived: BigNumber
   totalQueuedWithdrawals: BigNumber
-  timestamp: BigNumber
+  timestamp: number
   transactionHash: string
 }
 
@@ -59,70 +67,64 @@ export class LiquidityWithdrawal {
   delayReason: LiquidityDelayReason | null
   constructor(
     lyra: Lyra,
-    market: Market,
     data: {
-      queued?: LiquidityWithdrawalQueuedEvent
-      processed?: LiquidityWithdrawalProcessedEvent
-      cbTimestamp: BigNumber
+      events: LiquidityWithdrawalEvents
+      market: Market
+      circuitBreaker: LiquidityCircuitBreaker | null
       marketLiquidity: MarketLiquiditySnapshot
     }
   ) {
     // Data
     this.lyra = lyra
-    this.__market = market
-    this.__queued = data.queued
-    this.__processed = data.processed
+    this.__market = data.market
 
     // Fields
-    const queued = data.queued
-    const processed = data.processed
+    const queued = !data.events.isInstant ? data.events.queued : null
+    const processed = data.events.isProcessed ? data.events.processed : null
     const queuedOrProcessed = queued ?? processed
     if (!queuedOrProcessed) {
       throw new Error('No queued or processed event for LiquidityWithdrawal')
     }
-    this.queueId = queuedOrProcessed.withdrawalQueueId.toNumber()
+    this.queueId = queuedOrProcessed.queueId
     this.beneficiary = queuedOrProcessed.beneficiary
     this.balance = queued?.amountWithdrawn ?? ZERO_BN
     this.tokenPriceAtWithdraw = processed?.tokenPrice
     this.value = processed?.amountWithdrawn
     this.isPending = !processed
-    this.withdrawalRequestedTimestamp = queuedOrProcessed.timestamp.toNumber()
+    this.withdrawalRequestedTimestamp = queuedOrProcessed.timestamp
     this.withdrawalTimestamp = processed
-      ? processed.timestamp.toNumber()
+      ? processed.timestamp
       : queued
-      ? queued.timestamp.add(market.params.withdrawalDelay).toNumber()
+      ? queued.timestamp + data.market.params.withdrawalDelay
       : // Should never happen
         0
-    this.timeToWithdrawal = Math.max(0, this.withdrawalTimestamp - market.block.timestamp)
+    this.timeToWithdrawal = Math.max(0, this.withdrawalTimestamp - data.market.block.timestamp)
     this.delayReason =
-      this.timeToWithdrawal === 0 && this.isPending
-        ? getLiquidityDelayReason(market, data.cbTimestamp, data.marketLiquidity)
+      this.timeToWithdrawal === 0 &&
+      this.isPending &&
+      data.circuitBreaker &&
+      data.circuitBreaker.timestamp > data.market.block.timestamp
+        ? data.circuitBreaker.reason
         : null
   }
 
   // Getters
 
-  static async getByOwner(lyra: Lyra, marketAddress: string, owner: string): Promise<LiquidityWithdrawal[]> {
-    const market = await Market.get(lyra, marketAddress)
-    const liquidityPoolContract = getLyraMarketContract(
-      lyra,
-      market.contractAddresses,
-      lyra.version,
-      LyraMarketContractId.LiquidityPool
-    )
-    const [{ events }, cbTimestamp, marketLiquidity] = await Promise.all([
+  static async getByOwner(lyra: Lyra, market: Market, owner: string): Promise<LiquidityWithdrawal[]> {
+    const [{ events, circuitBreaker }, marketLiquidity] = await Promise.all([
       fetchLiquidityWithdrawalEventDataByOwner(lyra, owner, market),
-      liquidityPoolContract.CBTimestamp(),
       market.liquidity(),
     ])
-    return events.map(
-      event =>
-        new LiquidityWithdrawal(lyra, market, {
-          ...event,
-          cbTimestamp,
+    const liquidityDeposits = events.map(
+      events =>
+        new LiquidityWithdrawal(lyra, {
+          market,
+          events,
+          circuitBreaker,
           marketLiquidity,
         })
     )
+    return liquidityDeposits
   }
 
   // Transactions
diff --git a/sdk/src/lyra.ts b/sdk/src/lyra.ts
index e6ad6280..bd939063 100644
--- a/sdk/src/lyra.ts
+++ b/sdk/src/lyra.ts
@@ -33,11 +33,13 @@ import getLyraChainIdForChain from './utils/getLyraChainIdForChain'
 import getLyraDeploymentForChain from './utils/getLyraDeploymentForChain'
 import getLyraDeploymentProvider from './utils/getLyraDeploymentProvider'
 import getLyraDeploymentSubgraphURI from './utils/getLyraDeploymentSubgraphURI'
+import getLyraGovernanceSubgraphURI from './utils/getLyraGovernanceSubgraphURI'
 import getNetworkForChain from './utils/getLyraNetworkForChain'
 
 export type LyraConfig = {
   provider: JsonRpcProvider
   subgraphUri?: string
+  govSubgraphUri?: string
   apiUri?: string
   version?: Version
 }
@@ -55,6 +57,8 @@ export default class Lyra {
   provider: JsonRpcProvider
   subgraphUri: string
   subgraphClient: ApolloClient<NormalizedCacheObject>
+  govSubgraphUri: string
+  govSubgraphClient: ApolloClient<NormalizedCacheObject>
   apiUri: string
   deployment: Deployment
   network: Network
@@ -68,23 +72,32 @@ export default class Lyra {
       this.apiUri = configObj.apiUri ?? LYRA_API_URL
       this.version = config.version ?? getDefaultVersionForChain(this.chain)
       this.subgraphUri = configObj?.subgraphUri ?? getLyraDeploymentSubgraphURI(this.chain, this.version)
+      this.govSubgraphUri = configObj?.govSubgraphUri ?? getLyraGovernanceSubgraphURI(this.chain)
     } else if (typeof config === 'number') {
       // Chain ID
       this.chain = getLyraChainForChainId(config)
       this.provider = getLyraDeploymentProvider(this.chain)
       this.version = getDefaultVersionForChain(this.chain)
       this.subgraphUri = getLyraDeploymentSubgraphURI(this.chain, this.version)
+      this.govSubgraphUri = getLyraGovernanceSubgraphURI(this.chain)
     } else {
       // String
       this.chain = config
       this.provider = getLyraDeploymentProvider(this.chain)
       this.version = getDefaultVersionForChain(this.chain)
       this.subgraphUri = getLyraDeploymentSubgraphURI(this.chain, this.version)
+      this.govSubgraphUri = getLyraGovernanceSubgraphURI(this.chain)
     }
     this.subgraphClient = new ApolloClient({
+      connectToDevTools: true,
       link: new HttpLink({ uri: this.subgraphUri, fetch }),
       cache: new InMemoryCache(),
     })
+    this.govSubgraphClient = new ApolloClient({
+      connectToDevTools: true,
+      link: new HttpLink({ uri: this.govSubgraphUri, fetch }),
+      cache: new InMemoryCache(),
+    })
     this.network = getNetworkForChain(this.chain)
     this.apiUri = LYRA_API_URL
     this.chainId = getLyraChainIdForChain(this.chain)
@@ -243,10 +256,11 @@ export default class Lyra {
     return account.drip()
   }
 
-  // Liquidity Deposits
+  // Deposits
 
   async deposits(marketAddressOrName: string, owner: string): Promise<LiquidityDeposit[]> {
-    return await LiquidityDeposit.getByOwner(this, marketAddressOrName, owner)
+    const market = await this.market(marketAddressOrName)
+    return await LiquidityDeposit.getByOwner(this, market, owner)
   }
 
   async approveDeposit(
@@ -267,10 +281,11 @@ export default class Lyra {
     return market.initiateDeposit(beneficiary, amountQuote)
   }
 
-  // Liquidity Withdrawals
+  // Withdrawals
 
   async withdrawals(marketAddressOrName: string, owner: string): Promise<LiquidityWithdrawal[]> {
-    return await LiquidityWithdrawal.getByOwner(this, marketAddressOrName, owner)
+    const market = await this.market(marketAddressOrName)
+    return await LiquidityWithdrawal.getByOwner(this, market, owner)
   }
 
   async initiateWithdraw(
@@ -290,19 +305,15 @@ export default class Lyra {
 
   // Rewards
 
-  async claimRewards(address: string, tokenAddresses: string[]) {
-    return await AccountRewardEpoch.claim(this, address, tokenAddresses)
+  async claimRewards(owner: string, tokenAddresses: string[]) {
+    return await AccountRewardEpoch.claim(this, owner, tokenAddresses)
   }
 
   async globalRewardEpochs(): Promise<GlobalRewardEpoch[]> {
     return await GlobalRewardEpoch.getAll(this)
   }
 
-  async latestGlobalRewardEpoch(): Promise<GlobalRewardEpoch | null> {
-    return await GlobalRewardEpoch.getLatest(this)
-  }
-
-  async accountRewardEpochs(address: string): Promise<AccountRewardEpoch[]> {
-    return await AccountRewardEpoch.getByOwner(this, address)
+  async accountRewardEpochs(owner: string): Promise<AccountRewardEpoch[]> {
+    return await AccountRewardEpoch.getByOwner(this, owner)
   }
 }
diff --git a/sdk/src/market/index.ts b/sdk/src/market/index.ts
index 5128d027..0ad222af 100644
--- a/sdk/src/market/index.ts
+++ b/sdk/src/market/index.ts
@@ -62,7 +62,6 @@ export type MarketContractAddresses = {
 }
 
 export type MarketLiquiditySnapshot = {
-  market: Market
   tvl: BigNumber
   freeLiquidity: BigNumber
   burnableLiquidity: BigNumber
@@ -673,4 +672,12 @@ export class Market {
   async owner(): Promise<string> {
     return await fetchMarketOwner(this.lyra, this.contractAddresses)
   }
+
+  async deposits(owner: string): Promise<LiquidityDeposit[]> {
+    return await LiquidityDeposit.getByOwner(this.lyra, this, owner)
+  }
+
+  async withdrawals(owner: string): Promise<LiquidityWithdrawal[]> {
+    return await LiquidityWithdrawal.getByOwner(this.lyra, this, owner)
+  }
 }
diff --git a/sdk/src/utils/fetchAllLiquidityDepositEventDataByOwner.ts b/sdk/src/utils/fetchAllLiquidityDepositEventDataByOwner.ts
deleted file mode 100644
index 04954c94..00000000
--- a/sdk/src/utils/fetchAllLiquidityDepositEventDataByOwner.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { gql } from '@apollo/client/core'
-import { BigNumber } from 'ethers'
-
-import { ZERO_BN } from '../constants/bn'
-import { LIQUIDITY_DEPOSIT_FRAGMENT, LiquidityDepositQueryResult } from '../constants/queries'
-import { LiquidityDepositProcessedEvent, LiquidityDepositQueuedEvent } from '../liquidity_deposit'
-import Lyra from '../lyra'
-import { Market } from '../market'
-import subgraphRequest from './subgraphRequest'
-
-const lpUserLiquiditiesQuery = gql`
-  query lpuserLiquidities($user: String!, $pool: String!) {
-    lpuserLiquidities(where: { 
-      user: $user,
-      pool: $pool
-    }) {
-      ${LIQUIDITY_DEPOSIT_FRAGMENT}
-    }
-  }
-`
-
-type LiquidityDepositVariables = {
-  user: string
-  pool: string
-}
-
-export default async function fetchAllLiquidityDepositEventDataByOwner(
-  lyra: Lyra,
-  owner: string,
-  market: Market
-): Promise<{
-  queued: LiquidityDepositQueuedEvent[]
-  processed: LiquidityDepositProcessedEvent[]
-}> {
-  const { data } = await subgraphRequest<
-    { lpuserLiquidities: LiquidityDepositQueryResult[] },
-    LiquidityDepositVariables
-  >(lyra.subgraphClient, {
-    query: lpUserLiquiditiesQuery,
-    variables: {
-      user: owner.toLowerCase(),
-      pool: market.contractAddresses.liquidityPool.toLowerCase(),
-    },
-  })
-
-  const depositQueuedEvents =
-    data?.lpuserLiquidities[0]?.pendingDepositsAndWithdrawals.map(queuedDeposit => {
-      return {
-        depositor: owner,
-        beneficiary: owner,
-        depositQueueId: BigNumber.from(queuedDeposit.queueID),
-        amountDeposited: BigNumber.from(queuedDeposit.pendingAmount),
-        totalQueuedDeposits: ZERO_BN,
-        timestamp: BigNumber.from(queuedDeposit.timestamp),
-        transactionHash: queuedDeposit.transactionHash,
-      }
-    }) ?? []
-
-  const depositProcessedEvents =
-    data?.lpuserLiquidities[0]?.depositsAndWithdrawals.map(processedDeposit => {
-      return {
-        caller: owner,
-        beneficiary: owner,
-        depositQueueId: ZERO_BN,
-        amountDeposited: BigNumber.from(processedDeposit.quoteAmount),
-        tokenPrice: BigNumber.from(processedDeposit.tokenPrice),
-        tokensReceived: BigNumber.from(processedDeposit.tokenAmount),
-        timestamp: BigNumber.from(processedDeposit.timestamp),
-        transactionHash: processedDeposit.transactionHash,
-      }
-    }) ?? []
-
-  return {
-    queued: depositQueuedEvents,
-    processed: depositProcessedEvents,
-  }
-}
diff --git a/sdk/src/utils/fetchAllLiquidityWithdrawalEventDataByOwner.ts b/sdk/src/utils/fetchAllLiquidityWithdrawalEventDataByOwner.ts
deleted file mode 100644
index d97dc733..00000000
--- a/sdk/src/utils/fetchAllLiquidityWithdrawalEventDataByOwner.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import { gql } from '@apollo/client/core'
-import { BigNumber } from 'ethers'
-
-import { ZERO_BN } from '../constants/bn'
-import { LIQUIDITY_WITHDRAWAL_FRAGMENT, LiquidityWithdrawalQueryResult } from '../constants/queries'
-import { LiquidityWithdrawalProcessedEvent, LiquidityWithdrawalQueuedEvent } from '../liquidity_withdrawal'
-import Lyra from '../lyra'
-import { Market } from '../market'
-import subgraphRequest from './subgraphRequest'
-
-const lpUserLiquiditiesQuery = gql`
-  query lpuserLiquidities($user: String!, $pool: String!) {
-    lpuserLiquidities(where: { 
-      user: $user,
-      pool: $pool
-    }) {
-      ${LIQUIDITY_WITHDRAWAL_FRAGMENT}
-    }
-  }
-`
-
-type LiquidityWithdrawalVariables = {
-  user: string
-  pool: string
-}
-
-export default async function fetchAllLiquidityWithdrawalEventDataByOwner(
-  lyra: Lyra,
-  owner: string,
-  market: Market
-): Promise<{
-  queued: LiquidityWithdrawalQueuedEvent[]
-  processed: LiquidityWithdrawalProcessedEvent[]
-}> {
-  const { data } = await subgraphRequest<
-    { lpuserLiquidities: LiquidityWithdrawalQueryResult[] },
-    LiquidityWithdrawalVariables
-  >(lyra.subgraphClient, {
-    query: lpUserLiquiditiesQuery,
-    variables: {
-      user: owner.toLowerCase(),
-      pool: market.contractAddresses.liquidityPool.toLowerCase(),
-    },
-  })
-
-  const withdrawalQueuedEvents =
-    data?.lpuserLiquidities[0]?.pendingDepositsAndWithdrawals.map(queuedWithdrawal => {
-      return {
-        withdrawer: owner,
-        beneficiary: owner,
-        withdrawalQueueId: BigNumber.from(queuedWithdrawal.queueID),
-        amountWithdrawn: BigNumber.from(queuedWithdrawal.pendingAmount),
-        totalQueuedWithdrawals: ZERO_BN,
-        timestamp: BigNumber.from(queuedWithdrawal.timestamp),
-        transactionHash: queuedWithdrawal.transactionHash,
-      }
-    }) ?? []
-
-  const withdrawalProcessedEvents =
-    data?.lpuserLiquidities[0]?.depositsAndWithdrawals.map(processedWithdrawal => {
-      return {
-        caller: owner,
-        beneficiary: owner,
-        withdrawalQueueId: ZERO_BN,
-        amountWithdrawn: BigNumber.from(processedWithdrawal.quoteAmount),
-        tokenPrice: BigNumber.from(processedWithdrawal.tokenPrice),
-        quoteReceived: BigNumber.from(processedWithdrawal.tokenAmount),
-        totalQueuedWithdrawals: ZERO_BN,
-        timestamp: BigNumber.from(processedWithdrawal.timestamp),
-        transactionHash: processedWithdrawal.transactionHash,
-      }
-    }) ?? []
-
-  return {
-    queued: withdrawalQueuedEvents,
-    processed: withdrawalProcessedEvents,
-  }
-}
diff --git a/sdk/src/utils/fetchClaimAddedEvents.ts b/sdk/src/utils/fetchClaimAddedEvents.ts
index 7cf61a49..37dcc7d4 100644
--- a/sdk/src/utils/fetchClaimAddedEvents.ts
+++ b/sdk/src/utils/fetchClaimAddedEvents.ts
@@ -1,11 +1,9 @@
-import { ApolloClient, gql, HttpLink, InMemoryCache } from '@apollo/client/core'
+import { gql } from '@apollo/client/core'
 import { BigNumber } from 'ethers'
 
 import { ClaimAddedEvent } from '../account_reward_epoch'
-import { Chain } from '../constants/chain'
 import { CLAIM_ADDED_FRAGMENT, ClaimAddedQueryResult } from '../constants/queries'
 import Lyra from '../lyra'
-import getLyraGovernanceSubgraphURI from './getLyraGovernanceSubgraphURI'
 import subgraphRequest from './subgraphRequest'
 
 const claimAddedQuery = gql`
@@ -22,21 +20,16 @@ type ClaimAddedVariables = {
   user: string
 }
 
-export default async function fetchClaimAddedEvents(
-  lyra: Lyra,
-  chain: Chain,
-  address: string
-): Promise<ClaimAddedEvent[]> {
-  const client = new ApolloClient({
-    link: new HttpLink({ uri: getLyraGovernanceSubgraphURI(lyra, chain), fetch }),
-    cache: new InMemoryCache(),
-  })
-  const { data } = await subgraphRequest<{ claimAddeds: ClaimAddedQueryResult[] }, ClaimAddedVariables>(client, {
-    query: claimAddedQuery,
-    variables: {
-      user: address.toLowerCase(),
-    },
-  })
+export default async function fetchClaimAddedEvents(lyra: Lyra, address: string): Promise<ClaimAddedEvent[]> {
+  const { data } = await subgraphRequest<{ claimAddeds: ClaimAddedQueryResult[] }, ClaimAddedVariables>(
+    lyra.govSubgraphClient,
+    {
+      query: claimAddedQuery,
+      variables: {
+        user: address.toLowerCase(),
+      },
+    }
+  )
   return (
     data?.claimAddeds
       .map(ev => ({
diff --git a/sdk/src/utils/fetchClaimEvents.ts b/sdk/src/utils/fetchClaimEvents.ts
index 0a1ea35e..6249ba8a 100644
--- a/sdk/src/utils/fetchClaimEvents.ts
+++ b/sdk/src/utils/fetchClaimEvents.ts
@@ -1,11 +1,9 @@
-import { ApolloClient, gql, HttpLink, InMemoryCache } from '@apollo/client/core'
+import { gql } from '@apollo/client/core'
 import { BigNumber } from 'ethers'
 
 import { ClaimEvent } from '../account_reward_epoch'
-import { Chain } from '../constants/chain'
 import { CLAIM_FRAGMENT, ClaimAddedQueryResult } from '../constants/queries'
 import Lyra from '../lyra'
-import getLyraGovernanceSubgraphURI from './getLyraGovernanceSubgraphURI'
 import subgraphRequest from './subgraphRequest'
 
 const claimQuery = gql`
@@ -22,17 +20,16 @@ type ClaimAddedVariables = {
   user: string
 }
 
-export default async function fetchClaimEvents(lyra: Lyra, chain: Chain, address: string): Promise<ClaimEvent[]> {
-  const client = new ApolloClient({
-    link: new HttpLink({ uri: getLyraGovernanceSubgraphURI(lyra, chain), fetch }),
-    cache: new InMemoryCache(),
-  })
-  const { data } = await subgraphRequest<{ claims: ClaimAddedQueryResult[] }, ClaimAddedVariables>(client, {
-    query: claimQuery,
-    variables: {
-      user: address.toLowerCase(),
-    },
-  })
+export default async function fetchClaimEvents(lyra: Lyra, address: string): Promise<ClaimEvent[]> {
+  const { data } = await subgraphRequest<{ claims: ClaimAddedQueryResult[] }, ClaimAddedVariables>(
+    lyra.govSubgraphClient,
+    {
+      query: claimQuery,
+      variables: {
+        user: address.toLowerCase(),
+      },
+    }
+  )
   return (
     data?.claims.map(ev => ({
       amount: BigNumber.from(ev.amount),
diff --git a/sdk/src/utils/fetchLatestLiquidity.ts b/sdk/src/utils/fetchLatestLiquidity.ts
index d8000790..9bd7b2e3 100644
--- a/sdk/src/utils/fetchLatestLiquidity.ts
+++ b/sdk/src/utils/fetchLatestLiquidity.ts
@@ -27,7 +27,7 @@ const marketTotalValueSnapshotsQuery = gql`
   }
 `
 
-const EMPTY: Omit<MarketLiquiditySnapshot, 'market' | 'timestamp'> = {
+const EMPTY: Omit<MarketLiquiditySnapshot, 'timestamp'> = {
   tvl: ZERO_BN,
   freeLiquidity: ZERO_BN,
   burnableLiquidity: ZERO_BN,
@@ -44,7 +44,6 @@ export default async function fetchLatestLiquidity(lyra: Lyra, market: Market):
   if (market.liveBoards().length === 0) {
     // No boards, deposits only
     return {
-      market,
       tvl: market.params.NAV,
       freeLiquidity: market.params.NAV,
       burnableLiquidity: ZERO_BN,
@@ -70,7 +69,7 @@ export default async function fetchLatestLiquidity(lyra: Lyra, market: Market):
   })
 
   if (!data || data.marketTotalValueSnapshots.length === 0) {
-    return { ...EMPTY, market, timestamp: market.block.timestamp }
+    return { ...EMPTY, timestamp: market.block.timestamp }
   }
 
   const latestLiquiditySnapshot = data.marketTotalValueSnapshots[0]
@@ -83,7 +82,6 @@ export default async function fetchLatestLiquidity(lyra: Lyra, market: Market):
   const tokenPrice = BigNumber.from(latestLiquiditySnapshot.tokenPrice)
 
   return {
-    market,
     timestamp: latestLiquiditySnapshot.timestamp,
     freeLiquidity,
     burnableLiquidity,
diff --git a/sdk/src/utils/fetchLatestLiquidityDepositEventDataByOwner.ts b/sdk/src/utils/fetchLatestLiquidityDepositEventDataByOwner.ts
deleted file mode 100644
index 57cefcec..00000000
--- a/sdk/src/utils/fetchLatestLiquidityDepositEventDataByOwner.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import Lyra from '..'
-import { LyraMarketContractId } from '../constants/contracts'
-import { LiquidityDepositProcessedEvent, LiquidityDepositQueuedEvent } from '../liquidity_deposit'
-import { Market } from '../market'
-import getLyraMarketContract from './getLyraMarketContract'
-
-const BLOCK_LIMIT = 100
-
-export default async function fetchLatestLiquidityDepositEventDataByOwner(
-  lyra: Lyra,
-  owner: string,
-  market: Market
-): Promise<{
-  queued: LiquidityDepositQueuedEvent[]
-  processed: LiquidityDepositProcessedEvent[]
-}> {
-  const liquidityPoolContract = getLyraMarketContract(
-    lyra,
-    market.contractAddresses,
-    lyra.version,
-    LyraMarketContractId.LiquidityPool
-  )
-
-  // Approximately last 1 min of events
-  const toBlockNumber = (await lyra.provider.getBlock('latest')).number
-  const fromBlockNumber = toBlockNumber - BLOCK_LIMIT
-
-  const [depositQueuedEvents, depositProcessedEvents] = await Promise.all([
-    liquidityPoolContract.queryFilter(
-      liquidityPoolContract.filters.DepositQueued(null, owner),
-      fromBlockNumber,
-      toBlockNumber
-    ),
-    liquidityPoolContract.queryFilter(
-      liquidityPoolContract.filters.DepositProcessed(null, owner),
-      fromBlockNumber,
-      toBlockNumber
-    ),
-  ])
-
-  const liquidityDepositQueuedEvents: LiquidityDepositQueuedEvent[] = depositQueuedEvents.map(event => {
-    return {
-      depositor: event.args.depositor,
-      beneficiary: event.args.beneficiary,
-      depositQueueId: event.args.depositQueueId,
-      amountDeposited: event.args.amountDeposited,
-      totalQueuedDeposits: event.args.totalQueuedDeposits,
-      timestamp: event.args.timestamp,
-      transactionHash: event.transactionHash,
-    }
-  })
-
-  const liquidityDepositProcessedEvents: LiquidityDepositProcessedEvent[] = depositProcessedEvents.map(event => {
-    return {
-      caller: event.args.caller,
-      beneficiary: event.args.beneficiary,
-      depositQueueId: event.args.depositQueueId,
-      amountDeposited: event.args.amountDeposited,
-      tokenPrice: event.args.tokenPrice,
-      tokensReceived: event.args.tokensReceived,
-      timestamp: event.args.timestamp,
-      transactionHash: event.transactionHash,
-    }
-  })
-
-  return {
-    queued: liquidityDepositQueuedEvents,
-    processed: liquidityDepositProcessedEvents,
-  }
-}
diff --git a/sdk/src/utils/fetchLatestLiquidityWithdrawalEventDataByOwner.ts b/sdk/src/utils/fetchLatestLiquidityWithdrawalEventDataByOwner.ts
deleted file mode 100644
index 5697f4ee..00000000
--- a/sdk/src/utils/fetchLatestLiquidityWithdrawalEventDataByOwner.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import Lyra from '..'
-import { LyraMarketContractId } from '../constants/contracts'
-import { LiquidityWithdrawalProcessedEvent, LiquidityWithdrawalQueuedEvent } from '../liquidity_withdrawal'
-import { Market } from '../market'
-import getLyraMarketContract from './getLyraMarketContract'
-
-const BLOCK_LIMIT = 100
-
-export default async function fetchLatestLiquidityWithdrawalEventDataByOwner(
-  lyra: Lyra,
-  owner: string,
-  market: Market
-): Promise<{
-  queued: LiquidityWithdrawalQueuedEvent[]
-  processed: LiquidityWithdrawalProcessedEvent[]
-}> {
-  const liquidityPoolContract = getLyraMarketContract(
-    lyra,
-    market.contractAddresses,
-    lyra.version,
-    LyraMarketContractId.LiquidityPool
-  )
-
-  // Approximately last 1 min of events
-  const toBlockNumber = (await lyra.provider.getBlock('latest')).number
-  const fromBlockNumber = toBlockNumber - BLOCK_LIMIT
-
-  const [withdrawalQueuedEvents, withdrawalProcessedEvents] = await Promise.all([
-    liquidityPoolContract.queryFilter(
-      liquidityPoolContract.filters.WithdrawQueued(null, owner),
-      fromBlockNumber,
-      toBlockNumber
-    ),
-    liquidityPoolContract.queryFilter(
-      liquidityPoolContract.filters.WithdrawProcessed(null, owner),
-      fromBlockNumber,
-      toBlockNumber
-    ),
-  ])
-
-  const liquidityWithdrawalQueuedEvents: LiquidityWithdrawalQueuedEvent[] = withdrawalQueuedEvents.map(event => {
-    return {
-      withdrawer: event.args.withdrawer,
-      beneficiary: event.args.beneficiary,
-      withdrawalQueueId: event.args.withdrawalQueueId,
-      amountWithdrawn: event.args.amountWithdrawn,
-      totalQueuedWithdrawals: event.args.totalQueuedWithdrawals,
-      timestamp: event.args.timestamp,
-      transactionHash: event.transactionHash,
-    }
-  })
-
-  const liquidityWithdrawalProcessedEvents: LiquidityWithdrawalProcessedEvent[] = withdrawalProcessedEvents.map(
-    event => {
-      return {
-        caller: event.args.caller,
-        beneficiary: event.args.beneficiary,
-        withdrawalQueueId: event.args.withdrawalQueueId,
-        amountWithdrawn: event.args.amountWithdrawn,
-        tokenPrice: event.args.tokenPrice,
-        quoteReceived: event.args.quoteReceived,
-        totalQueuedWithdrawals: event.args.totalQueuedWithdrawals,
-        timestamp: event.args.timestamp,
-        transactionHash: event.transactionHash,
-      }
-    }
-  )
-
-  return {
-    queued: liquidityWithdrawalQueuedEvents,
-    processed: liquidityWithdrawalProcessedEvents,
-  }
-}
diff --git a/sdk/src/utils/fetchLiquidityDepositEventDataByOwner.ts b/sdk/src/utils/fetchLiquidityDepositEventDataByOwner.ts
index 4e7cd485..046be303 100644
--- a/sdk/src/utils/fetchLiquidityDepositEventDataByOwner.ts
+++ b/sdk/src/utils/fetchLiquidityDepositEventDataByOwner.ts
@@ -1,73 +1,161 @@
-import Lyra from '..'
+import { gql } from '@apollo/client/core'
+import { BigNumber } from 'ethers'
+
 import { ZERO_BN } from '../constants/bn'
 import {
-  DepositQueuedOrProcessedEvent,
+  CIRCUIT_BREAKER_FRAGMENT,
+  CircuitBreakerQueryResult,
+  LIQUIDITY_DEPOSIT_FRAGMENT,
+  LiquidityDepositQueryResult,
+} from '../constants/queries'
+import {
+  LiquidityCircuitBreaker,
+  LiquidityDelayReason,
+  LiquidityDepositEvents,
   LiquidityDepositProcessedEvent,
   LiquidityDepositQueuedEvent,
 } from '../liquidity_deposit'
+import Lyra from '../lyra'
 import { Market } from '../market'
-import fetchAllLiquidityDepositEventDataByOwner from './fetchAllLiquidityDepositEventDataByOwner'
-import fetchLatestLiquidityDepositEventDataByOwner from './fetchLatestLiquidityDepositEventDataByOwner'
-import getUniqueBy from './getUniqueBy'
+import subgraphRequest from './subgraphRequest'
+
+const lpUserLiquiditiesQuery = gql`
+  query lpuserLiquidities($user: String!, $pool: String!) {
+    lpuserLiquidities(where: { 
+      user: $user,
+      pool: $pool
+    }) {
+      ${LIQUIDITY_DEPOSIT_FRAGMENT}
+    }
+    circuitBreakers(first: 1, where: {
+      pool: $pool
+    }) {
+      ${CIRCUIT_BREAKER_FRAGMENT}
+    }
+  }
+`
+
+type LiquidityDepositVariables = {
+  user: string
+  pool: string
+}
 
 export default async function fetchLiquidityDepositEventDataByOwner(
   lyra: Lyra,
   owner: string,
   market: Market
-): Promise<{
-  events: DepositQueuedOrProcessedEvent[]
-}> {
-  const [latestLiquidityDeposit, allLiquidityDeposits] = await Promise.all([
-    // Contract (realtime) data
-    fetchLatestLiquidityDepositEventDataByOwner(lyra, owner, market),
-    // Subgraph data
-    fetchAllLiquidityDepositEventDataByOwner(lyra, owner, market),
-  ])
+): Promise<{ events: LiquidityDepositEvents[]; circuitBreaker: LiquidityCircuitBreaker | null }> {
+  const { data } = await subgraphRequest<
+    { lpuserLiquidities: LiquidityDepositQueryResult[]; circuitBreakers: CircuitBreakerQueryResult[] },
+    LiquidityDepositVariables
+  >(lyra.subgraphClient, {
+    query: lpUserLiquiditiesQuery,
+    variables: {
+      user: owner.toLowerCase(),
+      pool: market.contractAddresses.liquidityPool.toLowerCase(),
+    },
+  })
 
-  const uniqueQueuedDeposits = getUniqueBy(
-    latestLiquidityDeposit.queued.concat(allLiquidityDeposits.queued),
-    deposit => deposit?.timestamp
-  )
-  const uniqueProcessedDeposits = getUniqueBy(
-    latestLiquidityDeposit.processed.concat(allLiquidityDeposits.processed),
-    deposit => deposit?.timestamp
-  )
+  const userLiquidity = data?.lpuserLiquidities[0]
+  const circuitBreakerData = data?.circuitBreakers[0]
 
-  const depositQueuedMap: Record<string, LiquidityDepositQueuedEvent> = {}
-  const depositProcessedMap: Record<string, LiquidityDepositProcessedEvent> = {}
-  const depositQueuedOrProcessedEvents: DepositQueuedOrProcessedEvent[] = []
-  uniqueProcessedDeposits.forEach((depositProcessedEvent: LiquidityDepositProcessedEvent) => {
-    if (depositProcessedEvent?.depositQueueId.eq(ZERO_BN)) {
-      depositQueuedOrProcessedEvents.push({
-        processed: depositProcessedEvent,
-      })
-    }
-  })
+  const circuitBreaker: LiquidityCircuitBreaker | null = circuitBreakerData
+    ? {
+        timestamp: circuitBreakerData.cbTimestamp,
+        reason:
+          circuitBreakerData.ivVarianceCrossed || circuitBreakerData.skewVarianceCrossed
+            ? LiquidityDelayReason.Volatility
+            : circuitBreakerData.liquidityVarianceCrossed
+            ? LiquidityDelayReason.Liquidity
+            : LiquidityDelayReason.Keeper,
+      }
+    : null
 
-  uniqueQueuedDeposits.forEach((depositQueuedEvent: LiquidityDepositQueuedEvent) => {
-    const id = String(depositQueuedEvent?.depositQueueId)
-    depositQueuedMap[id] = depositQueuedEvent
-  })
+  if (!userLiquidity) {
+    return { circuitBreaker, events: [] }
+  }
 
-  uniqueProcessedDeposits.forEach((depositProcessedEvent: LiquidityDepositProcessedEvent) => {
-    const id = String(depositProcessedEvent?.depositQueueId)
-    depositProcessedMap[id] = depositProcessedEvent
-  })
+  const depositQueuedEvents =
+    userLiquidity.pendingDepositsAndWithdrawals.map(queuedDeposit => {
+      return {
+        depositor: owner,
+        beneficiary: owner,
+        queueId: parseInt(queuedDeposit.queueID, 10),
+        amountDeposited: BigNumber.from(queuedDeposit.pendingAmount),
+        totalQueuedDeposits: ZERO_BN,
+        timestamp: queuedDeposit.timestamp,
+        transactionHash: queuedDeposit.transactionHash,
+      }
+    }) ?? []
+
+  const depositProcessedEvents =
+    userLiquidity.depositsAndWithdrawals.map(processedDeposit => {
+      return {
+        caller: owner,
+        beneficiary: owner,
+        queueId: parseInt(processedDeposit.queueID, 10),
+        amountDeposited: BigNumber.from(processedDeposit.quoteAmount),
+        tokenPrice: BigNumber.from(processedDeposit.tokenPrice),
+        tokensReceived: BigNumber.from(processedDeposit.tokenAmount),
+        timestamp: processedDeposit.timestamp,
+        transactionHash: processedDeposit.transactionHash,
+      }
+    }) ?? []
+
+  const depositQueuedEventMap: Record<number, LiquidityDepositQueuedEvent> = depositQueuedEvents.reduce(
+    (map, depositQueuedEvent) => ({
+      ...map,
+      [depositQueuedEvent.queueId]: depositQueuedEvent,
+    }),
+    {}
+  )
 
-  uniqueQueuedDeposits.forEach((depositQueuedEvent: LiquidityDepositQueuedEvent) => {
-    const id = String(depositQueuedEvent?.depositQueueId)
-    if (depositQueuedMap[id] && depositProcessedMap[id]) {
-      depositQueuedOrProcessedEvents.push({
-        queued: depositQueuedMap[id],
-        processed: depositProcessedMap[id],
-      })
-    } else if (depositQueuedMap[id] && !depositProcessedMap[id]) {
-      depositQueuedOrProcessedEvents.push({
-        queued: depositQueuedMap[id],
-      })
+  const depositProcessedEventMap: Record<number, LiquidityDepositProcessedEvent> = depositProcessedEvents.reduce(
+    (map, depositProcessedEvent) => {
+      if (depositProcessedEvent.queueId === 0) {
+        return map
+      } else {
+        return {
+          ...map,
+          [depositProcessedEvent.queueId]: depositProcessedEvent,
+        }
+      }
+    },
+    {}
+  )
+
+  const instantDepositEvents: LiquidityDepositEvents[] = depositProcessedEvents.map(processed => ({
+    processed,
+    isProcessed: true,
+    isInstant: true,
+  }))
+
+  const depositEvents: LiquidityDepositEvents[] = Object.entries(depositQueuedEventMap).map(
+    ([depositQueueId, queued]) => {
+      const processed = depositProcessedEventMap[parseInt(depositQueueId, 10)]
+      if (processed) {
+        return {
+          queued,
+          processed,
+          isProcessed: true,
+          isInstant: false,
+        }
+      } else {
+        return {
+          queued,
+          isProcessed: false,
+          isInstant: false,
+        }
+      }
     }
-  })
+  )
+
   return {
-    events: depositQueuedOrProcessedEvents,
+    events: instantDepositEvents.concat(depositEvents).sort((a, b) => {
+      const bTimestamp = b.isProcessed ? b.processed.timestamp : b.queued.timestamp
+      const aTimestamp = a.isProcessed ? a.processed.timestamp : a.queued.timestamp
+      return bTimestamp - aTimestamp
+    }),
+    circuitBreaker,
   }
 }
diff --git a/sdk/src/utils/fetchLiquidityHistory.ts b/sdk/src/utils/fetchLiquidityHistory.ts
index 3693445a..467f4851 100644
--- a/sdk/src/utils/fetchLiquidityHistory.ts
+++ b/sdk/src/utils/fetchLiquidityHistory.ts
@@ -64,7 +64,7 @@ export default async function fetchLiquidityHistory(
 
   if (data.length === 0) {
     // Always return at least 1 snapshot
-    return [{ ...EMPTY, market, timestamp: market.block.timestamp }]
+    return [{ ...EMPTY, timestamp: market.block.timestamp }]
   }
 
   const marketLiquidity = data.map(marketTotalValueSnapshot => {
@@ -77,7 +77,6 @@ export default async function fetchLiquidityHistory(
     const usedDeltaLiquidityBN = BigNumber.from(marketTotalValueSnapshot.usedDeltaLiquidity)
     const tokenPriceBN = BigNumber.from(marketTotalValueSnapshot.tokenPrice)
     return {
-      market,
       freeLiquidity: freeLiquidityBN,
       burnableLiquidity: burnableLiquidityBN,
       tvl,
diff --git a/sdk/src/utils/fetchLiquidityWithdrawalEventDataByOwner.ts b/sdk/src/utils/fetchLiquidityWithdrawalEventDataByOwner.ts
index 1de030ab..826f058f 100644
--- a/sdk/src/utils/fetchLiquidityWithdrawalEventDataByOwner.ts
+++ b/sdk/src/utils/fetchLiquidityWithdrawalEventDataByOwner.ts
@@ -1,75 +1,162 @@
-import Lyra from '..'
+import { gql } from '@apollo/client/core'
+import { BigNumber } from 'ethers'
+
 import { ZERO_BN } from '../constants/bn'
 import {
+  CIRCUIT_BREAKER_FRAGMENT,
+  CircuitBreakerQueryResult,
+  LIQUIDITY_WITHDRAWAL_FRAGMENT,
+  LiquidityWithdrawalQueryResult,
+} from '../constants/queries'
+import { LiquidityCircuitBreaker, LiquidityDelayReason } from '../liquidity_deposit'
+import {
+  LiquidityWithdrawalEvents,
   LiquidityWithdrawalProcessedEvent,
   LiquidityWithdrawalQueuedEvent,
-  WithdrawalQueuedOrProcessedEvent,
 } from '../liquidity_withdrawal'
+import Lyra from '../lyra'
 import { Market } from '../market'
-import fetchAllLiquidityWithdrawalEventDataByOwner from './fetchAllLiquidityWithdrawalEventDataByOwner'
-import fetchLatestLiquidityWithdrawalEventDataByOwner from './fetchLatestLiquidityWithdrawalEventDataByOwner'
-import getUniqueBy from './getUniqueBy'
+import subgraphRequest from './subgraphRequest'
+
+const lpUserLiquiditiesQuery = gql`
+  query lpuserLiquidities($user: String!, $pool: String!) {
+    lpuserLiquidities(where: { 
+      user: $user,
+      pool: $pool
+    }) {
+      ${LIQUIDITY_WITHDRAWAL_FRAGMENT}
+    }
+    circuitBreakers(first: 1, where: {
+      pool: $pool
+    }) {
+      ${CIRCUIT_BREAKER_FRAGMENT}
+    }
+  }
+`
+
+type LiquidityWithdrawalVariables = {
+  user: string
+  pool: string
+}
 
 export default async function fetchLiquidityWithdrawalEventDataByOwner(
   lyra: Lyra,
   owner: string,
   market: Market
 ): Promise<{
-  events: WithdrawalQueuedOrProcessedEvent[]
+  events: LiquidityWithdrawalEvents[]
+  circuitBreaker: LiquidityCircuitBreaker | null
 }> {
-  const [latestLiquidityWithdrawal, allLiquidityWithdrawals] = await Promise.all([
-    // Contract (realtime) data
-    fetchLatestLiquidityWithdrawalEventDataByOwner(lyra, owner, market),
-    // Subgraph data
-    fetchAllLiquidityWithdrawalEventDataByOwner(lyra, owner, market),
-  ])
+  const { data } = await subgraphRequest<
+    { lpuserLiquidities: LiquidityWithdrawalQueryResult[]; circuitBreakers: CircuitBreakerQueryResult[] },
+    LiquidityWithdrawalVariables
+  >(lyra.subgraphClient, {
+    query: lpUserLiquiditiesQuery,
+    variables: {
+      user: owner.toLowerCase(),
+      pool: market.contractAddresses.liquidityPool.toLowerCase(),
+    },
+  })
 
-  const uniqueQueuedWithdrawals = getUniqueBy(
-    latestLiquidityWithdrawal.queued.concat(allLiquidityWithdrawals.queued),
-    withdrawal => withdrawal?.timestamp
-  )
-  const uniqueProcessedWithdrawals = getUniqueBy(
-    latestLiquidityWithdrawal.processed.concat(allLiquidityWithdrawals.processed),
-    withdrawal => withdrawal?.timestamp
-  )
+  const userLiquidity = data?.lpuserLiquidities[0]
+  const circuitBreakerData = data?.circuitBreakers[0]
 
-  const withdrawalQueuedMap: Record<string, LiquidityWithdrawalQueuedEvent> = {}
-  const withdrawalProcessedMap: Record<string, LiquidityWithdrawalProcessedEvent> = {}
-  const withdrawalQueuedOrProcessedEvents: WithdrawalQueuedOrProcessedEvent[] = []
+  const circuitBreaker: LiquidityCircuitBreaker | null = circuitBreakerData
+    ? {
+        timestamp: circuitBreakerData.cbTimestamp,
+        reason:
+          circuitBreakerData.ivVarianceCrossed || circuitBreakerData.skewVarianceCrossed
+            ? LiquidityDelayReason.Volatility
+            : circuitBreakerData.liquidityVarianceCrossed
+            ? LiquidityDelayReason.Liquidity
+            : LiquidityDelayReason.Keeper,
+      }
+    : null
 
-  uniqueProcessedWithdrawals.forEach((withdrawalProcessedEvent: LiquidityWithdrawalProcessedEvent) => {
-    if (withdrawalProcessedEvent?.withdrawalQueueId == ZERO_BN) {
-      withdrawalQueuedOrProcessedEvents.push({
-        processed: withdrawalProcessedEvent,
-      })
-    }
-  })
+  if (!userLiquidity) {
+    return { circuitBreaker, events: [] }
+  }
 
-  uniqueQueuedWithdrawals.forEach((withdrawalQueuedEvent: LiquidityWithdrawalQueuedEvent) => {
-    const id = String(withdrawalQueuedEvent?.withdrawalQueueId)
-    withdrawalQueuedMap[id] = withdrawalQueuedEvent
-  })
+  const withdrawalQueuedEvents =
+    userLiquidity.pendingDepositsAndWithdrawals.map(queuedWithdrawal => {
+      return {
+        withdrawer: owner,
+        beneficiary: owner,
+        queueId: parseInt(queuedWithdrawal.queueID, 10),
+        amountWithdrawn: BigNumber.from(queuedWithdrawal.pendingAmount),
+        totalQueuedWithdrawals: ZERO_BN,
+        timestamp: queuedWithdrawal.timestamp,
+        transactionHash: queuedWithdrawal.transactionHash,
+      }
+    }) ?? []
 
-  uniqueProcessedWithdrawals.forEach((withdrawalProcessedEvent: LiquidityWithdrawalProcessedEvent) => {
-    const id = String(withdrawalProcessedEvent?.withdrawalQueueId)
-    withdrawalProcessedMap[id] = withdrawalProcessedEvent
-  })
+  const withdrawalProcessedEvents =
+    userLiquidity.depositsAndWithdrawals.map(processedWithdrawal => {
+      return {
+        caller: owner,
+        beneficiary: owner,
+        queueId: parseInt(processedWithdrawal.queueID, 10),
+        amountWithdrawn: BigNumber.from(processedWithdrawal.quoteAmount),
+        tokenPrice: BigNumber.from(processedWithdrawal.tokenPrice),
+        quoteReceived: BigNumber.from(processedWithdrawal.tokenAmount),
+        totalQueuedWithdrawals: ZERO_BN,
+        timestamp: processedWithdrawal.timestamp,
+        transactionHash: processedWithdrawal.transactionHash,
+      }
+    }) ?? []
 
-  uniqueQueuedWithdrawals.forEach((withdrawalQueuedEvent: LiquidityWithdrawalQueuedEvent) => {
-    const id = String(withdrawalQueuedEvent?.withdrawalQueueId)
-    if (withdrawalQueuedMap[id] && withdrawalProcessedMap[id]) {
-      withdrawalQueuedOrProcessedEvents.push({
-        queued: withdrawalQueuedMap[id],
-        processed: withdrawalProcessedMap[id],
-      })
-    } else if (withdrawalQueuedMap[id] && !withdrawalProcessedMap[id]) {
-      withdrawalQueuedOrProcessedEvents.push({
-        queued: withdrawalQueuedMap[id],
-      })
+  const withdrawalQueuedEventMap: Record<number, LiquidityWithdrawalQueuedEvent> = withdrawalQueuedEvents.reduce(
+    (map, withdrawalQueuedEvent) => ({
+      ...map,
+      [withdrawalQueuedEvent.queueId]: withdrawalQueuedEvent,
+    }),
+    {}
+  )
+
+  const withdrawalProcessedEventMap: Record<number, LiquidityWithdrawalProcessedEvent> =
+    withdrawalProcessedEvents.reduce((map, withdrawalProcessedEvent) => {
+      if (withdrawalProcessedEvent.queueId === 0) {
+        return map
+      } else {
+        return {
+          ...map,
+          [withdrawalProcessedEvent.queueId]: withdrawalProcessedEvent,
+        }
+      }
+    }, {})
+
+  const instantDepositEvents: LiquidityWithdrawalEvents[] = withdrawalProcessedEvents.map(processed => ({
+    processed,
+    isProcessed: true,
+    isInstant: true,
+  }))
+
+  const withdrawalEvents: LiquidityWithdrawalEvents[] = Object.entries(withdrawalQueuedEventMap).map(
+    ([withdrawalQueueId, queued]) => {
+      const processed = withdrawalProcessedEventMap[parseInt(withdrawalQueueId, 10)]
+      if (processed) {
+        return {
+          queued,
+          processed,
+          isProcessed: true,
+          isInstant: false,
+        }
+      } else {
+        return {
+          queued,
+          isProcessed: false,
+          isInstant: false,
+        }
+      }
     }
-  })
+  )
 
   return {
-    events: withdrawalQueuedOrProcessedEvents,
+    events: instantDepositEvents.concat(withdrawalEvents).sort((a, b) => {
+      const bTimestamp = b.isProcessed ? b.processed.timestamp : b.queued.timestamp
+      const aTimestamp = a.isProcessed ? a.processed.timestamp : a.queued.timestamp
+      return bTimestamp - aTimestamp
+    }),
+    circuitBreaker,
   }
 }
diff --git a/sdk/src/utils/fetchStkLyraBalance.ts b/sdk/src/utils/fetchStkLyraBalance.ts
deleted file mode 100644
index bab89706..00000000
--- a/sdk/src/utils/fetchStkLyraBalance.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { BigNumber } from 'ethers'
-
-import Lyra from '../lyra'
-import fetchWithCache from './fetchWithCache'
-import fromBigNumber from './fromBigNumber'
-import isTestnet from './isTestnet'
-
-export default async function fetchStkLyraBalance(lyra: Lyra, owner: string): Promise<number> {
-  const testnet = isTestnet(lyra)
-  const data = await fetchWithCache<{
-    mainnetStkLYRA: string
-  }>(`${lyra.apiUri}/lyra-balances?&owner=${owner}&testnet=${testnet}`)
-  return fromBigNumber(BigNumber.from(data.mainnetStkLYRA))
-}
diff --git a/sdk/src/utils/fetchWithCache.ts b/sdk/src/utils/fetchWithCache.ts
index 4da57ce1..be21bf95 100644
--- a/sdk/src/utils/fetchWithCache.ts
+++ b/sdk/src/utils/fetchWithCache.ts
@@ -1,7 +1,7 @@
 import fetch from 'cross-fetch'
 
 const CACHE: Record<string, { lastUpdated: number; fetch: Promise<any> }> = {}
-const CACHE_TIMEOUT = 5 * 1000
+const CACHE_TIMEOUT = 10 * 1000
 
 async function fetcher<T>(url: string): Promise<T> {
   const data = await fetch(url)
diff --git a/sdk/src/utils/getEffectiveTradingFeeRebate.ts b/sdk/src/utils/getEffectiveTradingFeeRebate.ts
deleted file mode 100644
index 75297c35..00000000
--- a/sdk/src/utils/getEffectiveTradingFeeRebate.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-export default function getEffectiveTradingFeeRebate(
-  stkLyraBalance: number,
-  useRebateTable: boolean,
-  rebateRateTable: { cutoff: number; returnRate: number }[],
-  maxRebatePercentage: number,
-  netVerticalStretch: number,
-  verticalShift: number,
-  vertIntercept: number,
-  stretchiness: number
-): number {
-  if (useRebateTable) {
-    return Math.max(...rebateRateTable.filter(x => stkLyraBalance >= x.cutoff).map(x => x.returnRate))
-  } else {
-    return Math.min(
-      maxRebatePercentage,
-      vertIntercept + Math.max(0, netVerticalStretch * (verticalShift + Math.log(stkLyraBalance / stretchiness)))
-    )
-  }
-}
diff --git a/sdk/src/utils/getLiquidityDelayReason.ts b/sdk/src/utils/getLiquidityDelayReason.ts
deleted file mode 100644
index cd32c87b..00000000
--- a/sdk/src/utils/getLiquidityDelayReason.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { BigNumber } from 'ethers'
-
-import { LiquidityDelayReason, Market, MarketLiquiditySnapshot } from '..'
-import { VAULTS_UTILIZATION_THRESHOLD } from '../constants/contracts'
-
-export default function getLiquidityDelayReason(
-  market: Market,
-  cbTimestamp: BigNumber,
-  marketLiquidity: MarketLiquiditySnapshot
-): LiquidityDelayReason {
-  const currentTimestamp = market.block.timestamp
-  if (cbTimestamp.gt(currentTimestamp)) {
-    if (marketLiquidity.utilization > VAULTS_UTILIZATION_THRESHOLD) {
-      return LiquidityDelayReason.Liquidity
-    } else {
-      return LiquidityDelayReason.Volatility
-    }
-  } else {
-    return LiquidityDelayReason.Keeper
-  }
-}
diff --git a/sdk/src/utils/getLyraDeploymentSubgraphURI.ts b/sdk/src/utils/getLyraDeploymentSubgraphURI.ts
index 97a85bc1..5c6d0bf5 100644
--- a/sdk/src/utils/getLyraDeploymentSubgraphURI.ts
+++ b/sdk/src/utils/getLyraDeploymentSubgraphURI.ts
@@ -1,7 +1,7 @@
 import { Chain } from '../constants/chain'
 import { Version } from '../lyra'
 
-const getLyraDeploymentSubgraphURI = (chain: Chain, version: Version = Version.Newport): string => {
+const getLyraDeploymentSubgraphURI = (chain: Chain, version: Version): string => {
   switch (chain) {
     case Chain.Optimism:
       switch (version) {
diff --git a/sdk/src/utils/getLyraGovernanceSubgraphURI.ts b/sdk/src/utils/getLyraGovernanceSubgraphURI.ts
index 0c705689..1ef4c12f 100644
--- a/sdk/src/utils/getLyraGovernanceSubgraphURI.ts
+++ b/sdk/src/utils/getLyraGovernanceSubgraphURI.ts
@@ -1,14 +1,13 @@
 import { Chain } from '../constants/chain'
-import Lyra from '../lyra'
 
-const getLyraGovernanceSubgraphURI = (lyra: Lyra, chain: Chain): string => {
+const getLyraGovernanceSubgraphURI = (chain: Chain): string => {
   switch (chain) {
     case Chain.Optimism:
     case Chain.OptimismGoerli:
-      return new URL(`/subgraph/optimism-governance/v1/api`, lyra.apiUri).toString()
+      return 'https://subgraph.satsuma-prod.com/d14de8f7fd46/lyra/optimism-governance/api'
     case Chain.Arbitrum:
     case Chain.ArbitrumGoerli:
-      return new URL(`/subgraph/arbitrum-governance/v1/api`, lyra.apiUri).toString()
+      return 'https://subgraph.satsuma-prod.com/d14de8f7fd46/lyra/arbitrum-governance/api'
   }
 }