@reserve-protocol/dtf-sdk 0.1.4 → 0.1.6

package/dist/index.js

@@ -171,6 +171,199 @@ import {
   __toESM
 } from "./index-sdksp5px.js";
 
+// ../../node_modules/.bun/@reserve-protocol+rtokens@1.1.23/node_modules/@reserve-protocol/rtokens/rtokens/mainnet-rtoken-map.json
+var require_mainnet_rtoken_map = __commonJS((exports, module) => {
+  module.exports = {
+    "0x005F893EcD7bF9667195642f7649DA8163e23658": {
+      address: "0x005F893EcD7bF9667195642f7649DA8163e23658",
+      name: "Degen ETH",
+      symbol: "dgnETH",
+      logo: "dgneth.svg",
+      decimals: 18,
+      about: "Degen ETH is a high-yield diversified ETH strategy index designed to sustainably outperform LST market yields. Degen ETH uses a two-token model: dgnETH, which is pegged to ETH and backed 1:1 by DeFi yield strategies, and sdgnETH, obtained by depositing dgnETH in a staking vault, which accrues all yield from dgnETH's underlying assets.",
+      website: "https://degeneth.com",
+      support: {
+        email: "",
+        url: ""
+      },
+      social: {
+        twitter: "https://x.com/dgnETH_"
+      }
+    },
+    "0xA0d69E286B938e21CBf7E51D71F6A4c8918f482F": {
+      address: "0xA0d69E286B938e21CBf7E51D71F6A4c8918f482F",
+      name: "Electronic Dollar",
+      symbol: "eUSD",
+      logo: "eusd.svg",
+      decimals: 18,
+      about: "The eUSD RToken is a fully collateralized US-dollar stablecoin built on the Reserve Protocol"
+    },
+    "0xE72B141DF173b999AE7c1aDcbF60Cc9833Ce56a8": {
+      address: "0xE72B141DF173b999AE7c1aDcbF60Cc9833Ce56a8",
+      name: "ETHPlus",
+      symbol: "ETH+",
+      logo: "ethplus.svg",
+      decimals: 18,
+      about: "A reward generating Ethereum Liquid Staking Token basket with over-collateralized protection",
+      website: "https://register.app/#/overview?token=0xE72B141DF173b999AE7c1aDcbF60Cc9833Ce56a8",
+      support: {
+        url: "https://twitter.com/ETHPlus_"
+      },
+      social: {
+        twitter: "https://twitter.com/ETHPlus_"
+      }
+    },
+    "0xaCdf0DBA4B9839b96221a8487e9ca660a48212be": {
+      address: "0xaCdf0DBA4B9839b96221a8487e9ca660a48212be",
+      name: "High Yield USD",
+      symbol: "hyUSD",
+      logo: "hyusd.svg",
+      decimals: 18,
+      about: "hyUSD is a secure high yield savings flatcoin with up to 6% rewards outpacing inflation in over 100 countries around the world 🌎",
+      website: "https://linktr.ee/hyusd",
+      support: {
+        email: "contact@high-yield.io",
+        url: ""
+      },
+      social: {
+        twitter: "https://twitter.com/HighYieldUSD"
+      }
+    },
+    "0xFc0B1EEf20e4c68B3DCF36c4537Cfa7Ce46CA70b": {
+      address: "0xFc0B1EEf20e4c68B3DCF36c4537Cfa7Ce46CA70b",
+      name: "USDC Plus",
+      symbol: "USDC+",
+      logo: "usdcplus.svg",
+      decimals: 18,
+      about: "USDC PLUS (USDC+): A community governed yield bearing USDC index optimized for yield to holders and overcollateralization protection.",
+      website: "https://register.app/#/overview?token=0xFc0B1EEf20e4c68B3DCF36c4537Cfa7Ce46CA70b"
+    },
+    "0x0d86883FAf4FfD7aEb116390af37746F45b6f378": {
+      address: "0x0d86883FAf4FfD7aEb116390af37746F45b6f378",
+      name: "Web 3 Dollar",
+      symbol: "USD3",
+      logo: "usd3.svg",
+      decimals: 18,
+      about: "Earn the DeFi rate any time you're in stables",
+      support: {
+        email: "",
+        url: ""
+      },
+      social: {
+        twitter: "https://twitter.com/USD_3"
+      }
+    },
+    "0x78da5799CF427Fee11e9996982F4150eCe7a99A7": {
+      address: "0x78da5799CF427Fee11e9996982F4150eCe7a99A7",
+      name: "Revenue Generating USD",
+      symbol: "rgUSD",
+      logo: "rgusd.svg",
+      decimals: 18,
+      about: "Hold $1 USD peg, and deploy collateral to generate safe, on-chain yield to incentivize liquidity for itself and partners."
+    }
+  };
+});
+
+// ../../node_modules/.bun/@reserve-protocol+rtokens@1.1.23/node_modules/@reserve-protocol/rtokens/rtokens/base-rtoken-map.json
+var require_base_rtoken_map = __commonJS((exports, module) => {
+  module.exports = {
+    "0xCc7FF230365bD730eE4B352cC2492CEdAC49383e": {
+      address: "0xCc7FF230365bD730eE4B352cC2492CEdAC49383e",
+      name: "High Yield USD",
+      symbol: "hyUSD",
+      logo: "hyusd.svg",
+      decimals: 18,
+      about: "hyUSD is a secure high yield savings flatcoin with up to 6% rewards outpacing inflation in over 100 countries around the world 🌎",
+      website: "https://linktr.ee/hyusd",
+      support: {
+        email: "contact@high-yield.io",
+        url: ""
+      },
+      social: {
+        twitter: "https://twitter.com/HighYieldUSD"
+      }
+    },
+    "0x8f0987DDb485219c767770e2080E5cC01ddc772a": {
+      address: "0x8f0987DDb485219c767770e2080E5cC01ddc772a",
+      name: "Base Yield Index",
+      symbol: "BSDX",
+      logo: "bsdx.svg",
+      decimals: 18
+    },
+    "0xCb327b99fF831bF8223cCEd12B1338FF3aA322Ff": {
+      address: "0xCb327b99fF831bF8223cCEd12B1338FF3aA322Ff",
+      name: "Based ETH",
+      symbol: "bsdETH",
+      logo: "bsdeth.svg",
+      decimals: 18,
+      about: "A yield generating Ethereum Liquid Staking Token basket with over-collateralization protection."
+    },
+    "0xC9a3e2B3064c1c0546D3D0edc0A748E9f93Cf18d": {
+      address: "0xC9a3e2B3064c1c0546D3D0edc0A748E9f93Cf18d",
+      name: "Vaya",
+      symbol: "Vaya",
+      logo: "vaya.svg",
+      decimals: 18,
+      about: "A decentralized stablecoin which is striking to get the ideal balance between maximizing the worth of your finances and safeguarding its security.",
+      website: "https://vaya-stablecoin.com",
+      support: {
+        url: "https://twitter.com/Vaya_stablecoin"
+      },
+      social: {
+        twitter: "https://twitter.com/Vaya_stablecoin"
+      }
+    },
+    "0x641B0453487C9D14c5df96d45a481ef1dc84e31f": {
+      address: "0x641B0453487C9D14c5df96d45a481ef1dc84e31f",
+      name: "Maat",
+      symbol: "MAAT",
+      logo: "maat.svg",
+      decimals: 18,
+      about: "Monetary Average Across Time. The Dollar, Bitcoin, Ether unified.",
+      support: {
+        email: "maatcurrency@gmail.com"
+      },
+      social: {
+        twitter: "https://twitter.com/FlatcoinMaat"
+      }
+    }
+  };
+});
+
+// ../../node_modules/.bun/@reserve-protocol+rtokens@1.1.23/node_modules/@reserve-protocol/rtokens/rtokens/arbitrum-rtoken-map.json
+var require_arbitrum_rtoken_map = __commonJS((exports, module) => {
+  module.exports = {
+    "0x0BBF664D46becc28593368c97236FAa0fb397595": {
+      address: "0x0BBF664D46becc28593368c97236FAa0fb397595",
+      name: "KNOX Dollar",
+      symbol: "KNOX",
+      logo: "knox.svg",
+      decimals: 18,
+      about: "Where value anchors",
+      support: {
+        email: "knoxusd@gmail.com"
+      },
+      social: {
+        twitter: "https://twitter.com/KNOX_Dollar"
+      }
+    }
+  };
+});
+
+// ../../node_modules/.bun/@reserve-protocol+rtokens@1.1.23/node_modules/@reserve-protocol/rtokens/index.js
+var require_rtokens = __commonJS((exports, module) => {
+  var chainId = {
+    mainnet: 1,
+    base: 8453,
+    arbitrum: 42161
+  };
+  module.exports = {
+    [chainId.mainnet]: require_mainnet_rtoken_map(),
+    [chainId.base]: require_base_rtoken_map(),
+    [chainId.arbitrum]: require_arbitrum_rtoken_map()
+  };
+});
+
 // ../../node_modules/.bun/@reserve-protocol+dtf-rebalance-lib@3.2.1+cdf17018f2c68680/node_modules/@reserve-protocol/dtf-rebalance-lib/dist/types.js
 var require_types = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -12641,7 +12834,7 @@ async function fetchDtfBasket(chainId, folioAddress, baseUrl = RESERVE_API_BASE_
   const url = `${baseUrl}/current/dtf?address=${folioAddress.toLowerCase()}&chainId=${chainId}`;
   const response = await fetchWithRetry(url);
   if (!response.ok) {
-    throw new Error(`Reserve API /current/dtf failed: ${response.status} ${response.statusText}`);
+    throw new Error(`Reserve API /current/dtf failed for ${folioAddress} on chain ${chainId}: ${response.status} ${response.statusText}`);
   }
   return await response.json();
 }
@@ -12650,7 +12843,7 @@ async function fetchDtfBaskets(chainId, folioAddresses, baseUrl = RESERVE_API_BA
   const url = `${baseUrl}/current/dtfs?addresses=${addresses}&chainId=${chainId}`;
   const response = await fetchWithRetry(url);
   if (!response.ok) {
-    throw new Error(`Reserve API /current/dtfs failed: ${response.status} ${response.statusText}`);
+    throw new Error(`Reserve API /current/dtfs failed for [${folioAddresses.join(", ")}] on chain ${chainId}: ${response.status} ${response.statusText}`);
   }
   return await response.json();
 }
@@ -12756,17 +12949,36 @@ async function fetchDtfPrice(chainId, folioAddress, baseUrl = RESERVE_API_BASE_U
   return data.price;
 }
 async function fetchZapQuote(chainId, params, baseUrl = RESERVE_API_BASE_URL) {
-  const url = `${baseUrl}/zapper/${chainId}/swap?tokenIn=${params.tokenIn.toLowerCase()}&tokenOut=${params.tokenOut.toLowerCase()}&amountIn=${params.amountIn.toString()}&slippage=${params.slippage}&sender=${params.sender.toLowerCase()}&recipient=${params.recipient.toLowerCase()}`;
+  const queryParams = new URLSearchParams({
+    chainId: String(chainId),
+    signer: params.signer.toLowerCase(),
+    tokenIn: params.tokenIn.toLowerCase(),
+    tokenOut: params.tokenOut.toLowerCase(),
+    amountIn: params.amountIn.toString(),
+    slippage: String(params.slippage),
+    trade: String(params.trade ?? true)
+  });
+  if (params.bypassCache)
+    queryParams.set("bypassCache", "true");
+  const url = `${baseUrl}/api/zapper/${chainId}/swap?${queryParams.toString()}`;
   const response = await fetchWithRetry(url);
   if (!response.ok) {
-    throw new Error(`Reserve API /zapper/swap failed: ${response.status} ${response.statusText}`);
+    throw new Error(`Reserve API /api/zapper/swap failed: ${response.status} ${response.statusText}`);
   }
-  const data = await response.json();
+  const json = await response.json();
+  const r = json.result ?? json;
   return {
-    amountOut: BigInt(data.amountOut),
-    to: data.to,
-    data: data.data,
-    value: BigInt(data.value)
+    amountOut: BigInt(r.amountOut ?? "0"),
+    amountOutValue: r.amountOutValue ?? null,
+    amountInValue: r.amountInValue ?? null,
+    priceImpact: r.priceImpact ?? 0,
+    truePriceImpact: r.truePriceImpact ?? 0,
+    gas: r.gas ?? null,
+    dust: r.dust ?? [],
+    dustValue: r.dustValue ?? null,
+    to: r.to ?? "0x0000000000000000000000000000000000000000",
+    data: r.data ?? "0x",
+    value: BigInt(r.value ?? "0")
   };
 }
 async function fetchVoteLockPositions(baseUrl = RESERVE_API_BASE_URL) {
@@ -12921,6 +13133,27 @@ var mainAbi = [
     outputs: [{ internalType: "contract IRevenueTrader", name: "", type: "address" }],
     stateMutability: "view",
     type: "function"
+  },
+  {
+    inputs: [],
+    name: "frozen",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "issuancePausedOrFrozen",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "tradingPausedOrFrozen",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
   }
 ];
 
@@ -13190,7 +13423,7 @@ async function fetchYieldDtfConfig(publicClient, chainId, rTokenAddress) {
     throw new Error(`No FacadeRead address for chainId ${chainId}`);
   }
   const components = await readYieldDtfComponents(publicClient, rTokenAddress);
-  const [basket, backing, price, nameResult, symbolResult, stRSRInfo, distribution] = await Promise.all([
+  const [basket, backing, price, nameResult, symbolResult, totalSupplyResult, stRSRInfo, distribution] = await Promise.all([
     readYieldDtfBasket(publicClient, facadeAddress, rTokenAddress),
     readBackingOverview(publicClient, facadeAddress, rTokenAddress),
     readYieldDtfPrice(publicClient, facadeAddress, rTokenAddress),
@@ -13204,9 +13437,17 @@ async function fetchYieldDtfConfig(publicClient, chainId, rTokenAddress) {
       abi: ERC20_META_ABI,
       functionName: "symbol"
     }),
+    publicClient.readContract({
+      address: rTokenAddress,
+      abi: ERC20_META_ABI,
+      functionName: "totalSupply"
+    }),
     readStRSRInfo(publicClient, components.stRSR),
     readDistribution(publicClient, components.distributor)
   ]);
+  const totalSupply = totalSupplyResult;
+  const avgPrice = (Number(price.low) + Number(price.high)) / 2;
+  const tvl = avgPrice * Number(totalSupply) / (1000000000000000000 * 1000000000000000000);
   return {
     type: "yield",
     components,
@@ -13216,12 +13457,444 @@ async function fetchYieldDtfConfig(publicClient, chainId, rTokenAddress) {
     backing,
     priceLow: price.low,
     priceHigh: price.high,
+    totalSupply,
+    tvl,
     exchangeRate: stRSRInfo.exchangeRate,
     unstakingDelay: stRSRInfo.unstakingDelay,
     rTokenTotal: distribution.rTokenTotal,
     rsrTotal: distribution.rsrTotal
   };
 }
+// src/yield-dtf/fetch-discover.ts
+var import_rtokens = __toESM(require_rtokens(), 1);
+var rtokens = import_rtokens.default;
+var D18_NUM = 1000000000000000000;
+var PERCENT_SCALE = 100;
+var TOKENS_QUERY = `
+  query GetYieldDtfs($tokenIds: [String]!) {
+    tokens(where: { id_in: $tokenIds }) {
+      id
+      lastPriceUSD
+      name
+      symbol
+      totalSupply
+      cumulativeVolume
+      rToken {
+        backing
+        rsrStaked
+        rsrExchangeRate
+        holdersRewardShare
+        stakersRewardShare
+        targetUnits
+        collaterals {
+          id
+          symbol
+        }
+        collateralDistribution
+        revenueDistribution {
+          rTokenDist
+          rsrDist
+          destination
+        }
+      }
+    }
+  }
+`;
+function parseCollateralDistribution(raw) {
+  if (!raw)
+    return {};
+  try {
+    const parsed = JSON.parse(raw);
+    const result = {};
+    for (const key of Object.keys(parsed)) {
+      result[key.toLowerCase()] = parsed[key];
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function computeBasketApy(collaterals, distribution, collateralYields) {
+  if (collaterals.length === 0)
+    return null;
+  let basketApy = 0;
+  for (const collateral of collaterals) {
+    const yieldPct = collateralYields[collateral.symbol.toLowerCase()] || 0;
+    const weight = Number(distribution[collateral.id.toLowerCase()]?.dist) || 0;
+    basketApy += yieldPct * weight;
+  }
+  return basketApy;
+}
+async function fetchYieldDtfDiscover(chainId, options) {
+  const url = YIELD_SUBGRAPH_URLS[chainId];
+  if (!url)
+    return [];
+  const chainRtokens = rtokens[chainId.toString()];
+  if (!chainRtokens || Object.keys(chainRtokens).length === 0)
+    return [];
+  const tokenIds = Object.keys(chainRtokens).map((a) => a.toLowerCase());
+  const data = await querySubgraph(chainId, TOKENS_QUERY, { tokenIds }, url);
+  const collateralYields = options?.collateralYields;
+  const rsrPriceUsd = options?.rsrPriceUsd;
+  return data.tokens.map((t) => {
+    const price = Number(t.lastPriceUSD);
+    const totalSupplyRaw = Number(t.totalSupply) / D18_NUM;
+    const marketCap = price > 0 && totalSupplyRaw > 0 ? price * totalSupplyRaw : 0;
+    const collaterals = t.rToken?.collaterals ?? [];
+    const distribution = parseCollateralDistribution(t.rToken?.collateralDistribution ?? null);
+    let holdingApy = null;
+    let stakingApy = null;
+    if (collateralYields) {
+      const basketApy = computeBasketApy(collaterals, distribution, collateralYields);
+      if (basketApy !== null) {
+        const holdersShare = t.rToken ? Number(t.rToken.holdersRewardShare) / PERCENT_SCALE : 0;
+        holdingApy = basketApy * holdersShare;
+        if (rsrPriceUsd != null && rsrPriceUsd > 0) {
+          const stakersShare = t.rToken ? Number(t.rToken.stakersRewardShare) / PERCENT_SCALE : 0;
+          const supplyUsd = price > 0 ? price * totalSupplyRaw : 0;
+          const stakeUsd = Number(t.rToken?.rsrStaked ?? "0") / D18_NUM * rsrPriceUsd;
+          stakingApy = stakeUsd > 0 ? basketApy * supplyUsd / stakeUsd * stakersShare : basketApy * stakersShare;
+        }
+      }
+    }
+    return {
+      address: t.id,
+      chainId,
+      name: t.name,
+      symbol: t.symbol,
+      decimals: 18,
+      price: price > 0 ? price : null,
+      marketCap: marketCap > 0 ? marketCap : null,
+      totalSupply: t.totalSupply,
+      basketRate: null,
+      backing: t.rToken ? Number(t.rToken.backing) / D18_NUM : 1,
+      rsrStaked: t.rToken?.rsrStaked ?? "0",
+      rsrExchangeRate: t.rToken ? Number(t.rToken.rsrExchangeRate) / D18_NUM : 1,
+      holdersRewardShare: t.rToken ? Number(t.rToken.holdersRewardShare) / PERCENT_SCALE : 0,
+      stakersRewardShare: t.rToken ? Number(t.rToken.stakersRewardShare) / PERCENT_SCALE : 0,
+      targetUnits: t.rToken?.targetUnits ?? null,
+      collaterals: collaterals.map((c) => ({
+        address: c.id,
+        symbol: c.symbol
+      })),
+      holdingApy,
+      stakingApy
+    };
+  });
+}
+// src/yield-dtf/collateral-yields.ts
+var POOL_MAP = {
+  1: {
+    "acee1e4d-a73c-4e20-98f7-e87c13d446e4": "apxeth",
+    "405d8dad-5c99-4c91-90d3-82813ade1ff1": "sadai",
+    "a349fea4-d780-4e16-973e-70ca9b606db2": "sausdc",
+    "60d657c9-5f63-4771-a85b-2cf8d507ec00": "sausdt",
+    "1d53fa29-b918-4d74-9508-8fcf8173ca51": "sausdp",
+    "cc110152-36c2-4e10-9c12-c5b4eb662143": "cdai",
+    "cefa9bb8-c230-459a-a855-3b94e96acd8c": "cusdc",
+    "57647093-2868-4e65-97ab-9cae8ec74e7d": "cusdt",
+    "6c2b7a5c-6c4f-49ea-a08c-0366b772f2c2": "cusdp",
+    "1d876729-4445-4623-8b6b-c5290db5d100": "cwbtc",
+    "1e5da7c6-59bb-49bd-9f97-4f4fceeffad4": "ceth",
+    "fa4d7ee4-0001-4133-9e8d-cf7d5d194a91": "fusdc",
+    "ed227286-abb0-4a34-ada5-39f7ebd81afb": "fdai",
+    "6600934f-6323-447d-8a7d-67fbede8529d": "fusdt",
+    "747c1d2a-c668-4682-b9f9-296708a3dd90": "wsteth",
+    "d4b3c522-6127-4b89-bedf-83641cdcd2eb": "reth",
+    "7da72d09-56ca-4ec5-a45f-59114353e487": "wcusdcv3",
+    "f4d5b566-e815-4ca2-bb07-7bcd8bc797f1": "wcusdtv3",
+    "8a20c472-142c-4442-b724-40f2183c073e": "stkcvxmim-3lp3crv-f",
+    "ad3d7253-fb8f-402f-a6f8-821bc0a055cb": "stkcvxcrv3crypto",
+    "7394f1bc-840a-4ff0-9e87-5e0ef932943a": "stkcvx3crv",
+    "c04005c9-7e34-41a6-91c4-295834ed8ac0": "stkcvxeusd3crv-f",
+    "325ad2d6-70b1-48d7-a557-c2c99a036f87": "mrp-ausdc",
+    "1343a280-7812-4bc3-8f98-d1c37e11d271": "mrp-ausdt",
+    "b8bcdf8e-96ed-40ca-a7aa-aa048b9874e5": "mrp-adai",
+    "7be52986-18c2-450f-b74b-d65fb1205bbf": "mrp-aweth",
+    "ff61171d-d7b0-4989-816c-b9bf02a15f00": "mrp-awbtc",
+    "eab8d63d-8a8f-48cb-8027-583508831d24": "mrp-asteth",
+    "0f45d730-b279-4629-8e11-ccb5cc3038b4": "cbeth",
+    "c8a24fee-ec00-4f38-86c0-9f6daebc4225": "sdai",
+    "55de30c3-bf9f-4d4e-9e0b-536a8ef5ab35": "sfrax",
+    "aa70268e-4b52-42bf-a116-608b370f9501": "saethusdc",
+    "d118f505-e75f-4152-bad3-49a2dc7482bf": "saethpyusd",
+    "01146cce-9140-4e03-9a2e-82c99ccc42f1": "stkcvxpyusdusdc",
+    "5b3aebb3-891d-47fc-92e2-927ada3d5b82": "sfrxeth",
+    "d741644d-86ea-44ad-af5e-3042de381173": "re7weth",
+    "a3ffd3fe-b21c-44eb-94d5-22c80057a600": "stkcvxcrvusdusdt-f",
+    "755fcec6-f4fd-4150-9184-60f099206694": "stkcvxcrvusdusdc-f",
+    "d1dacce1-7815-420c-bb6d-d3c4320e1b2a": "steakpyusd",
+    "043a8330-bc29-4164-aa1c-28de7bf87755": "bbusdt",
+    "152b7ce2-7193-475d-9b15-3f17fee66047": "stkcvxeth+eth",
+    "74346f6f-c7ee-4506-a204-baf48e13decb": "stkcvxeth+eth-f",
+    "66985a81-9c51-46ca-9977-42b4fe7bc6df": "susde",
+    "90bfb3c2-5d35-4959-a275-ba5085b08aa3": "ethx",
+    "d8c4eff5-c8a9-46fc-a888-057c4c668e72": "susds",
+    "423681e3-4787-40ce-ae43-e9f67c5269b3": "woeth",
+    "f981a304-bb6c-45b8-b0c5-fd2f515ad23a": "saethusdt",
+    "85fc6934-c94d-4ebe-9c60-66beb363669f": "saethrlusd",
+    "46bd2bdf-6d92-4066-b482-e885ee172264": "weeth",
+    "b55f43a8-f444-4cd8-a3a4-0a4e786ba566": "steakusdc"
+  },
+  8453: {
+    "df65c4f4-e33a-481c-bac8-0c2252867c93": "wcusdbcv3",
+    "0c8567f8-ba5b-41ad-80de-00a71895eb19": "wcusdcv3",
+    "9d09b0be-f6c2-463a-ad2c-4552b3e12bd9": "wsgusdbc",
+    "7e0661bf-8cf3-45e6-9424-31916d4c7b84": "sabasusdc",
+    "833ec61b-f9e6-46ac-9eff-2785808b2389": "sabasusdbc",
+    "b90eba2e-ed29-414e-b16d-82f9c3eae707": "meusd",
+    "bde35fef-649f-4514-a564-e7e7da05eb52": "wsamm-eusd/usdc",
+    "69c0fc74-dee5-4c60-9aed-a593661d54ea": "wvamm-weth/aero",
+    "7b542141-5eed-4d70-bee6-0f9733beb362": "wvamm-mog/weth",
+    "be8a4206-6543-4690-a5c2-b3e032245aa2": "wsamm-usdz/usdc",
+    "593056a0-1e39-451d-acc8-081526625ab3": "wvamm-weth/cbbtc",
+    "8af246ee-cf26-4c8e-88f8-f2021a69e44d": "wvamm-weth/well",
+    "7e15dae2-ba5c-4658-b1a2-efb908a15200": "wvamm-weth/degen",
+    "f388573e-5c0f-4dac-9f70-116a4aabaf17": "wsuperoethb"
+  }
+};
+var LLAMA_CHAIN_MAP = {
+  Ethereum: 1,
+  Base: 8453
+};
+var CROSS_CHAIN_SYMBOLS = new Set(["wsteth", "cbeth"]);
+async function fetchCollateralYields() {
+  const response = await fetchWithRetry("https://yields.llama.fi/pools", undefined, {
+    timeoutMs: 30000
+  });
+  if (!response.ok) {
+    throw new Error(`DefiLlama API failed: ${response.status} ${response.statusText}`);
+  }
+  const json = await response.json();
+  const yields = {
+    1: {},
+    8453: {}
+  };
+  for (const pool of json.data) {
+    const chainId = LLAMA_CHAIN_MAP[pool.chain];
+    if (chainId === undefined)
+      continue;
+    const symbol = POOL_MAP[chainId]?.[pool.pool];
+    if (!symbol)
+      continue;
+    yields[chainId][symbol] = pool.apyMean30d || 0;
+    if (symbol === "cusdc" || symbol === "cusdt") {
+      yields[chainId][`${symbol}-vault`] = yields[chainId][symbol];
+    }
+    if (CROSS_CHAIN_SYMBOLS.has(symbol)) {
+      for (const targetChainId of Object.keys(yields)) {
+        yields[Number(targetChainId)][symbol] = yields[chainId][symbol];
+      }
+    }
+  }
+  return yields;
+}
+// src/yield-dtf/fetch-apy.ts
+var MIN_SNAPSHOTS = 7;
+var TOKEN_SNAPSHOTS_QUERY = `query($token: String!) {
+  tokenDailySnapshots(
+    where: { token: $token }
+    orderBy: timestamp
+    orderDirection: desc
+    first: 30
+  ) { timestamp, basketRate }
+}`;
+var RTOKEN_SNAPSHOTS_QUERY = `query($rToken: String!) {
+  rtokenDailySnapshots(
+    where: { rToken: $rToken }
+    orderBy: timestamp
+    orderDirection: desc
+    first: 30
+  ) { timestamp, rsrExchangeRate }
+}`;
+async function fetchYieldDtfApy(chainId, rTokenAddress) {
+  const url = YIELD_SUBGRAPH_URLS[chainId];
+  if (!url)
+    return { holdingApy: null, stakingApy: null };
+  const addr = rTokenAddress.toLowerCase();
+  const [tokenData, rTokenData] = await Promise.all([
+    querySubgraph(chainId, TOKEN_SNAPSHOTS_QUERY, { token: addr }, url),
+    querySubgraph(chainId, RTOKEN_SNAPSHOTS_QUERY, { rToken: addr }, url)
+  ]);
+  const holdingApy = computeCompoundApy(tokenData.tokenDailySnapshots.map((s) => ({
+    timestamp: Number(s.timestamp),
+    rate: Number(s.basketRate)
+  })));
+  const stakingApy = computeCompoundApy(rTokenData.rtokenDailySnapshots.map((s) => ({
+    timestamp: Number(s.timestamp),
+    rate: Number(s.rsrExchangeRate)
+  })));
+  return { holdingApy, stakingApy };
+}
+function computeCompoundApy(snapshots) {
+  if (snapshots.length < MIN_SNAPSHOTS)
+    return null;
+  const newest = snapshots[0];
+  const oldest = snapshots[snapshots.length - 1];
+  if (oldest.rate === 0)
+    return null;
+  const ratio = newest.rate / oldest.rate;
+  const daysBetween = (newest.timestamp - oldest.timestamp) / 86400;
+  if (daysBetween <= 0)
+    return null;
+  return Math.pow(ratio, 365 / daysBetween) - 1;
+}
+// src/yield-dtf/fetch-revenue.ts
+async function fetchYieldDtfRevenue(chainId, rTokenAddress, days = 30) {
+  const url = YIELD_SUBGRAPH_URLS[chainId];
+  if (!url)
+    return { snapshots: [], totalRTokenRevenueUSD: 0, totalRSRRevenueUSD: 0, totalRevenueUSD: 0 };
+  const addr = rTokenAddress.toLowerCase();
+  const fetchCount = days + 1;
+  const rTokenQuery = `query($rToken: String!) {
+  rtokenDailySnapshots(
+    where: { rToken: $rToken }
+    orderBy: timestamp
+    orderDirection: desc
+    first: ${fetchCount}
+  ) {
+    timestamp
+    rsrStaked
+    rsrExchangeRate
+    rsrPrice
+  }
+}`;
+  const tokenQuery = `query($token: String!) {
+  tokenDailySnapshots(
+    where: { token: $token }
+    orderBy: timestamp
+    orderDirection: desc
+    first: ${fetchCount}
+  ) {
+    timestamp
+    basketRate
+    dailyTotalSupply
+    priceUSD
+  }
+}`;
+  const [rTokenData, tokenData] = await Promise.all([
+    querySubgraph(chainId, rTokenQuery, { rToken: addr }, url),
+    querySubgraph(chainId, tokenQuery, { token: addr }, url)
+  ]);
+  const stakerRevByTimestamp = new Map;
+  const rSnaps = rTokenData.rtokenDailySnapshots;
+  for (let i = 0;i < rSnaps.length - 1; i++) {
+    const newer = rSnaps[i];
+    const older = rSnaps[i + 1];
+    const rateNew = Number(newer.rsrExchangeRate);
+    const rateOld = Number(older.rsrExchangeRate);
+    const rsrPrice = Number(newer.rsrPrice) || 0;
+    let dailyRSRRevenueUSD = 0;
+    if (rateOld > 0 && rateNew > rateOld) {
+      const rsrStakedNorm = Number(newer.rsrStaked) / 1000000000000000000;
+      dailyRSRRevenueUSD = rsrStakedNorm * ((rateNew - rateOld) / rateOld) * rsrPrice;
+    }
+    stakerRevByTimestamp.set(Number(newer.timestamp), {
+      dailyRSRRevenueUSD,
+      rsrStaked: newer.rsrStaked,
+      rsrExchangeRate: rateNew,
+      rsrPrice
+    });
+  }
+  const holderRevByTimestamp = new Map;
+  const tSnaps = tokenData.tokenDailySnapshots;
+  for (let i = 0;i < tSnaps.length - 1; i++) {
+    const newer = tSnaps[i];
+    const older = tSnaps[i + 1];
+    const rateNew = Number(newer.basketRate);
+    const rateOld = Number(older.basketRate);
+    const priceUSD = Number(newer.priceUSD) || 0;
+    const totalSupplyNorm = Number(newer.dailyTotalSupply) / 1000000000000000000;
+    let dailyRTokenRevenueUSD = 0;
+    if (rateOld > 0 && rateNew > rateOld) {
+      dailyRTokenRevenueUSD = totalSupplyNorm * ((rateNew - rateOld) / rateOld) * priceUSD;
+    }
+    holderRevByTimestamp.set(Number(newer.timestamp), dailyRTokenRevenueUSD);
+  }
+  const snapshots = [];
+  let totalRTokenRevenueUSD = 0;
+  let totalRSRRevenueUSD = 0;
+  for (const [timestamp, staker] of stakerRevByTimestamp) {
+    const holderRev = holderRevByTimestamp.get(timestamp) ?? findClosest(holderRevByTimestamp, timestamp) ?? 0;
+    snapshots.push({
+      timestamp,
+      dailyRTokenRevenueUSD: holderRev,
+      dailyRSRRevenueUSD: staker.dailyRSRRevenueUSD,
+      rsrStaked: staker.rsrStaked,
+      rsrExchangeRate: staker.rsrExchangeRate,
+      rsrPrice: staker.rsrPrice
+    });
+    totalRTokenRevenueUSD += holderRev;
+    totalRSRRevenueUSD += staker.dailyRSRRevenueUSD;
+  }
+  return {
+    snapshots,
+    totalRTokenRevenueUSD,
+    totalRSRRevenueUSD,
+    totalRevenueUSD: totalRTokenRevenueUSD + totalRSRRevenueUSD
+  };
+}
+function findClosest(map, target) {
+  let bestKey = 0;
+  let bestDist = Infinity;
+  for (const key of map.keys()) {
+    const dist = Math.abs(key - target);
+    if (dist < bestDist) {
+      bestDist = dist;
+      bestKey = key;
+    }
+  }
+  if (bestDist > 43200)
+    return null;
+  return map.get(bestKey) ?? null;
+}
+// src/abi/rtoken.ts
+var rtokenAbi = [
+  {
+    inputs: [],
+    name: "issuanceAvailable",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "redemptionAvailable",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/yield-dtf/read-status.ts
+async function readYieldDtfStatus(publicClient, mainAddress) {
+  const results = await publicClient.multicall({
+    contracts: [
+      { address: mainAddress, abi: mainAbi, functionName: "frozen" },
+      { address: mainAddress, abi: mainAbi, functionName: "issuancePausedOrFrozen" },
+      { address: mainAddress, abi: mainAbi, functionName: "tradingPausedOrFrozen" }
+    ],
+    allowFailure: false
+  });
+  return {
+    frozen: results[0],
+    issuancePaused: results[1],
+    tradingPaused: results[2]
+  };
+}
+async function readThrottleStatus(publicClient, rTokenAddress) {
+  const results = await publicClient.multicall({
+    contracts: [
+      { address: rTokenAddress, abi: rtokenAbi, functionName: "issuanceAvailable" },
+      { address: rTokenAddress, abi: rtokenAbi, functionName: "redemptionAvailable" }
+    ],
+    allowFailure: false
+  });
+  return {
+    issuanceAvailable: results[0],
+    redemptionAvailable: results[1]
+  };
+}
 // src/yield-dtf/issue.ts
 async function readIssueQuote(publicClient, facadeAddress, rTokenAddress, amount) {
   const result = await publicClient.readContract({
@@ -13454,7 +14127,7 @@ async function fetchRebalanceHistory(chainId, folioAddress, opts, baseUrl = RESE
   const url = `${baseUrl}/dtf/rebalance?address=${folioAddress.toLowerCase()}&chainId=${chainId}&skip=${skip}&limit=${limit}`;
   const response = await fetchWithRetry(url);
   if (!response.ok) {
-    throw new Error(`Reserve API /dtf/rebalance failed: ${response.status} ${response.statusText}`);
+    throw new Error(`Reserve API /dtf/rebalance failed for ${folioAddress} on chain ${chainId}: ${response.status} ${response.statusText}`);
   }
   return await response.json();
 }
@@ -13462,7 +14135,7 @@ async function fetchRebalanceDetail(chainId, folioAddress, nonce, baseUrl = RESE
   const url = `${baseUrl}/dtf/rebalance?address=${folioAddress.toLowerCase()}&chainId=${chainId}&nonce=${nonce}`;
   const response = await fetchWithRetry(url);
   if (!response.ok) {
-    throw new Error(`Reserve API /dtf/rebalance detail failed: ${response.status} ${response.statusText}`);
+    throw new Error(`Reserve API /dtf/rebalance detail failed for ${folioAddress} nonce ${nonce} on chain ${chainId}: ${response.status} ${response.statusText}`);
   }
   return await response.json();
 }
@@ -17470,7 +18143,7 @@ async function fetchTokenPrices(chainId, tokenAddresses, baseUrl = RESERVE_API_B
   const url = `${baseUrl}/current/prices?chainId=${chainId}&tokens=${tokens}`;
   const response = await fetchWithRetry(url);
   if (!response.ok) {
-    throw new Error(`Reserve API prices failed: ${response.status} ${response.statusText}`);
+    throw new Error(`Reserve API prices failed for chain ${chainId} (${tokenAddresses.length} tokens): ${response.status} ${response.statusText}`);
   }
   const data = await response.json();
   const prices = {};
@@ -17611,6 +18284,27 @@ async function backfillChainlinkPrices(priceClient, days, batchSize = 50, feedAd
   }
   return records;
 }
+// src/prices/zapper-quote.ts
+var DUMMY_SIGNER = "0x0000000000000000000000000000000000000001";
+async function fetchZapSlippage(chainId, tokenIn, tokenOut, amountIn, slippage = 100, baseUrl = RESERVE_API_BASE_URL) {
+  try {
+    const quote = await fetchZapQuote(chainId, {
+      tokenIn,
+      tokenOut,
+      amountIn,
+      slippage,
+      signer: DUMMY_SIGNER,
+      trade: true
+    }, baseUrl);
+    return {
+      priceImpact: quote.priceImpact,
+      truePriceImpact: quote.truePriceImpact,
+      gas: quote.gas
+    };
+  } catch {
+    return null;
+  }
+}
 // src/revenue/fetch-revenue.ts
 var REVENUE_QUERY = `
   query GetDTFRevenue($id: String!) {
@@ -18091,6 +18785,312 @@ function computeSharpeRatio(prices, riskFreeRate = 0) {
   const annualizedReturn = totalReturn * (365 / (prices.length - 1));
   return Math.round((annualizedReturn - riskFreeRate) / vol * 100) / 100;
 }
+function computeVaR(prices, confidence = 0.95) {
+  if (prices.length < 3)
+    return 0;
+  const returns = [];
+  for (let i = 1;i < prices.length; i++) {
+    const prev = prices[i - 1].price;
+    const curr = prices[i].price;
+    if (prev <= 0)
+      continue;
+    returns.push((curr - prev) / prev);
+  }
+  if (returns.length < 2)
+    return 0;
+  const sorted = [...returns].sort((a, b) => a - b);
+  const index2 = Math.floor((1 - confidence) * sorted.length);
+  const varReturn = sorted[Math.min(index2, sorted.length - 1)];
+  return Math.round(varReturn * 1e4) / 100;
+}
+function computeCorrelation(prices1, prices2) {
+  if (prices1.length < 3 || prices2.length < 3)
+    return 0;
+  const len = Math.min(prices1.length, prices2.length);
+  const returns1 = [];
+  const returns2 = [];
+  for (let i = 1;i < len; i++) {
+    const prev1 = prices1[i - 1].price;
+    const curr1 = prices1[i].price;
+    const prev2 = prices2[i - 1].price;
+    const curr2 = prices2[i].price;
+    if (prev1 <= 0 || prev2 <= 0)
+      continue;
+    returns1.push((curr1 - prev1) / prev1);
+    returns2.push((curr2 - prev2) / prev2);
+  }
+  if (returns1.length < 2)
+    return 0;
+  const mean1 = returns1.reduce((s, r) => s + r, 0) / returns1.length;
+  const mean2 = returns2.reduce((s, r) => s + r, 0) / returns2.length;
+  let cov = 0;
+  let var1 = 0;
+  let var2 = 0;
+  for (let i = 0;i < returns1.length; i++) {
+    const d1 = returns1[i] - mean1;
+    const d2 = returns2[i] - mean2;
+    cov += d1 * d2;
+    var1 += d1 * d1;
+    var2 += d2 * d2;
+  }
+  const denom = Math.sqrt(var1 * var2);
+  if (denom === 0)
+    return 0;
+  return Math.round(cov / denom * 1e4) / 1e4;
+}
+function computeBeta(assetPrices, benchmarkPrices) {
+  if (assetPrices.length < 3 || benchmarkPrices.length < 3)
+    return 0;
+  const len = Math.min(assetPrices.length, benchmarkPrices.length);
+  const assetReturns = [];
+  const benchReturns = [];
+  for (let i = 1;i < len; i++) {
+    const prevA = assetPrices[i - 1].price;
+    const currA = assetPrices[i].price;
+    const prevB = benchmarkPrices[i - 1].price;
+    const currB = benchmarkPrices[i].price;
+    if (prevA <= 0 || prevB <= 0)
+      continue;
+    assetReturns.push((currA - prevA) / prevA);
+    benchReturns.push((currB - prevB) / prevB);
+  }
+  if (assetReturns.length < 2)
+    return 0;
+  const meanA = assetReturns.reduce((s, r) => s + r, 0) / assetReturns.length;
+  const meanB = benchReturns.reduce((s, r) => s + r, 0) / benchReturns.length;
+  let cov = 0;
+  let varB = 0;
+  for (let i = 0;i < assetReturns.length; i++) {
+    const dA = assetReturns[i] - meanA;
+    const dB = benchReturns[i] - meanB;
+    cov += dA * dB;
+    varB += dB * dB;
+  }
+  if (varB === 0)
+    return 0;
+  return Math.round(cov / varB * 1e4) / 1e4;
+}
+function computeTrackingError(assetPrices, benchmarkPrices) {
+  if (assetPrices.length < 3 || benchmarkPrices.length < 3)
+    return 0;
+  const len = Math.min(assetPrices.length, benchmarkPrices.length);
+  const diffs = [];
+  for (let i = 1;i < len; i++) {
+    const prevA = assetPrices[i - 1].price;
+    const currA = assetPrices[i].price;
+    const prevB = benchmarkPrices[i - 1].price;
+    const currB = benchmarkPrices[i].price;
+    if (prevA <= 0 || prevB <= 0)
+      continue;
+    const retA = (currA - prevA) / prevA;
+    const retB = (currB - prevB) / prevB;
+    diffs.push(retA - retB);
+  }
+  if (diffs.length < 2)
+    return 0;
+  const mean = diffs.reduce((s, d) => s + d, 0) / diffs.length;
+  const variance = diffs.reduce((s, d) => s + (d - mean) ** 2, 0) / (diffs.length - 1);
+  const dailyTE = Math.sqrt(variance);
+  return Math.round(dailyTE * Math.sqrt(365) * 1e4) / 1e4;
+}
+// src/signals/thresholds.ts
+var TOKEN_WEIGHT_WARNING = 0.5;
+var TOKEN_WEIGHT_CRITICAL = 0.75;
+var HHI_CONCENTRATED = 0.25;
+var EFFECTIVE_N_LOW = 3;
+var TOP_HOLDER_WARNING = 30;
+var TOP5_HOLDERS_WARNING = 70;
+var TVL_FRAGILE = 50000;
+var TVL_VERY_LOW = 1e4;
+var FEE_HIGH_ANNUAL = 3;
+var FEE_VERY_HIGH_ANNUAL = 5;
+var MINT_FEE_HIGH = 0.5;
+var BACKING_LOW = 99.5;
+var VAR_95_HIGH = 10;
+var BETA_HIGH = 1.5;
+var BETA_LOW = 0.5;
+var DRAWDOWN_HIGH = 30;
+
+// src/signals/compute-signals.ts
+function fmtUsd(n) {
+  return `$${n.toLocaleString("en-US", { maximumFractionDigits: 0 })}`;
+}
+function computeBasketSignals(weights, symbols) {
+  if (weights.length === 0)
+    return [];
+  const signals = [];
+  for (let i = 0;i < weights.length; i++) {
+    const w = weights[i];
+    const label = symbols?.[i] ?? `Token #${i + 1}`;
+    if (w > TOKEN_WEIGHT_CRITICAL) {
+      signals.push({
+        type: "concentration",
+        severity: "critical",
+        message: `${label} dominates basket at ${(w * 100).toFixed(1)}% (>${TOKEN_WEIGHT_CRITICAL * 100}% threshold)`
+      });
+    } else if (w > TOKEN_WEIGHT_WARNING) {
+      signals.push({
+        type: "concentration",
+        severity: "warning",
+        message: `${label} dominates basket at ${(w * 100).toFixed(1)}% (>${TOKEN_WEIGHT_WARNING * 100}% threshold)`
+      });
+    }
+  }
+  const hhi = weights.reduce((sum, w) => sum + w * w, 0);
+  const effectiveN = hhi > 0 ? 1 / hhi : 0;
+  if (hhi > HHI_CONCENTRATED) {
+    signals.push({
+      type: "concentration",
+      severity: "warning",
+      message: `High HHI concentration (${hhi.toFixed(2)} > ${HHI_CONCENTRATED}). ${effectiveN.toFixed(1)} effective tokens`
+    });
+  }
+  if (effectiveN > 0 && effectiveN < EFFECTIVE_N_LOW) {
+    signals.push({
+      type: "concentration",
+      severity: "warning",
+      message: `Low diversification: ${effectiveN.toFixed(1)} effective tokens (< ${EFFECTIVE_N_LOW})`
+    });
+  }
+  return signals;
+}
+function computeLiquiditySignals(tvlUsd) {
+  if (tvlUsd === null)
+    return [];
+  if (tvlUsd < TVL_VERY_LOW) {
+    return [{
+      type: "liquidity",
+      severity: "critical",
+      message: `Very low TVL (${fmtUsd(tvlUsd)}) — below $10K threshold. Liquidity risk is extreme`
+    }];
+  }
+  if (tvlUsd < TVL_FRAGILE) {
+    return [{
+      type: "liquidity",
+      severity: "warning",
+      message: `Low TVL (${fmtUsd(tvlUsd)}) — below $50K threshold`
+    }];
+  }
+  return [];
+}
+function computeFeeSignals(tvlFeeAnnualPct, mintFeePct) {
+  const signals = [];
+  if (tvlFeeAnnualPct > FEE_VERY_HIGH_ANNUAL) {
+    signals.push({
+      type: "fee",
+      severity: "warning",
+      message: `High annual TVL fee (${tvlFeeAnnualPct.toFixed(2)}% > ${FEE_VERY_HIGH_ANNUAL}%)`
+    });
+  } else if (tvlFeeAnnualPct > FEE_HIGH_ANNUAL) {
+    signals.push({
+      type: "fee",
+      severity: "info",
+      message: `Above-average annual TVL fee (${tvlFeeAnnualPct.toFixed(2)}% > ${FEE_HIGH_ANNUAL}%)`
+    });
+  }
+  if (mintFeePct !== undefined && mintFeePct > MINT_FEE_HIGH) {
+    signals.push({
+      type: "fee",
+      severity: "info",
+      message: `Mint fee of ${mintFeePct.toFixed(2)}% (> ${MINT_FEE_HIGH}%)`
+    });
+  }
+  return signals;
+}
+function computeHolderSignals(holders) {
+  if (holders.length === 0)
+    return [];
+  const signals = [];
+  const topHolder = holders[0];
+  if (topHolder.supplyPercent > TOP_HOLDER_WARNING) {
+    signals.push({
+      type: "holder-concentration",
+      severity: "warning",
+      message: `Top holder owns ${topHolder.supplyPercent.toFixed(1)}% of supply (>${TOP_HOLDER_WARNING}% threshold)`
+    });
+  }
+  const top5Pct = holders.slice(0, 5).reduce((sum, h) => sum + h.supplyPercent, 0);
+  if (top5Pct > TOP5_HOLDERS_WARNING) {
+    signals.push({
+      type: "holder-concentration",
+      severity: "info",
+      message: `Top 5 holders own ${top5Pct.toFixed(1)}% of supply (>${TOP5_HOLDERS_WARNING}% threshold)`
+    });
+  }
+  return signals;
+}
+function computeOperationalSignals(status) {
+  if (!status)
+    return [];
+  const signals = [];
+  if (status.frozen) {
+    signals.push({
+      type: "operational",
+      severity: "critical",
+      message: "DTF is frozen — all operations halted"
+    });
+  }
+  if (status.issuancePaused && !status.frozen) {
+    signals.push({
+      type: "operational",
+      severity: "warning",
+      message: "Issuance is paused"
+    });
+  }
+  if (status.tradingPaused && !status.frozen) {
+    signals.push({
+      type: "operational",
+      severity: "warning",
+      message: "Trading is paused"
+    });
+  }
+  if (status.backingPercent !== undefined && status.backingPercent < BACKING_LOW) {
+    signals.push({
+      type: "operational",
+      severity: "critical",
+      message: `Backing at ${status.backingPercent.toFixed(2)}% — below ${BACKING_LOW}% threshold`
+    });
+  }
+  return signals;
+}
+function computePriceSignals(metrics) {
+  const signals = [];
+  if (metrics.var95Day !== undefined && metrics.var95Day !== null) {
+    const absVar = Math.abs(metrics.var95Day);
+    if (absVar > VAR_95_HIGH) {
+      signals.push({
+        type: "price",
+        severity: "warning",
+        message: `High daily VaR (${metrics.var95Day.toFixed(2)}%) — exceeds ${VAR_95_HIGH}% threshold`
+      });
+    }
+  }
+  if (metrics.beta !== undefined && metrics.beta !== null) {
+    if (metrics.beta > BETA_HIGH) {
+      signals.push({
+        type: "price",
+        severity: "warning",
+        message: `High BTC beta (${metrics.beta.toFixed(2)}) — amplifies market moves (>${BETA_HIGH})`
+      });
+    } else if (metrics.beta < BETA_LOW) {
+      signals.push({
+        type: "price",
+        severity: "info",
+        message: `Low BTC beta (${metrics.beta.toFixed(2)}) — largely decorrelated (<${BETA_LOW})`
+      });
+    }
+  }
+  if (metrics.maxDrawdown !== undefined && metrics.maxDrawdown !== null) {
+    if (metrics.maxDrawdown > DRAWDOWN_HIGH) {
+      signals.push({
+        type: "price",
+        severity: "warning",
+        message: `Severe max drawdown (${metrics.maxDrawdown.toFixed(2)}%) — exceeds ${DRAWDOWN_HIGH}% threshold`
+      });
+    }
+  }
+  return signals;
+}
 export {
   wrapInProposal,
   vote_lock_default as voteLockAbi,
@@ -18102,9 +19102,11 @@ export {
   timelock_default as timelockAbi,
   submitZapDeploy,
   stRSRAbi,
+  rtokenAbi,
   resolveToken,
   readRedeemQuote as readYieldRedeemQuote,
   readIssueQuote as readYieldIssueQuote,
+  readYieldDtfStatus,
   readYieldDtfPrice,
   readYieldDtfComponents,
   readYieldDtfBasket,
@@ -18115,6 +19117,7 @@ export {
   readUnstakingDelay,
   readTvlFee,
   readTotalSupply,
+  readThrottleStatus,
   readSymbol,
   readStRSRInfo,
   readRewardTokens,
@@ -18160,8 +19163,12 @@ export {
   generateDeploymentNonce,
   formatRoleName,
   folio_default as folioAbi,
+  fetchZapSlippage,
   fetchZapQuote,
+  fetchYieldDtfRevenue,
+  fetchYieldDtfDiscover,
   fetchYieldDtfConfig,
+  fetchYieldDtfApy,
   fetchWithRetry,
   fetchVoteLockPositions,
   fetchTokenVolatility,
@@ -18182,6 +19189,7 @@ export {
   fetchDtfConfig,
   fetchDtfBaskets,
   fetchDtfBasket,
+  fetchCollateralYields,
   fetchAllProposals,
   facadeReadAbi,
   extractDeployedAddress,
@@ -18211,18 +19219,28 @@ export {
   createPriceClient,
   createDtfClients,
   computeVolatility,
+  computeVaR,
+  computeTrackingError,
   computeTargetBasket,
   computeStartRebalanceParams,
   computeSharpeRatio,
   computeRsrBurnProjection,
   computeRevenueUsd,
   computeProposalState,
+  computePriceSignals,
+  computeOperationalSignals,
   computeOpenAuctionParams,
   computeMaxDrawdown,
   computeLockedRsr,
+  computeLiquiditySignals,
+  computeHolderSignals,
   computeHistoricalBurnTotals,
+  computeFeeSignals,
   computeFeeMetrics,
+  computeCorrelation,
   computeBurnAccuracy,
+  computeBeta,
+  computeBasketSignals,
   calculatePriceFromRange,
   buildVoteLockWithDelegateCalldata,
   buildVoteLockCalldata,
@@ -18262,8 +19280,15 @@ export {
   YIELD_SUBGRAPH_URLS,
   VOTE_LOCK_ADDRESS,
   VOLATILITY_TO_PRICE_ERROR,
+  VAR_95_HIGH,
   V5_SPELL_ADDRESS,
   V4_SPELL_ADDRESS,
+  TVL_VERY_LOW,
+  TVL_FRAGILE,
+  TOP_HOLDER_WARNING,
+  TOP5_HOLDERS_WARNING,
+  TOKEN_WEIGHT_WARNING,
+  TOKEN_WEIGHT_CRITICAL,
   SUPPORTED_CHAINS,
   SUBGRAPH_URLS,
   STALE_PRICE_THRESHOLD_S,
@@ -18276,11 +19301,17 @@ export {
   PROPOSAL_STATE_MAP,
   PROPOSAL_STATES,
   PRICE_CONTROL,
+  MINT_FEE_HIGH,
+  HHI_CONCENTRATED,
   GOVERNANCE_SPELL_ADDRESS,
   GOVERNANCE_DEPLOYER_ADDRESS,
   FOLIO_ROLES,
+  FEE_VERY_HIGH_ANNUAL,
+  FEE_HIGH_ANNUAL,
   FACADE_READ_ADDRESS,
   ERC20_META_ABI,
+  EFFECTIVE_N_LOW,
+  DRAWDOWN_HIGH,
   DEPLOYER_ADDRESS,
   DEFAULT_TVL_FEE,
   DEFAULT_TRADING_GOV_PARAMS,
@@ -18295,5 +19326,8 @@ export {
   CHAINLINK_RSR_USD,
   CHAINLINK_DECIMALS,
   CHAINLINK_BTC_USD,
+  BETA_LOW,
+  BETA_HIGH,
+  BACKING_LOW,
   AUCTION_LAUNCHER_WINDOW
 };