@reserve-protocol/dtf-cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -2435,19 +2435,19 @@ var init_index_sdksp5px = __esm(() => {
   __hasOwnProp = Object.prototype.hasOwnProperty;
 });
 
-// ../sdk/dist/ccip-9vnc6854.js
-var exports_ccip_9vnc6854 = {};
-__export(exports_ccip_9vnc6854, {
+// ../sdk/dist/ccip-tn8s4j8m.js
+var exports_ccip_tn8s4j8m = {};
+__export(exports_ccip_tn8s4j8m, {
   offchainLookupSignature: () => offchainLookupSignature,
   offchainLookupAbiItem: () => offchainLookupAbiItem,
   offchainLookup: () => offchainLookup,
   ccipRequest: () => ccipRequest
 });
-var init_ccip_9vnc6854 = __esm(() => {
-  init_index_tdmavmz7();
+var init_ccip_tn8s4j8m = __esm(() => {
+  init_index_azrx1hqn();
 });
 
-// ../sdk/dist/index-tdmavmz7.js
+// ../sdk/dist/index-azrx1hqn.js
 function execTyped(regex, string) {
   const match = regex.exec(string);
   return match?.groups;
@@ -3457,6 +3457,14 @@ function hexToNumber2(hex, opts = {}) {
     });
   return number;
 }
+function hexToString(hex, opts = {}) {
+  let bytes = hexToBytes2(hex);
+  if (opts.size) {
+    assertSize3(bytes, { size: opts.size });
+    bytes = trim3(bytes, { dir: "right" });
+  }
+  return new TextDecoder().decode(bytes);
+}
 function toHex(value, opts = {}) {
   if (typeof value === "number" || typeof value === "bigint")
     return numberToHex(value, opts);
@@ -4795,7 +4803,7 @@ async function call(client, args) {
     return { data: response };
   } catch (err) {
     const data2 = getRevertErrorData(err);
-    const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip_9vnc6854(), exports_ccip_9vnc6854));
+    const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await Promise.resolve().then(() => (init_ccip_tn8s4j8m(), exports_ccip_tn8s4j8m));
     if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
       return { data: await offchainLookup2(client, { data: data2, to }) };
     if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
@@ -5099,7 +5107,7 @@ var version = "1.2.3", BaseError, bytesRegex, integerRegex, isTupleRegex, tupleR
   const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
   return typeof replacer === "function" ? replacer(key, value2) : value2;
 }, space), toEventSelector, etherUnits, gweiUnits, AccountStateConflictError, StateAssignmentConflictError, InvalidLegacyVError, InvalidSerializableTransactionError, InvalidStorageKeySizeError, TransactionExecutionError, TransactionNotFoundError, TransactionReceiptNotFoundError, TransactionReceiptRevertedError, WaitForTransactionReceiptTimeoutError, getContractAddress = (address) => address, getUrl = (url) => url, CallExecutionError, ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, CounterfactualDeploymentFailedError, RawContractError, docsPath = "/docs/contract/decodeFunctionResult", docsPath2 = "/docs/contract/encodeDeployData", docsPath3 = "/docs/contract/encodeFunctionData", ExecutionRevertedError, FeeCapTooHighError, FeeCapTooLowError, NonceTooHighError, NonceTooLowError, NonceMaxValueError, InsufficientFundsError, IntrinsicGasTooHighError, IntrinsicGasTooLowError, TransactionTypeNotSupportedError, TipAboveFeeCapError, UnknownNodeError, HttpRequestError, RpcRequestError, TimeoutError, unknownErrorCode = -1, RpcError, ProviderRpcError, ParseRpcError, InvalidRequestRpcError, MethodNotFoundRpcError, InvalidParamsRpcError, InternalRpcError, InvalidInputRpcError, ResourceNotFoundRpcError, ResourceUnavailableRpcError, TransactionRejectedRpcError, MethodNotSupportedRpcError, LimitExceededRpcError, JsonRpcVersionUnsupportedError, UserRejectedRequestError, UnauthorizedProviderError, UnsupportedProviderMethodError, ProviderDisconnectedError, ChainDisconnectedError, SwitchChainError, UnsupportedNonOptionalCapabilityError, UnsupportedChainIdError, DuplicateIdError, UnknownBundleIdError, BundleTooLargeError, AtomicReadyWalletRejectedUpgradeError, AtomicityNotSupportedError, WalletConnectSessionSettlementError, UnknownRpcError, rpcTransactionType, schedulerCache, maxInt8, maxInt16, maxInt24, maxInt32, maxInt40, maxInt48, maxInt56, maxInt64, maxInt72, maxInt80, maxInt88, maxInt96, maxInt104, maxInt112, maxInt120, maxInt128, maxInt136, maxInt144, maxInt152, maxInt160, maxInt168, maxInt176, maxInt184, maxInt192, maxInt200, maxInt208, maxInt216, maxInt224, maxInt232, maxInt240, maxInt248, maxInt256, minInt8, minInt16, minInt24, minInt32, minInt40, minInt48, minInt56, minInt64, minInt72, minInt80, minInt88, minInt96, minInt104, minInt112, minInt120, minInt128, minInt136, minInt144, minInt152, minInt160, minInt168, minInt176, minInt184, minInt192, minInt200, minInt208, minInt216, minInt224, minInt232, minInt240, minInt248, minInt256, maxUint8, maxUint16, maxUint24, maxUint32, maxUint40, maxUint48, maxUint56, maxUint64, maxUint72, maxUint80, maxUint88, maxUint96, maxUint104, maxUint112, maxUint120, maxUint128, maxUint136, maxUint144, maxUint152, maxUint160, maxUint168, maxUint176, maxUint184, maxUint192, maxUint200, maxUint208, maxUint216, maxUint224, maxUint232, maxUint240, maxUint248, maxUint256, OffchainLookupError, OffchainLookupResponseMalformedError, OffchainLookupSenderMismatchError, docsPath4 = "/docs/contract/encodeErrorResult", docsPath5 = "/docs/contract/encodeFunctionResult", localBatchGatewayUrl = "x-batch-gateway:true", offchainLookupSignature = "0x556f1830", offchainLookupAbiItem;
-var init_index_tdmavmz7 = __esm(() => {
+var init_index_azrx1hqn = __esm(() => {
   init_index_wjqsw4fc();
   BaseError = class BaseError extends Error {
     constructor(shortMessage, args = {}) {
@@ -8952,6 +8960,8 @@ function resolveConfig(args) {
   const limitStr = getFlag(args, "--limit");
   const limit = limitStr !== undefined ? Number(limitStr) : undefined;
   const performance = getFlag(args, "--performance") ?? undefined;
+  const subgraphRaw = getFlag(args, "--subgraph");
+  const subgraph = subgraphRaw === "index" || subgraphRaw === "yield" ? subgraphRaw : undefined;
   return {
     chainId: Number(chainId),
     allChains,
@@ -8964,7 +8974,8 @@ function resolveConfig(args) {
     account,
     nonce,
     limit,
-    performance
+    performance,
+    subgraph
   };
 }
 function getCommand(args) {
@@ -8972,7 +8983,7 @@ function getCommand(args) {
   let i = 0;
   while (i < args.length) {
     const arg = args[i];
-    if (arg === "--chain" || arg === "--rpc" || arg === "--wallet-key" || arg === "--action" || arg === "--account" || arg === "--nonce" || arg === "--limit" || arg === "--performance" || arg === "--name" || arg === "--symbol" || arg === "--basket" || arg === "--amount" || arg === "--config" || arg === "--mandate") {
+    if (arg === "--chain" || arg === "--rpc" || arg === "--wallet-key" || arg === "--action" || arg === "--account" || arg === "--nonce" || arg === "--limit" || arg === "--performance" || arg === "--name" || arg === "--symbol" || arg === "--basket" || arg === "--amount" || arg === "--config" || arg === "--mandate" || arg === "--subgraph") {
       i += 2;
     } else if (arg === "--json" || arg === "--help" || arg === "--all" || arg === "--dry-run" || arg === "--ungoverned" || arg === "--list-tokens") {
       i++;
@@ -9006,37 +9017,49 @@ function loadRcFile() {
 
 // src/lib/dtf-registry.ts
 var REGISTRY = [
-  { symbol: "CMC20", name: "CoinMarketCap 20 Index DTF", address: "0x2f8a339b5889ffac4c5a956787cda593b3c36867", chainId: 56 },
-  { symbol: "LCAP", name: "CF Large Cap Index", address: "0x4da9a0f397db1397902070f93a4d6ddbc0e0e6e8", chainId: 8453 },
-  { symbol: "VLONE", name: "Reserve Venionaire L1 Select DTF", address: "0xe00cfa595841fb331105b93c19827797c925e3e4", chainId: 8453 },
-  { symbol: "BGCI", name: "Bloomberg Galaxy Crypto Index", address: "0x23418de10d422ad71c9d5713a2b8991a9c586443", chainId: 8453 },
-  { symbol: "ABX", name: "Alpha Base Index", address: "0xebcda5b80f62dd4dd2a96357b42bb6facbf30267", chainId: 8453 },
-  { symbol: "OPEN", name: "Open Stablecoin Index", address: "0x323c03c48660fe31186fa82c289b0766d331ce21", chainId: 1 },
-  { symbol: "CLX", name: "Clanker Index", address: "0x44551ca46fa5592bb572e20043f7c3d54c85cad7", chainId: 8453 },
-  { symbol: "BED", name: "BTC ETH DCA Index", address: "0x4e3b170dcbe704b248df5f56d488114ace01b1c5", chainId: 1 },
-  { symbol: "SMEL", name: "Imagine The SMEL", address: "0xf91384484f4717314798e8975bcd904a35fc2bf1", chainId: 1 },
-  { symbol: "MVTT10F", name: "MarketVector Token Terminal", address: "0xe8b46b116d3bdfa787ce9cf3f5acc78dc7ca380e", chainId: 8453 },
-  { symbol: "ixEdel", name: "Sagix Club Edelweiss", address: "0xe4a10951f962e6cb93cb843a4ef05d2f99db1f94", chainId: 1 },
-  { symbol: "DGI", name: "DeFi Growth Index", address: "0x9a1741e151233a82cf69209a2f1bc7442b1fb29c", chainId: 1 },
-  { symbol: "DFX", name: "CoinDesk DeFi Select Index", address: "0x188d12eb13a5eadd0867074ce8354b1ad6f4790b", chainId: 1 },
-  { symbol: "mvRWA", name: "RWA Index", address: "0xa5cdea03b11042fc10b52af9eca48bb17a2107d2", chainId: 1 },
-  { symbol: "mvDEFI", name: "Large Cap DeFi Index", address: "0x20d81101d254729a6e689418526be31e2c544290", chainId: 1 },
-  { symbol: "AI", name: "AIndex", address: "0xfe45eda533e97198d9f3deeda9ae6c147141f6f9", chainId: 8453 },
-  { symbol: "VTF", name: "Virtuals Index", address: "0x47686106181b3cefe4eaf94c4c10b48ac750370b", chainId: 8453 },
-  { symbol: "ZINDEX", name: "Zora Index", address: "0x160c18476f6f5099f374033fbc695c9234cda495", chainId: 8453 },
-  { symbol: "BDTF", name: "Base MemeIndexer DTF", address: "0xb8753941196692e322846cfee9c14c97ac81928a", chainId: 8453 },
-  { symbol: "CLUB", name: "Club Night DTF", address: "0xf8ef6e785473e82527908b06023ac3e401ccfdcd", chainId: 8453 },
-  { symbol: "MVDA25", name: "MarketVector Digital Assets 25", address: "0xd600e748c17ca237fcb5967fa13d688aff17be78", chainId: 8453 },
-  { symbol: "SBR", name: "Strategic Base Reserve", address: "0x89ff8f639d402839205a6bf03cc01bdffa4768b7", chainId: 8453 }
+  { symbol: "CMC20", name: "CoinMarketCap 20 Index DTF", address: "0x2f8a339b5889ffac4c5a956787cda593b3c36867", chainId: 56, type: "index" },
+  { symbol: "LCAP", name: "CF Large Cap Index", address: "0x4da9a0f397db1397902070f93a4d6ddbc0e0e6e8", chainId: 8453, type: "index" },
+  { symbol: "VLONE", name: "Reserve Venionaire L1 Select DTF", address: "0xe00cfa595841fb331105b93c19827797c925e3e4", chainId: 8453, type: "index" },
+  { symbol: "BGCI", name: "Bloomberg Galaxy Crypto Index", address: "0x23418de10d422ad71c9d5713a2b8991a9c586443", chainId: 8453, type: "index" },
+  { symbol: "ABX", name: "Alpha Base Index", address: "0xebcda5b80f62dd4dd2a96357b42bb6facbf30267", chainId: 8453, type: "index" },
+  { symbol: "OPEN", name: "Open Stablecoin Index", address: "0x323c03c48660fe31186fa82c289b0766d331ce21", chainId: 1, type: "index" },
+  { symbol: "CLX", name: "Clanker Index", address: "0x44551ca46fa5592bb572e20043f7c3d54c85cad7", chainId: 8453, type: "index" },
+  { symbol: "BED", name: "BTC ETH DCA Index", address: "0x4e3b170dcbe704b248df5f56d488114ace01b1c5", chainId: 1, type: "index" },
+  { symbol: "SMEL", name: "Imagine The SMEL", address: "0xf91384484f4717314798e8975bcd904a35fc2bf1", chainId: 1, type: "index" },
+  { symbol: "MVTT10F", name: "MarketVector Token Terminal", address: "0xe8b46b116d3bdfa787ce9cf3f5acc78dc7ca380e", chainId: 8453, type: "index" },
+  { symbol: "ixEdel", name: "Sagix Club Edelweiss", address: "0xe4a10951f962e6cb93cb843a4ef05d2f99db1f94", chainId: 1, type: "index" },
+  { symbol: "DGI", name: "DeFi Growth Index", address: "0x9a1741e151233a82cf69209a2f1bc7442b1fb29c", chainId: 1, type: "index" },
+  { symbol: "DFX", name: "CoinDesk DeFi Select Index", address: "0x188d12eb13a5eadd0867074ce8354b1ad6f4790b", chainId: 1, type: "index" },
+  { symbol: "mvRWA", name: "RWA Index", address: "0xa5cdea03b11042fc10b52af9eca48bb17a2107d2", chainId: 1, type: "index" },
+  { symbol: "mvDEFI", name: "Large Cap DeFi Index", address: "0x20d81101d254729a6e689418526be31e2c544290", chainId: 1, type: "index" },
+  { symbol: "AI", name: "AIndex", address: "0xfe45eda533e97198d9f3deeda9ae6c147141f6f9", chainId: 8453, type: "index" },
+  { symbol: "VTF", name: "Virtuals Index", address: "0x47686106181b3cefe4eaf94c4c10b48ac750370b", chainId: 8453, type: "index" },
+  { symbol: "ZINDEX", name: "Zora Index", address: "0x160c18476f6f5099f374033fbc695c9234cda495", chainId: 8453, type: "index" },
+  { symbol: "BDTF", name: "Base MemeIndexer DTF", address: "0xb8753941196692e322846cfee9c14c97ac81928a", chainId: 8453, type: "index" },
+  { symbol: "CLUB", name: "Club Night DTF", address: "0xf8ef6e785473e82527908b06023ac3e401ccfdcd", chainId: 8453, type: "index" },
+  { symbol: "MVDA25", name: "MarketVector Digital Assets 25", address: "0xd600e748c17ca237fcb5967fa13d688aff17be78", chainId: 8453, type: "index" },
+  { symbol: "SBR", name: "Strategic Base Reserve", address: "0x89ff8f639d402839205a6bf03cc01bdffa4768b7", chainId: 8453, type: "index" },
+  { symbol: "dgnETH", name: "Degen ETH", address: "0x005F893EcD7bF9667195642f7649DA8163e23658", chainId: 1, type: "yield" },
+  { symbol: "eUSD", name: "Electronic Dollar", address: "0xA0d69E286B938e21CBf7E51D71F6A4c8918f482F", chainId: 1, type: "yield" },
+  { symbol: "ETH+", name: "ETHPlus", address: "0xE72B141DF173b999AE7c1aDcbF60Cc9833Ce56a8", chainId: 1, type: "yield" },
+  { symbol: "hyUSD", name: "High Yield USD", address: "0xaCdf0DBA4B9839b96221a8487e9ca660a48212be", chainId: 1, type: "yield" },
+  { symbol: "USDC+", name: "USDC Plus", address: "0xFc0B1EEf20e4c68B3DCF36c4537Cfa7Ce46CA70b", chainId: 1, type: "yield" },
+  { symbol: "USD3", name: "Web 3 Dollar", address: "0x0d86883FAf4FfD7aEb116390af37746F45b6f378", chainId: 1, type: "yield" },
+  { symbol: "rgUSD", name: "Revenue Generating USD", address: "0x78da5799CF427Fee11e9996982F4150eCe7a99A7", chainId: 1, type: "yield" },
+  { symbol: "hyUSD", name: "High Yield USD", address: "0xCc7FF230365bD730eE4B352cC2492CEdAC49383e", chainId: 8453, type: "yield" },
+  { symbol: "BSDX", name: "Base Yield Index", address: "0x8f0987DDb485219c767770e2080E5cC01ddc772a", chainId: 8453, type: "yield" },
+  { symbol: "bsdETH", name: "Based ETH", address: "0xCb327b99fF831bF8223cCEd12B1338FF3aA322Ff", chainId: 8453, type: "yield" },
+  { symbol: "Vaya", name: "Vaya", address: "0xC9a3e2B3064c1c0546D3D0edc0A748E9f93Cf18d", chainId: 8453, type: "yield" },
+  { symbol: "MAAT", name: "Maat", address: "0x641B0453487C9D14c5df96d45a481ef1dc84e31f", chainId: 8453, type: "yield" }
 ];
 function resolveAlias(input) {
   const lower = input.toLowerCase();
   const bySymbol = REGISTRY.find((d) => d.symbol.toLowerCase() === lower);
   if (bySymbol)
-    return { address: bySymbol.address, chainId: bySymbol.chainId };
+    return { address: bySymbol.address, chainId: bySymbol.chainId, type: bySymbol.type };
   const nameMatches = REGISTRY.filter((d) => d.name.toLowerCase().includes(lower));
   if (nameMatches.length === 1) {
-    return { address: nameMatches[0].address, chainId: nameMatches[0].chainId };
+    return { address: nameMatches[0].address, chainId: nameMatches[0].chainId, type: nameMatches[0].type };
   }
   if (nameMatches.length > 1) {
     return {
@@ -9049,6 +9072,10 @@ function resolveAlias(input) {
   }
   return null;
 }
+function getRegistryType(address) {
+  const lower = address.toLowerCase();
+  return REGISTRY.find((d) => d.address.toLowerCase() === lower)?.type;
+}
 
 // src/lib/cache.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync, rmSync } from "fs";
@@ -9104,7 +9131,7 @@ function setCache(chainId, address, data) {
 
 // ../sdk/dist/index.js
 init_index_qp8fkhx7();
-init_index_tdmavmz7();
+init_index_azrx1hqn();
 init_index_sdksp5px();
 var require_types = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -19505,6 +19532,14 @@ var SUBGRAPH_URLS = {
   56: "https://api.goldsky.com/api/public/project_cmgzim3e100095np2gjnbh6ry/subgraphs/dtf-index-bsc/prod/gn",
   8453: "https://api.goldsky.com/api/public/project_cmgzim3e100095np2gjnbh6ry/subgraphs/dtf-index-base/prod/gn"
 };
+var YIELD_SUBGRAPH_URLS = {
+  1: "https://api.goldsky.com/api/public/project_cmgzim3e100095np2gjnbh6ry/subgraphs/dtf-yield-mainnet/4.2.0-v2/gn",
+  8453: "https://api.goldsky.com/api/public/project_cmgzim3e100095np2gjnbh6ry/subgraphs/dtf-yield-base/4.2.0-v2/gn"
+};
+var FACADE_READ_ADDRESS = {
+  1: "0x2C7ca56342177343A2954C250702Fd464f4d0613",
+  8453: "0xeb2071e9b542555e90e6e4e1f83fa17423583991"
+};
 var SUPPORTED_CHAINS = [1, 56, 8453];
 var CHAINLINK_BTC_USD = "0xF4030086522a5bEEa4988F8cA5B36dbC97BeE88c";
 var CHAINLINK_RSR_USD = "0x759bBC1be8F90eE6457C44abc7d443842a976d02";
@@ -19600,11 +19635,11 @@ async function fetchWithRetry(url, init, opts) {
   }
   throw lastError;
 }
-async function querySubgraph(chainId, query, variables = {}) {
-  const url = SUBGRAPH_URLS[chainId];
-  if (!url)
+async function querySubgraph(chainId, query, variables = {}, url) {
+  const endpoint = url ?? SUBGRAPH_URLS[chainId];
+  if (!endpoint)
     throw new Error(`No subgraph URL for chainId ${chainId}`);
-  const response = await fetchWithRetry(url, {
+  const response = await fetchWithRetry(endpoint, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ query, variables })
@@ -21176,240 +21211,705 @@ async function fetchVoteLockPositions(baseUrl = RESERVE_API_BASE_URL) {
   }
   return await response.json();
 }
-async function readMintQuote(publicClient, folioAddress, shares) {
-  const results = await publicClient.multicall({
-    contracts: [
-      {
-        address: folioAddress,
-        abi: folio_default,
-        functionName: "toAssets",
-        args: [shares, 1]
-      },
-      {
-        address: folioAddress,
-        abi: folio_default,
-        functionName: "mintFee"
-      }
-    ]
-  });
-  if (results[0].status !== "success")
-    throw new Error(`toAssets failed for ${folioAddress} with ${shares} shares`);
-  if (results[1].status !== "success")
-    throw new Error(`mintFee failed for ${folioAddress}`);
-  const [assets, amounts] = results[0].result;
-  const mintFee = results[1].result;
-  const minSharesOut = shares - shares * mintFee / D18;
-  return { shares, assets, amounts, mintFee, minSharesOut };
-}
-async function readMintFee(publicClient, folioAddress) {
-  return await publicClient.readContract({
-    address: folioAddress,
-    abi: folio_default,
-    functionName: "mintFee"
-  });
-}
-function applySlippage(amount, slippageBps) {
-  if (slippageBps < 0n || slippageBps > 10000n) {
-    throw new Error(`slippageBps must be between 0 and 10000, got ${slippageBps}`);
-  }
-  return amount - amount * slippageBps / 10000n;
-}
-async function readRedeemQuote(publicClient, folioAddress, shares) {
-  const result = await publicClient.readContract({
-    address: folioAddress,
-    abi: folio_default,
-    functionName: "toAssets",
-    args: [shares, 0]
-  });
-  const [assets, amounts] = result;
-  return { shares, assets, amounts };
-}
-async function readPendingFees(publicClient, folioAddress) {
-  const results = await publicClient.multicall({
-    contracts: [
-      {
-        address: folioAddress,
-        abi: folio_default,
-        functionName: "getPendingFeeShares"
-      },
-      {
-        address: folioAddress,
-        abi: folio_default,
-        functionName: "feeRecipientsPendingFeeShares"
-      },
-      {
-        address: folioAddress,
-        abi: folio_default,
-        functionName: "daoPendingFeeShares"
-      }
-    ]
-  });
-  const total = results[0].status === "success" ? results[0].result : 0n;
-  const folio = results[1].status === "success" ? results[1].result : 0n;
-  const dao = results[2].status === "success" ? results[2].result : 0n;
-  return { total, folio, dao };
-}
-async function readFeeRecipients(publicClient, folioAddress) {
-  const indices = Array.from({ length: 10 }, (_, i) => i);
-  const results = await publicClient.multicall({
-    contracts: indices.map((i) => ({
-      address: folioAddress,
-      abi: folio_default,
-      functionName: "feeRecipients",
-      args: [BigInt(i)]
-    }))
-  });
-  const recipients = [];
-  for (const r of results) {
-    if (r.status !== "success")
-      break;
-    const [recipient, portion] = r.result;
-    recipients.push({ recipient, portion });
-  }
-  return recipients;
-}
-async function fetchRebalanceHistory(chainId, folioAddress, opts, baseUrl = RESERVE_API_BASE_URL) {
-  const skip = opts?.skip ?? 0;
-  const limit = opts?.limit ?? 50;
-  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}`);
-  }
-  return await response.json();
-}
-async function fetchRebalanceDetail(chainId, folioAddress, nonce, baseUrl = RESERVE_API_BASE_URL) {
-  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}`);
-  }
-  return await response.json();
-}
-async function fetchHistoricalDtf(chainId, folioAddress, opts, baseUrl = RESERVE_API_BASE_URL) {
-  const now = Math.floor(Date.now() / 1000);
-  const to = opts?.to ?? now;
-  const from14 = opts?.from ?? to - 2592000;
-  const interval = opts?.interval ?? "1h";
-  const url = `${baseUrl}/historical/dtf?address=${folioAddress.toLowerCase()}&chainId=${chainId}&from=${from14}&to=${to}&interval=${interval}`;
-  const response = await fetchWithRetry(url);
-  if (!response.ok) {
-    throw new Error(`Reserve API /historical/dtf failed: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  if (Array.isArray(data))
-    return data;
-  return data.timeseries ?? [];
-}
-var governor_default = [
+var stRSRAbi = [
   {
-    type: "constructor",
     inputs: [],
-    stateMutability: "nonpayable"
+    name: "exchangeRate",
+    outputs: [{ internalType: "uint192", name: "", type: "uint192" }],
+    stateMutability: "view",
+    type: "function"
   },
   {
-    type: "receive",
-    stateMutability: "payable"
+    inputs: [],
+    name: "totalSupply",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
   },
   {
-    type: "function",
-    name: "BALLOT_TYPEHASH",
     inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
+    name: "unstakingDelay",
+    outputs: [{ internalType: "uint48", name: "", type: "uint48" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "account", type: "address" }
     ],
-    stateMutability: "view"
+    name: "balanceOf",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
   },
   {
-    type: "function",
-    name: "CLOCK_MODE",
     inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "string",
-        internalType: "string"
-      }
-    ],
-    stateMutability: "view"
+    name: "main",
+    outputs: [{ internalType: "contract IMain", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
   },
   {
-    type: "function",
-    name: "COUNTING_MODE",
     inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "string",
-        internalType: "string"
-      }
-    ],
-    stateMutability: "pure"
+    name: "name",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
   },
   {
-    type: "function",
-    name: "EXTENDED_BALLOT_TYPEHASH",
     inputs: [],
-    outputs: [
-      {
-        name: "",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
-    ],
-    stateMutability: "view"
+    name: "symbol",
+    outputs: [{ internalType: "string", name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
   },
   {
-    type: "function",
-    name: "cancel",
     inputs: [
-      {
-        name: "targets",
-        type: "address[]",
-        internalType: "address[]"
-      },
-      {
-        name: "values",
-        type: "uint256[]",
-        internalType: "uint256[]"
-      },
-      {
-        name: "calldatas",
-        type: "bytes[]",
-        internalType: "bytes[]"
-      },
-      {
-        name: "descriptionHash",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
+      { internalType: "address", name: "account", type: "address" }
     ],
-    stateMutability: "nonpayable"
+    name: "delegates",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
   },
   {
-    type: "function",
-    name: "castVote",
     inputs: [
-      {
-        name: "proposalId",
-        type: "uint256",
-        internalType: "uint256"
-      },
-      {
-        name: "support",
-        type: "uint8",
-        internalType: "uint8"
+      { internalType: "address", name: "account", type: "address" }
+    ],
+    name: "getVotes",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var mainAbi = [
+  {
+    inputs: [],
+    name: "rToken",
+    outputs: [{ internalType: "contract IRToken", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "stRSR",
+    outputs: [{ internalType: "contract IStRSR", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "assetRegistry",
+    outputs: [{ internalType: "contract IAssetRegistry", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "basketHandler",
+    outputs: [{ internalType: "contract IBasketHandler", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "backingManager",
+    outputs: [{ internalType: "contract IBackingManager", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "distributor",
+    outputs: [{ internalType: "contract IDistributor", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "furnace",
+    outputs: [{ internalType: "contract IFurnace", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "broker",
+    outputs: [{ internalType: "contract IBroker", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "rsrTrader",
+    outputs: [{ internalType: "contract IRevenueTrader", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "rTokenTrader",
+    outputs: [{ internalType: "contract IRevenueTrader", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+async function detectDtfType(publicClient, address) {
+  try {
+    const mainAddress = await publicClient.readContract({
+      address,
+      abi: stRSRAbi,
+      functionName: "main"
+    });
+    const rTokenAddress = await publicClient.readContract({
+      address: mainAddress,
+      abi: mainAbi,
+      functionName: "rToken"
+    });
+    if (rTokenAddress.toLowerCase() === address.toLowerCase()) {
+      return "yield";
+    }
+    return "index";
+  } catch {
+    return "index";
+  }
+}
+async function readYieldDtfComponents(publicClient, rTokenAddress) {
+  const mainAddress = await publicClient.readContract({
+    address: rTokenAddress,
+    abi: stRSRAbi,
+    functionName: "main"
+  });
+  const results = await publicClient.multicall({
+    contracts: [
+      { address: mainAddress, abi: mainAbi, functionName: "rToken" },
+      { address: mainAddress, abi: mainAbi, functionName: "stRSR" },
+      { address: mainAddress, abi: mainAbi, functionName: "assetRegistry" },
+      { address: mainAddress, abi: mainAbi, functionName: "basketHandler" },
+      { address: mainAddress, abi: mainAbi, functionName: "backingManager" },
+      { address: mainAddress, abi: mainAbi, functionName: "distributor" },
+      { address: mainAddress, abi: mainAbi, functionName: "furnace" },
+      { address: mainAddress, abi: mainAbi, functionName: "broker" },
+      { address: mainAddress, abi: mainAbi, functionName: "rsrTrader" },
+      { address: mainAddress, abi: mainAbi, functionName: "rTokenTrader" }
+    ],
+    allowFailure: false
+  });
+  return {
+    main: mainAddress,
+    rToken: results[0],
+    stRSR: results[1],
+    assetRegistry: results[2],
+    basketHandler: results[3],
+    backingManager: results[4],
+    distributor: results[5],
+    furnace: results[6],
+    broker: results[7],
+    rsrTrader: results[8],
+    rTokenTrader: results[9]
+  };
+}
+var facadeReadAbi = [
+  {
+    inputs: [
+      { internalType: "contract IRToken", name: "rToken", type: "address" }
+    ],
+    name: "backingOverview",
+    outputs: [
+      { internalType: "uint192", name: "backing", type: "uint192" },
+      { internalType: "uint192", name: "overCollateralization", type: "uint192" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "contract IRToken", name: "rToken", type: "address" }
+    ],
+    name: "basketBreakdown",
+    outputs: [
+      { internalType: "address[]", name: "erc20s", type: "address[]" },
+      { internalType: "uint192[]", name: "uoaShares", type: "uint192[]" },
+      { internalType: "bytes32[]", name: "targets", type: "bytes32[]" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "contract IRToken", name: "rToken", type: "address" }
+    ],
+    name: "basketTokens",
+    outputs: [
+      { internalType: "address[]", name: "tokens", type: "address[]" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "contract IRToken", name: "rToken", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" }
+    ],
+    name: "issue",
+    outputs: [
+      { internalType: "address[]", name: "tokens", type: "address[]" },
+      { internalType: "uint256[]", name: "deposits", type: "uint256[]" },
+      { internalType: "uint192[]", name: "depositsUoA", type: "uint192[]" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "contract IRToken", name: "rToken", type: "address" }
+    ],
+    name: "price",
+    outputs: [
+      { internalType: "uint192", name: "low", type: "uint192" },
+      { internalType: "uint192", name: "high", type: "uint192" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "contract IRToken", name: "rToken", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" }
+    ],
+    name: "redeem",
+    outputs: [
+      { internalType: "address[]", name: "tokens", type: "address[]" },
+      { internalType: "uint256[]", name: "withdrawals", type: "uint256[]" },
+      { internalType: "uint256[]", name: "available", type: "uint256[]" }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "contract IRToken", name: "rToken", type: "address" }
+    ],
+    name: "stToken",
+    outputs: [
+      { internalType: "contract IStRSR", name: "stTokenAddress", type: "address" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+async function readYieldDtfBasket(publicClient, facadeAddress, rTokenAddress) {
+  const result = await publicClient.readContract({
+    address: facadeAddress,
+    abi: facadeReadAbi,
+    functionName: "basketBreakdown",
+    args: [rTokenAddress]
+  });
+  const [erc20s, uoaShares, targets] = result;
+  const tokenMeta = await fetchTokenMetadata(publicClient, erc20s);
+  return tokenMeta.map((token, i) => ({
+    address: token.address,
+    symbol: token.symbol,
+    decimals: token.decimals,
+    targetUnit: decodeBytes32(targets[i]),
+    uoaShare: uoaShares[i]
+  }));
+}
+function decodeBytes32(hex) {
+  if (hex === "0x0000000000000000000000000000000000000000000000000000000000000000")
+    return "";
+  try {
+    return hexToString(hex, { size: 32 });
+  } catch {
+    return hex;
+  }
+}
+async function readBackingOverview(publicClient, facadeAddress, rTokenAddress) {
+  const [backing, overCollateralization] = await publicClient.readContract({
+    address: facadeAddress,
+    abi: facadeReadAbi,
+    functionName: "backingOverview",
+    args: [rTokenAddress]
+  });
+  return {
+    backing,
+    overCollateralization
+  };
+}
+async function readYieldDtfPrice(publicClient, facadeAddress, rTokenAddress) {
+  const [low, high] = await publicClient.readContract({
+    address: facadeAddress,
+    abi: facadeReadAbi,
+    functionName: "price",
+    args: [rTokenAddress]
+  });
+  return { low, high };
+}
+async function readStRSRInfo(publicClient, stRSRAddress, account) {
+  const baseContracts = [
+    { address: stRSRAddress, abi: stRSRAbi, functionName: "exchangeRate" },
+    { address: stRSRAddress, abi: stRSRAbi, functionName: "totalSupply" },
+    { address: stRSRAddress, abi: stRSRAbi, functionName: "unstakingDelay" }
+  ];
+  const accountContracts = account ? [
+    { address: stRSRAddress, abi: stRSRAbi, functionName: "balanceOf", args: [account] },
+    { address: stRSRAddress, abi: stRSRAbi, functionName: "getVotes", args: [account] },
+    { address: stRSRAddress, abi: stRSRAbi, functionName: "delegates", args: [account] }
+  ] : [];
+  const results = await publicClient.multicall({
+    contracts: [...baseContracts, ...accountContracts],
+    allowFailure: false
+  });
+  const info = {
+    exchangeRate: results[0],
+    totalSupply: results[1],
+    unstakingDelay: results[2]
+  };
+  if (account) {
+    info.balance = results[3];
+    info.votingPower = results[4];
+    info.delegatee = results[5];
+  }
+  return info;
+}
+var distributorAbi = [
+  {
+    inputs: [],
+    name: "totals",
+    outputs: [
+      {
+        components: [
+          { internalType: "uint24", name: "rTokenTotal", type: "uint24" },
+          { internalType: "uint24", name: "rsrTotal", type: "uint24" }
+        ],
+        internalType: "struct RevenueTotals",
+        name: "revTotals",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+async function readDistribution(publicClient, distributorAddress) {
+  const result = await publicClient.readContract({
+    address: distributorAddress,
+    abi: distributorAbi,
+    functionName: "totals"
+  });
+  const totals = result;
+  return {
+    rTokenTotal: BigInt(totals.rTokenTotal),
+    rsrTotal: BigInt(totals.rsrTotal)
+  };
+}
+async function fetchYieldDtfConfig(publicClient, chainId, rTokenAddress) {
+  const facadeAddress = FACADE_READ_ADDRESS[chainId];
+  if (!facadeAddress) {
+    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([
+    readYieldDtfBasket(publicClient, facadeAddress, rTokenAddress),
+    readBackingOverview(publicClient, facadeAddress, rTokenAddress),
+    readYieldDtfPrice(publicClient, facadeAddress, rTokenAddress),
+    publicClient.readContract({
+      address: rTokenAddress,
+      abi: ERC20_META_ABI,
+      functionName: "name"
+    }),
+    publicClient.readContract({
+      address: rTokenAddress,
+      abi: ERC20_META_ABI,
+      functionName: "symbol"
+    }),
+    readStRSRInfo(publicClient, components.stRSR),
+    readDistribution(publicClient, components.distributor)
+  ]);
+  return {
+    type: "yield",
+    components,
+    name: nameResult,
+    symbol: symbolResult,
+    basket,
+    backing,
+    priceLow: price.low,
+    priceHigh: price.high,
+    exchangeRate: stRSRInfo.exchangeRate,
+    unstakingDelay: stRSRInfo.unstakingDelay,
+    rTokenTotal: distribution.rTokenTotal,
+    rsrTotal: distribution.rsrTotal
+  };
+}
+async function readIssueQuote(publicClient, facadeAddress, rTokenAddress, amount) {
+  const result = await publicClient.readContract({
+    address: facadeAddress,
+    abi: facadeReadAbi,
+    functionName: "issue",
+    args: [rTokenAddress, amount]
+  });
+  const [tokens, deposits, depositsUoA] = result;
+  return { tokens, deposits, depositsUoA };
+}
+async function readRedeemQuote(publicClient, facadeAddress, rTokenAddress, amount) {
+  const result = await publicClient.readContract({
+    address: facadeAddress,
+    abi: facadeReadAbi,
+    functionName: "redeem",
+    args: [rTokenAddress, amount]
+  });
+  const [tokens, withdrawals, available] = result;
+  return { tokens, withdrawals, available };
+}
+async function readMintQuote(publicClient, folioAddress, shares) {
+  const results = await publicClient.multicall({
+    contracts: [
+      {
+        address: folioAddress,
+        abi: folio_default,
+        functionName: "toAssets",
+        args: [shares, 1]
+      },
+      {
+        address: folioAddress,
+        abi: folio_default,
+        functionName: "mintFee"
+      }
+    ]
+  });
+  if (results[0].status !== "success")
+    throw new Error(`toAssets failed for ${folioAddress} with ${shares} shares`);
+  if (results[1].status !== "success")
+    throw new Error(`mintFee failed for ${folioAddress}`);
+  const [assets, amounts] = results[0].result;
+  const mintFee = results[1].result;
+  const minSharesOut = shares - shares * mintFee / D18;
+  return { shares, assets, amounts, mintFee, minSharesOut };
+}
+async function readMintFee(publicClient, folioAddress) {
+  return await publicClient.readContract({
+    address: folioAddress,
+    abi: folio_default,
+    functionName: "mintFee"
+  });
+}
+function applySlippage(amount, slippageBps) {
+  if (slippageBps < 0n || slippageBps > 10000n) {
+    throw new Error(`slippageBps must be between 0 and 10000, got ${slippageBps}`);
+  }
+  return amount - amount * slippageBps / 10000n;
+}
+async function readRedeemQuote2(publicClient, folioAddress, shares) {
+  const result = await publicClient.readContract({
+    address: folioAddress,
+    abi: folio_default,
+    functionName: "toAssets",
+    args: [shares, 0]
+  });
+  const [assets, amounts] = result;
+  return { shares, assets, amounts };
+}
+async function readPendingFees(publicClient, folioAddress) {
+  const results = await publicClient.multicall({
+    contracts: [
+      {
+        address: folioAddress,
+        abi: folio_default,
+        functionName: "getPendingFeeShares"
+      },
+      {
+        address: folioAddress,
+        abi: folio_default,
+        functionName: "feeRecipientsPendingFeeShares"
+      },
+      {
+        address: folioAddress,
+        abi: folio_default,
+        functionName: "daoPendingFeeShares"
+      }
+    ]
+  });
+  const total = results[0].status === "success" ? results[0].result : 0n;
+  const folio = results[1].status === "success" ? results[1].result : 0n;
+  const dao = results[2].status === "success" ? results[2].result : 0n;
+  return { total, folio, dao };
+}
+async function readFeeRecipients(publicClient, folioAddress) {
+  const indices = Array.from({ length: 10 }, (_, i) => i);
+  const results = await publicClient.multicall({
+    contracts: indices.map((i) => ({
+      address: folioAddress,
+      abi: folio_default,
+      functionName: "feeRecipients",
+      args: [BigInt(i)]
+    }))
+  });
+  const recipients = [];
+  for (const r of results) {
+    if (r.status !== "success")
+      break;
+    const [recipient, portion] = r.result;
+    recipients.push({ recipient, portion });
+  }
+  return recipients;
+}
+async function fetchRebalanceHistory(chainId, folioAddress, opts, baseUrl = RESERVE_API_BASE_URL) {
+  const skip = opts?.skip ?? 0;
+  const limit = opts?.limit ?? 50;
+  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}`);
+  }
+  return await response.json();
+}
+async function fetchRebalanceDetail(chainId, folioAddress, nonce, baseUrl = RESERVE_API_BASE_URL) {
+  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}`);
+  }
+  return await response.json();
+}
+async function fetchHistoricalDtf(chainId, folioAddress, opts, baseUrl = RESERVE_API_BASE_URL) {
+  const now = Math.floor(Date.now() / 1000);
+  const to = opts?.to ?? now;
+  const from14 = opts?.from ?? to - 2592000;
+  const interval = opts?.interval ?? "1h";
+  const url = `${baseUrl}/historical/dtf?address=${folioAddress.toLowerCase()}&chainId=${chainId}&from=${from14}&to=${to}&interval=${interval}`;
+  const response = await fetchWithRetry(url);
+  if (!response.ok) {
+    throw new Error(`Reserve API /historical/dtf failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (Array.isArray(data))
+    return data;
+  return data.timeseries ?? [];
+}
+async function fetchHistoricalPrices(chainId, tokenAddress, opts, baseUrl = RESERVE_API_BASE_URL) {
+  const now = Math.floor(Date.now() / 1000);
+  const to = opts?.to ?? now;
+  const from14 = opts?.from ?? to - 2592000;
+  const interval = opts?.interval ?? "1h";
+  const url = `${baseUrl}/historical/prices?address=${tokenAddress.toLowerCase()}&chainId=${chainId}&from=${from14}&to=${to}&interval=${interval}`;
+  const response = await fetchWithRetry(url);
+  if (!response.ok) {
+    throw new Error(`Reserve API /historical/prices failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (Array.isArray(data))
+    return data;
+  return data.timeseries ?? [];
+}
+var governor_default = [
+  {
+    type: "constructor",
+    inputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "receive",
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "BALLOT_TYPEHASH",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "CLOCK_MODE",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "COUNTING_MODE",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "pure"
+  },
+  {
+    type: "function",
+    name: "EXTENDED_BALLOT_TYPEHASH",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "cancel",
+    inputs: [
+      {
+        name: "targets",
+        type: "address[]",
+        internalType: "address[]"
+      },
+      {
+        name: "values",
+        type: "uint256[]",
+        internalType: "uint256[]"
+      },
+      {
+        name: "calldatas",
+        type: "bytes[]",
+        internalType: "bytes[]"
+      },
+      {
+        name: "descriptionHash",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "castVote",
+    inputs: [
+      {
+        name: "proposalId",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "support",
+        type: "uint8",
+        internalType: "uint8"
       }
     ],
     outputs: [
@@ -25137,6 +25637,7 @@ function computeHistoricalBurnTotals(burns, prices) {
 
 // src/lib/cached-config.ts
 var CACHE_NAMESPACE = "config";
+var YIELD_CACHE_NAMESPACE = "yield-config";
 async function fetchDtfConfigCached(fetchFn, publicClient, chainId, address) {
   const cacheKey3 = `${CACHE_NAMESPACE}:${address.toLowerCase()}`;
   const cached = getCached(chainId, cacheKey3);
@@ -25146,6 +25647,22 @@ async function fetchDtfConfigCached(fetchFn, publicClient, chainId, address) {
   setCache(chainId, cacheKey3, config);
   return config;
 }
+async function fetchYieldDtfConfigCached(fetchFn, publicClient, chainId, address) {
+  const cacheKey3 = `${YIELD_CACHE_NAMESPACE}:${address.toLowerCase()}`;
+  const cached = getCached(chainId, cacheKey3);
+  if (cached)
+    return cached;
+  const config = await fetchFn(publicClient, chainId, address);
+  setCache(chainId, cacheKey3, config);
+  return config;
+}
+
+// src/lib/detect-type.ts
+async function resolveDtfType(publicClient, address, registryType) {
+  if (registryType)
+    return registryType;
+  return detectDtfType(publicClient, address);
+}
 
 // src/lib/output.ts
 function printTable(columns, rows) {
@@ -25231,10 +25748,16 @@ async function infoCommand(address, config) {
     chainId: config.chainId,
     rpc: config.rpc
   });
+  const dtfType = await resolveDtfType(publicClient, address, config.dtfType);
+  if (dtfType === "yield") {
+    await yieldInfo(publicClient, address, config);
+    return;
+  }
   const dtfConfig = await fetchDtfConfigCached(fetchDtfConfig, publicClient, config.chainId, address);
   if (config.json) {
     printJson({
       dtf: address,
+      type: "index",
       chain: config.chainId,
       chainLabel: chainLabel(config.chainId),
       ownerGovernance: govToJson(dtfConfig.ownerGovernance),
@@ -25261,6 +25784,7 @@ async function infoCommand(address, config) {
   console.log();
   const rows = [
     { prop: "DTF Address", value: address },
+    { prop: "Type", value: "Index DTF" },
     { prop: "Auction Length", value: formatDuration(dtfConfig.auctionLength) }
   ];
   if (dtfConfig.mandate) {
@@ -25322,11 +25846,99 @@ async function infoCommand(address, config) {
     ], roleRows);
   }
 }
+async function yieldInfo(publicClient, address, config) {
+  const yieldConfig = await fetchYieldDtfConfigCached(fetchYieldDtfConfig, publicClient, config.chainId, address);
+  const backingPct = Number(yieldConfig.backing.backing) / Number(D18);
+  const overCollPct = Number(yieldConfig.backing.overCollateralization) / Number(D18);
+  const priceLow = Number(yieldConfig.priceLow) / Number(D18);
+  const priceHigh = Number(yieldConfig.priceHigh) / Number(D18);
+  const exchangeRate = Number(yieldConfig.exchangeRate) / Number(D18);
+  const totalDist = Number(yieldConfig.rTokenTotal) + Number(yieldConfig.rsrTotal);
+  const rTokenPct = totalDist > 0 ? Number(yieldConfig.rTokenTotal) / totalDist : 0;
+  const rsrPct = totalDist > 0 ? 1 - rTokenPct : 0;
+  if (config.json) {
+    printJson({
+      dtf: address,
+      type: "yield",
+      chain: config.chainId,
+      chainLabel: chainLabel(config.chainId),
+      name: yieldConfig.name,
+      symbol: yieldConfig.symbol,
+      components: yieldConfig.components,
+      backing: yieldConfig.backing.backing.toString(),
+      backingPercent: backingPct * 100,
+      overCollateralization: yieldConfig.backing.overCollateralization.toString(),
+      overCollateralizationPercent: overCollPct * 100,
+      priceLow: yieldConfig.priceLow.toString(),
+      priceHigh: yieldConfig.priceHigh.toString(),
+      priceLowHuman: priceLow,
+      priceHighHuman: priceHigh,
+      exchangeRate: yieldConfig.exchangeRate.toString(),
+      exchangeRateHuman: exchangeRate,
+      unstakingDelay: yieldConfig.unstakingDelay.toString(),
+      unstakingDelayHuman: formatDuration(Number(yieldConfig.unstakingDelay)),
+      rTokenTotal: yieldConfig.rTokenTotal.toString(),
+      rsrTotal: yieldConfig.rsrTotal.toString(),
+      distributionPercent: { holders: rTokenPct * 100, stakers: rsrPct * 100 },
+      basket: yieldConfig.basket.map((t) => ({
+        address: t.address,
+        symbol: t.symbol,
+        decimals: t.decimals,
+        targetUnit: t.targetUnit,
+        uoaShare: t.uoaShare.toString(),
+        uoaSharePercent: Number(t.uoaShare) / Number(D18) * 100
+      }))
+    });
+    return;
+  }
+  printHeader(`Yield DTF Info — ${yieldConfig.symbol} (${chainLabel(config.chainId)})`);
+  console.log();
+  printTable([
+    { header: "Property", key: "prop" },
+    { header: "Value", key: "value" }
+  ], [
+    { prop: "Name", value: yieldConfig.name },
+    { prop: "Symbol", value: yieldConfig.symbol },
+    { prop: "Type", value: "Yield DTF (RToken)" },
+    { prop: "Address", value: address },
+    { prop: "Price", value: `$${priceLow.toFixed(4)} - $${priceHigh.toFixed(4)}` },
+    { prop: "Backing", value: formatPct(backingPct) },
+    { prop: "Over-collateralization", value: formatPct(overCollPct) },
+    { prop: "Revenue Split", value: `${formatPct(rTokenPct)} holders / ${formatPct(rsrPct)} stakers` },
+    { prop: "StRSR Exchange Rate", value: `${exchangeRate.toFixed(6)} RSR/stRSR` },
+    { prop: "Unstaking Delay", value: formatDuration(Number(yieldConfig.unstakingDelay)) },
+    { prop: "Main", value: yieldConfig.components.main },
+    { prop: "StRSR", value: yieldConfig.components.stRSR }
+  ]);
+  if (yieldConfig.basket.length > 0) {
+    console.log();
+    printTable([
+      { header: "Token", key: "symbol" },
+      { header: "Target", key: "target" },
+      { header: "UoA Share", key: "share", align: "right" },
+      { header: "Address", key: "address" }
+    ], yieldConfig.basket.map((t) => ({
+      symbol: t.symbol,
+      target: t.targetUnit,
+      share: formatPct(Number(t.uoaShare) / Number(D18)),
+      address: formatAddress(t.address)
+    })));
+  }
+}
 
 // ../../node_modules/.bun/viem@2.46.2+1fb4c65d43e298b9/node_modules/viem/_esm/index.js
 init_isAddress();
 // src/commands/basket.ts
 async function basketCommand(address, config) {
+  const { publicClient } = createDtfClients({
+    chainId: config.chainId,
+    rpc: config.rpc
+  });
+  const dtfType = await resolveDtfType(publicClient, address, config.dtfType);
+  if (dtfType === "yield") {
+    await yieldBasket(publicClient, address, config);
+    return;
+  }
   try {
     await basketFromApi(address, config);
   } catch {
@@ -25334,6 +25946,43 @@ async function basketCommand(address, config) {
     await basketFromRpc(address, config);
   }
 }
+async function yieldBasket(publicClient, address, config) {
+  const facadeAddress = FACADE_READ_ADDRESS[config.chainId];
+  if (!facadeAddress) {
+    throw new Error(`No FacadeRead address for chain ${config.chainId}`);
+  }
+  const basket = await readYieldDtfBasket(publicClient, facadeAddress, address);
+  if (config.json) {
+    printJson({
+      dtf: address,
+      type: "yield",
+      chain: config.chainId,
+      chainLabel: chainLabel(config.chainId),
+      tokens: basket.map((t) => ({
+        address: t.address,
+        symbol: t.symbol,
+        decimals: t.decimals,
+        targetUnit: t.targetUnit,
+        uoaShare: t.uoaShare.toString(),
+        uoaSharePercent: Number(t.uoaShare) / Number(D18) * 100
+      }))
+    });
+    return;
+  }
+  printHeader(`Yield DTF Basket — ${formatAddress(address)} (${chainLabel(config.chainId)})`);
+  console.log();
+  printTable([
+    { header: "Token", key: "symbol" },
+    { header: "Target", key: "target" },
+    { header: "UoA Share", key: "share", align: "right" },
+    { header: "Address", key: "address" }
+  ], basket.map((t) => ({
+    symbol: t.symbol,
+    target: t.targetUnit,
+    share: formatPct(Number(t.uoaShare) / Number(D18)),
+    address: formatAddress(t.address)
+  })));
+}
 async function basketFromApi(address, config) {
   const { publicClient } = createDtfClients({
     chainId: config.chainId,
@@ -25350,6 +25999,7 @@ async function basketFromApi(address, config) {
   if (config.json) {
     printJson({
       dtf: address,
+      type: "index",
       chain: config.chainId,
       chainLabel: chainLabel(config.chainId),
       tokens: data.basket.map((t) => ({
@@ -25405,6 +26055,7 @@ async function basketFromRpc(address, config) {
   if (config.json) {
     printJson({
       dtf: address,
+      type: "index",
       chain: config.chainId,
       chainLabel: chainLabel(config.chainId),
       tokens: tokenValues.map((t) => ({
@@ -25728,6 +26379,16 @@ async function rebalanceCommand(address, config) {
     chainId: config.chainId,
     rpc: config.rpc
   });
+  const dtfType = await resolveDtfType(publicClient, address, config.dtfType);
+  if (dtfType === "yield") {
+    const msg = "Yield DTFs rebalance automatically via BackingManager. No manual rebalance state.";
+    if (config.json) {
+      printJson({ dtf: address, type: "yield", chain: config.chainId, chainLabel: chainLabel(config.chainId), message: msg });
+    } else {
+      console.log(msg);
+    }
+    return;
+  }
   const [rebalance, auction] = await Promise.all([
     readRebalanceState(publicClient, address),
     readActiveAuction(publicClient, address)
@@ -25861,6 +26522,21 @@ No active auction.`);
   }
 }
 
+// src/lib/periods.ts
+var PERIOD_SECONDS = {
+  "30d": 30 * 24 * 60 * 60,
+  "3m": 90 * 24 * 60 * 60,
+  "6m": 180 * 24 * 60 * 60,
+  "1y": 365 * 24 * 60 * 60
+};
+function parsePeriodSeconds(period) {
+  const s = PERIOD_SECONDS[period];
+  if (!s) {
+    throw new Error(`Unknown period "${period}". Use: 30d, 3m, 6m, 1y`);
+  }
+  return s;
+}
+
 // src/commands/prices.ts
 async function pricesCommand(address, config) {
   const { publicClient } = createDtfClients({
@@ -25875,23 +26551,53 @@ async function pricesCommand(address, config) {
     fetchTokenVolatility(config.chainId),
     readChainlinkPrice(priceClient)
   ]);
+  const perfPeriod = config.performance;
+  let tokenReturns = null;
+  if (perfPeriod) {
+    const now = Math.floor(Date.now() / 1000);
+    const seconds = parsePeriodSeconds(perfPeriod);
+    const histResults = await Promise.allSettled(tokenAddresses.map((addr) => fetchHistoricalPrices(config.chainId, addr, {
+      from: now - seconds,
+      to: now,
+      interval: "1d"
+    })));
+    tokenReturns = new Map;
+    for (let i = 0;i < tokenAddresses.length; i++) {
+      const hist = histResults[i];
+      let ret = null;
+      if (hist?.status === "fulfilled" && hist.value.length >= 2) {
+        const first = hist.value[0];
+        const last = hist.value[hist.value.length - 1];
+        if (first.price > 0) {
+          ret = Math.round((last.price - first.price) / first.price * 1e4) / 100;
+        }
+      }
+      tokenReturns.set(tokenAddresses[i].toLowerCase(), ret);
+    }
+  }
+  let tokens = basket.tokens.map((t) => {
+    const addr = t.address.toLowerCase();
+    const vol = volatility[addr] ?? "high";
+    const ret = tokenReturns?.get(addr) ?? null;
+    return { ...t, addr, vol, price: prices[addr] ?? 0, ret };
+  });
+  if (tokenReturns) {
+    tokens = [...tokens].sort((a, b) => (b.ret ?? -Infinity) - (a.ret ?? -Infinity));
+  }
   if (config.json) {
     printJson({
       dtf: address,
       chain: config.chainId,
       chainLabel: chainLabel(config.chainId),
-      tokens: basket.tokens.map((t) => {
-        const addr = t.address.toLowerCase();
-        const vol = volatility[addr] ?? "high";
-        return {
-          symbol: t.symbol,
-          address: t.address,
-          price: prices[addr] ?? 0,
-          volatility: vol,
-          auctionPriceError: volatilityToPriceError(vol),
-          proposalPriceError: proposalVolatilityToPriceError(vol)
-        };
-      }),
+      tokens: tokens.map((t) => ({
+        symbol: t.symbol,
+        address: t.address,
+        price: t.price,
+        volatility: t.vol,
+        auctionPriceError: volatilityToPriceError(t.vol),
+        proposalPriceError: proposalVolatilityToPriceError(t.vol),
+        ...tokenReturns ? { [`return_${perfPeriod}`]: t.ret } : {}
+      })),
       btcUsd: btcPrice ? {
         price: btcPrice.record.priceUsd,
         timestamp: btcPrice.record.timestamp,
@@ -25902,25 +26608,30 @@ async function pricesCommand(address, config) {
   }
   printHeader(`DTF Prices — ${formatAddress(address)} (Chain ${config.chainId})`);
   console.log();
-  printTable([
+  const columns = [
     { header: "Token", key: "symbol" },
     { header: "Address", key: "address" },
     { header: "Price (USD)", key: "price", align: "right" },
     { header: "Volatility", key: "volatility" },
     { header: "Auction Error", key: "auctionErr", align: "right" },
     { header: "Proposal Error", key: "proposalErr", align: "right" }
-  ], basket.tokens.map((t) => {
-    const addr = t.address.toLowerCase();
-    const vol = volatility[addr] ?? "high";
-    const price = prices[addr] ?? 0;
-    return {
+  ];
+  if (tokenReturns) {
+    columns.push({ header: perfPeriod, key: "retPeriod", align: "right" });
+  }
+  printTable(columns, tokens.map((t) => {
+    const row = {
       symbol: t.symbol,
       address: formatAddress(t.address),
-      price: formatUsd(price),
-      volatility: vol,
-      auctionErr: `${(volatilityToPriceError(vol) * 100).toFixed(0)}%`,
-      proposalErr: `${(proposalVolatilityToPriceError(vol) * 100).toFixed(0)}%`
+      price: formatUsd(t.price),
+      volatility: t.vol,
+      auctionErr: `${(volatilityToPriceError(t.vol) * 100).toFixed(0)}%`,
+      proposalErr: `${(proposalVolatilityToPriceError(t.vol) * 100).toFixed(0)}%`
     };
+    if (tokenReturns) {
+      row.retPeriod = t.ret !== null ? `${t.ret > 0 ? "+" : ""}${t.ret}%` : "—";
+    }
+    return row;
   }));
   if (btcPrice) {
     console.log();
@@ -25942,6 +26653,11 @@ async function quoteCommand(address, config, rest) {
     chainId: config.chainId,
     rpc: config.rpc
   });
+  const dtfType = await resolveDtfType(publicClient, address, config.dtfType);
+  if (dtfType === "yield") {
+    await yieldQuote(publicClient, address, config, shares, action);
+    return;
+  }
   const dtfConfig = config.json ? await fetchDtfConfigCached(fetchDtfConfig, publicClient, config.chainId, address) : null;
   const tokenByAddress = new Map((dtfConfig?.tokens ?? []).map((t) => [t.address.toLowerCase(), t]));
   if (action === "mint") {
@@ -25971,55 +26687,124 @@ async function quoteCommand(address, config, rest) {
       });
       return;
     }
-    printHeader(`Mint Quote — ${formatAddress(address)}`);
+    printHeader(`Mint Quote — ${formatAddress(address)}`);
+    console.log(`
+Minting ${amount} shares (${formatUnits2(shares, 18)})`);
+    console.log();
+    printTable([
+      { header: "Token", key: "token" },
+      { header: "Amount Required", key: "amount", align: "right" },
+      { header: "With 1% Slippage", key: "slippage", align: "right" }
+    ], quote.assets.map((asset, i) => ({
+      token: formatAddress(asset),
+      amount: quote.amounts[i].toString(),
+      slippage: applySlippage(quote.amounts[i], slippageBps).toString()
+    })));
+    console.log(`
+Mint Fee: ${formatUnits2(quote.mintFee, 18)}`);
+    console.log(`Min Shares Out: ${formatUnits2(quote.minSharesOut, 18)}`);
+  } else {
+    const quote = await readRedeemQuote2(publicClient, address, shares);
+    if (config.json) {
+      printJson({
+        dtf: address,
+        chain: config.chainId,
+        chainLabel: chainLabel(config.chainId),
+        action: "redeem",
+        shares: shares.toString(),
+        sharesHuman: Number(shares) / 1000000000000000000,
+        amounts: quote.assets.map((asset, i) => {
+          const token = tokenByAddress.get(asset.toLowerCase());
+          const decimals = token?.decimals ?? 18;
+          return {
+            address: asset,
+            symbol: token?.symbol ?? null,
+            amount: quote.amounts[i].toString(),
+            amountHuman: Number(quote.amounts[i]) / 10 ** decimals
+          };
+        })
+      });
+      return;
+    }
+    printHeader(`Redeem Quote — ${formatAddress(address)}`);
+    console.log(`
+Redeeming ${amount} shares`);
+    console.log();
+    printTable([
+      { header: "Token", key: "token" },
+      { header: "Amount Out", key: "amount", align: "right" }
+    ], quote.assets.map((asset, i) => ({
+      token: formatAddress(asset),
+      amount: quote.amounts[i].toString()
+    })));
+  }
+}
+async function yieldQuote(publicClient, address, config, shares, action) {
+  const facadeAddress = FACADE_READ_ADDRESS[config.chainId];
+  if (!facadeAddress) {
+    throw new Error(`No FacadeRead address for chain ${config.chainId}`);
+  }
+  if (action === "mint") {
+    const quote = await readIssueQuote(publicClient, facadeAddress, address, shares);
+    if (config.json) {
+      printJson({
+        dtf: address,
+        type: "yield",
+        chain: config.chainId,
+        chainLabel: chainLabel(config.chainId),
+        action: "mint",
+        shares: shares.toString(),
+        sharesHuman: Number(shares) / 1000000000000000000,
+        tokens: quote.tokens.map((token, i) => ({
+          address: token,
+          deposit: quote.deposits[i].toString(),
+          depositUoA: quote.depositsUoA[i].toString()
+        }))
+      });
+      return;
+    }
+    printHeader(`Yield DTF Issue Quote — ${formatAddress(address)}`);
     console.log(`
-Minting ${amount} shares (${formatUnits2(shares, 18)})`);
+Issuing ${Number(shares) / 1000000000000000000} RTokens`);
     console.log();
     printTable([
       { header: "Token", key: "token" },
-      { header: "Amount Required", key: "amount", align: "right" },
-      { header: "With 1% Slippage", key: "slippage", align: "right" }
-    ], quote.assets.map((asset, i) => ({
-      token: formatAddress(asset),
-      amount: quote.amounts[i].toString(),
-      slippage: applySlippage(quote.amounts[i], slippageBps).toString()
+      { header: "Deposit Required", key: "deposit", align: "right" }
+    ], quote.tokens.map((token, i) => ({
+      token: formatAddress(token),
+      deposit: quote.deposits[i].toString()
     })));
-    console.log(`
-Mint Fee: ${formatUnits2(quote.mintFee, 18)}`);
-    console.log(`Min Shares Out: ${formatUnits2(quote.minSharesOut, 18)}`);
   } else {
-    const quote = await readRedeemQuote(publicClient, address, shares);
+    const quote = await readRedeemQuote(publicClient, facadeAddress, address, shares);
     if (config.json) {
       printJson({
         dtf: address,
+        type: "yield",
         chain: config.chainId,
         chainLabel: chainLabel(config.chainId),
         action: "redeem",
         shares: shares.toString(),
         sharesHuman: Number(shares) / 1000000000000000000,
-        amounts: quote.assets.map((asset, i) => {
-          const token = tokenByAddress.get(asset.toLowerCase());
-          const decimals = token?.decimals ?? 18;
-          return {
-            address: asset,
-            symbol: token?.symbol ?? null,
-            amount: quote.amounts[i].toString(),
-            amountHuman: Number(quote.amounts[i]) / 10 ** decimals
-          };
-        })
+        tokens: quote.tokens.map((token, i) => ({
+          address: token,
+          withdrawal: quote.withdrawals[i].toString(),
+          available: quote.available[i].toString()
+        }))
       });
       return;
     }
-    printHeader(`Redeem Quote — ${formatAddress(address)}`);
+    printHeader(`Yield DTF Redeem Quote — ${formatAddress(address)}`);
     console.log(`
-Redeeming ${amount} shares`);
+Redeeming ${Number(shares) / 1000000000000000000} RTokens`);
     console.log();
     printTable([
       { header: "Token", key: "token" },
-      { header: "Amount Out", key: "amount", align: "right" }
-    ], quote.assets.map((asset, i) => ({
-      token: formatAddress(asset),
-      amount: quote.amounts[i].toString()
+      { header: "Withdrawal", key: "withdrawal", align: "right" },
+      { header: "Available", key: "available", align: "right" }
+    ], quote.tokens.map((token, i) => ({
+      token: formatAddress(token),
+      withdrawal: quote.withdrawals[i].toString(),
+      available: quote.available[i].toString()
     })));
   }
 }
@@ -26030,6 +26815,11 @@ async function feesCommand(address, config) {
     chainId: config.chainId,
     rpc: config.rpc
   });
+  const dtfType = await resolveDtfType(publicClient, address, config.dtfType);
+  if (dtfType === "yield") {
+    await yieldFees(publicClient, address, config);
+    return;
+  }
   const [pending, recipients, mintFee, dtfConfig] = await Promise.all([
     readPendingFees(publicClient, address),
     readFeeRecipients(publicClient, address),
@@ -26102,6 +26892,39 @@ Fee Recipients:`);
     })));
   }
 }
+async function yieldFees(publicClient, address, config) {
+  const yieldConfig = await fetchYieldDtfConfigCached(fetchYieldDtfConfig, publicClient, config.chainId, address);
+  const total = Number(yieldConfig.rTokenTotal) + Number(yieldConfig.rsrTotal);
+  const holdersPct = total > 0 ? Number(yieldConfig.rTokenTotal) / total : 0;
+  const stakersPct = total > 0 ? Number(yieldConfig.rsrTotal) / total : 0;
+  if (config.json) {
+    printJson({
+      dtf: address,
+      type: "yield",
+      chain: config.chainId,
+      chainLabel: chainLabel(config.chainId),
+      distribution: {
+        rTokenTotal: yieldConfig.rTokenTotal.toString(),
+        rsrTotal: yieldConfig.rsrTotal.toString(),
+        holdersPercent: holdersPct * 100,
+        stakersPercent: stakersPct * 100
+      }
+    });
+    return;
+  }
+  printHeader(`Yield DTF Revenue Distribution — ${yieldConfig.symbol} (${chainLabel(config.chainId)})`);
+  console.log();
+  printTable([
+    { header: "Destination", key: "dest" },
+    { header: "Share", key: "share", align: "right" },
+    { header: "Basis Points", key: "bps", align: "right" }
+  ], [
+    { dest: "RToken Holders (Furnace)", share: formatPct(holdersPct), bps: yieldConfig.rTokenTotal.toString() },
+    { dest: "RSR Stakers (StRSR)", share: formatPct(stakersPct), bps: yieldConfig.rsrTotal.toString() }
+  ]);
+  console.log();
+  console.log("Revenue comes from collateral yield, distributed via Furnace (melting) and StRSR rewards.");
+}
 
 // src/commands/governance.ts
 async function governanceCommand(address, config) {
@@ -26109,6 +26932,11 @@ async function governanceCommand(address, config) {
     chainId: config.chainId,
     rpc: config.rpc
   });
+  const dtfType = await resolveDtfType(publicClient, address, config.dtfType);
+  if (dtfType === "yield") {
+    await yieldGovernance(address, config);
+    return;
+  }
   const dtfConfig = await fetchDtfConfigCached(fetchDtfConfig, publicClient, config.chainId, address);
   const govs = [];
   if (dtfConfig.ownerGovernance) {
@@ -26197,6 +27025,62 @@ ${g.label} Governance:`);
     ]);
   }
 }
+async function yieldGovernance(address, config) {
+  const subgraphUrl = YIELD_SUBGRAPH_URLS[config.chainId];
+  if (!subgraphUrl) {
+    const msg = `Yield DTF governance not available for chain ${config.chainId} (no subgraph).`;
+    if (config.json) {
+      printJson({ dtf: address, type: "yield", chain: config.chainId, governances: [], message: msg });
+    } else {
+      console.log(msg);
+    }
+    return;
+  }
+  const query = `{
+    rtoken(id: "${address.toLowerCase()}") {
+      id
+      governance {
+        id
+        governor
+        timelock
+      }
+    }
+  }`;
+  try {
+    const data = await querySubgraph(config.chainId, query, {}, subgraphUrl);
+    const gov = data.rtoken?.governance;
+    if (config.json) {
+      printJson({
+        dtf: address,
+        type: "yield",
+        chain: config.chainId,
+        chainLabel: chainLabel(config.chainId),
+        governance: gov ? { governor: gov.governor, timelock: gov.timelock } : null
+      });
+      return;
+    }
+    printHeader(`Yield DTF Governance — ${formatAddress(address)} (${chainLabel(config.chainId)})`);
+    console.log();
+    if (gov) {
+      printTable([
+        { header: "Property", key: "prop" },
+        { header: "Value", key: "value" }
+      ], [
+        { prop: "Governor", value: gov.governor },
+        { prop: "Timelock", value: gov.timelock }
+      ]);
+    } else {
+      console.log("No governance found for this yield DTF.");
+    }
+  } catch {
+    const msg = "Failed to fetch yield DTF governance from subgraph.";
+    if (config.json) {
+      printJson({ dtf: address, type: "yield", chain: config.chainId, governance: null, error: msg });
+    } else {
+      console.log(msg);
+    }
+  }
+}
 
 // src/commands/staking.ts
 async function stakingCommand(address, config, rest) {
@@ -26204,6 +27088,11 @@ async function stakingCommand(address, config, rest) {
     chainId: config.chainId,
     rpc: config.rpc
   });
+  const dtfType = await resolveDtfType(publicClient, address, config.dtfType);
+  if (dtfType === "yield") {
+    await yieldStaking(publicClient, address, config);
+    return;
+  }
   const dtfConfig = await fetchDtfConfigCached(fetchDtfConfig, publicClient, config.chainId, address);
   const stToken = dtfConfig.stTokenAddress;
   if (!stToken) {
@@ -26290,6 +27179,59 @@ Account: ${account}`);
     ]);
   }
 }
+async function yieldStaking(publicClient, address, config) {
+  const yieldConfig = await fetchYieldDtfConfigCached(fetchYieldDtfConfig, publicClient, config.chainId, address);
+  const account = config.account;
+  const stRSRInfo = await readStRSRInfo(publicClient, yieldConfig.components.stRSR, account);
+  const exchangeRate = Number(stRSRInfo.exchangeRate) / Number(D18);
+  if (config.json) {
+    printJson({
+      dtf: address,
+      type: "yield",
+      chain: config.chainId,
+      chainLabel: chainLabel(config.chainId),
+      stRSR: yieldConfig.components.stRSR,
+      exchangeRate: stRSRInfo.exchangeRate.toString(),
+      exchangeRateHuman: exchangeRate,
+      totalSupply: stRSRInfo.totalSupply.toString(),
+      totalSupplyHuman: Number(stRSRInfo.totalSupply) / 1000000000000000000,
+      unstakingDelay: stRSRInfo.unstakingDelay.toString(),
+      unstakingDelayHuman: formatDuration(Number(stRSRInfo.unstakingDelay)),
+      account: account && stRSRInfo.balance !== undefined ? {
+        address: account,
+        balance: stRSRInfo.balance.toString(),
+        balanceHuman: Number(stRSRInfo.balance) / 1000000000000000000,
+        votingPower: stRSRInfo.votingPower.toString(),
+        votingPowerHuman: Number(stRSRInfo.votingPower) / 1000000000000000000,
+        delegatee: stRSRInfo.delegatee
+      } : null
+    });
+    return;
+  }
+  printHeader(`Yield DTF Staking — ${yieldConfig.symbol} (${chainLabel(config.chainId)})`);
+  console.log();
+  printTable([
+    { header: "Property", key: "prop" },
+    { header: "Value", key: "value" }
+  ], [
+    { prop: "StRSR Address", value: yieldConfig.components.stRSR },
+    { prop: "Exchange Rate", value: `${exchangeRate.toFixed(6)} RSR/stRSR` },
+    { prop: "Total Supply", value: `${(Number(stRSRInfo.totalSupply) / 1000000000000000000).toLocaleString("en-US", { maximumFractionDigits: 2 })} stRSR` },
+    { prop: "Unstaking Delay", value: formatDuration(Number(stRSRInfo.unstakingDelay)) }
+  ]);
+  if (account && stRSRInfo.balance !== undefined) {
+    console.log(`
+Account: ${account}`);
+    printTable([
+      { header: "Property", key: "prop" },
+      { header: "Value", key: "value", align: "right" }
+    ], [
+      { prop: "Balance", value: formatUnits2(stRSRInfo.balance, 18) },
+      { prop: "Voting Power", value: formatUnits2(stRSRInfo.votingPower, 18) },
+      { prop: "Delegatee", value: stRSRInfo.delegatee }
+    ]);
+  }
+}
 
 // src/commands/roles.ts
 async function rolesCommand(address, config) {
@@ -26297,6 +27239,11 @@ async function rolesCommand(address, config) {
     chainId: config.chainId,
     rpc: config.rpc
   });
+  const dtfType = await resolveDtfType(publicClient, address, config.dtfType);
+  if (dtfType === "yield") {
+    await yieldRoles(address, config);
+    return;
+  }
   const dtfConfig = await fetchDtfConfigCached(fetchDtfConfig, publicClient, config.chainId, address);
   if (config.json) {
     printJson({
@@ -26341,6 +27288,63 @@ async function rolesCommand(address, config) {
     { header: "Holder", key: "holder" }
   ], rows);
 }
+async function yieldRoles(address, config) {
+  const subgraphUrl = YIELD_SUBGRAPH_URLS[config.chainId];
+  if (!subgraphUrl) {
+    const msg = `Yield DTF roles not available for chain ${config.chainId} (no subgraph).`;
+    if (config.json) {
+      printJson({ dtf: address, type: "yield", chain: config.chainId, roles: null, message: msg });
+    } else {
+      console.log(msg);
+    }
+    return;
+  }
+  const query = `{
+    rtoken(id: "${address.toLowerCase()}") {
+      id
+      main {
+        owner
+        pauser
+        freezer
+      }
+    }
+  }`;
+  try {
+    const data = await querySubgraph(config.chainId, query, {}, subgraphUrl);
+    const main = data.rtoken?.main;
+    if (config.json) {
+      printJson({
+        dtf: address,
+        type: "yield",
+        chain: config.chainId,
+        chainLabel: chainLabel(config.chainId),
+        roles: main ? { owner: main.owner, pauser: main.pauser, freezer: main.freezer } : null
+      });
+      return;
+    }
+    printHeader(`Yield DTF Roles — ${formatAddress(address)} (${chainLabel(config.chainId)})`);
+    console.log();
+    if (main) {
+      printTable([
+        { header: "Role", key: "role" },
+        { header: "Holder", key: "holder" }
+      ], [
+        { role: "Owner", holder: main.owner },
+        { role: "Pauser", holder: main.pauser },
+        { role: "Freezer", holder: main.freezer }
+      ]);
+    } else {
+      console.log("No role data found for this yield DTF.");
+    }
+  } catch {
+    const msg = "Failed to fetch yield DTF roles from subgraph.";
+    if (config.json) {
+      printJson({ dtf: address, type: "yield", chain: config.chainId, roles: null, error: msg });
+    } else {
+      console.log(msg);
+    }
+  }
+}
 
 // src/commands/rebalance-history.ts
 function summarizeRebalance(detail) {
@@ -26571,19 +27575,6 @@ function computeReturn(performance) {
     return null;
   return Math.round((last.value - first.value) / first.value * 1e4) / 100;
 }
-var PERIOD_SECONDS = {
-  "30d": 30 * 24 * 60 * 60,
-  "3m": 90 * 24 * 60 * 60,
-  "6m": 180 * 24 * 60 * 60,
-  "1y": 365 * 24 * 60 * 60
-};
-function parsePeriodSeconds(period) {
-  const s = PERIOD_SECONDS[period];
-  if (!s) {
-    throw new Error(`Unknown period "${period}". Use: 30d, 3m, 6m, 1y`);
-  }
-  return s;
-}
 async function discoverCommand(config) {
   const isAll = config.allChains || !config.chainExplicit;
   const chains = isAll ? [...SUPPORTED_CHAINS] : [config.chainId];
@@ -27695,9 +28686,492 @@ function getFlag2(args, flag) {
   return args[idx + 1];
 }
 
+// src/commands/query.ts
+var INDEX_ONLY = new Set([
+  "dtf",
+  "dtfs",
+  "rebalance",
+  "rebalances",
+  "auction",
+  "auctions",
+  "auctionBid",
+  "auctionBids",
+  "rebalanceAuctionBid",
+  "rebalanceAuctionBids",
+  "stakingToken",
+  "stakingTokens",
+  "stakingTokenRewards",
+  "lock",
+  "locks",
+  "rsrBurn",
+  "rsrBurns",
+  "rsrBurnGlobal",
+  "rsrBurnDailySnapshot",
+  "rsrBurnDailySnapshots",
+  "rsrBurnMonthlySnapshot",
+  "rsrBurnMonthlySnapshots",
+  "minting",
+  "mintings",
+  "transferEvent",
+  "transferEvents",
+  "unstakingManager",
+  "version",
+  "versions",
+  "timelockOperation",
+  "timelockOperations",
+  "timelockOperationByTx"
+]);
+var YIELD_ONLY = new Set([
+  "rtoken",
+  "rtokens",
+  "protocol",
+  "protocols",
+  "accountRToken",
+  "accountRTokens",
+  "accountRTokenDailySnapshot",
+  "accountRTokenDailySnapshots",
+  "accountStakeRecord",
+  "accountStakeRecords",
+  "governanceFramework",
+  "governanceFrameworks",
+  "revenueDistribution",
+  "revenueDistributions",
+  "financialsDailySnapshot",
+  "financialsDailySnapshots",
+  "rtokenDailySnapshot",
+  "rtokenDailySnapshots",
+  "rtokenHourlySnapshot",
+  "rtokenHourlySnapshots",
+  "rtokenHistoricalBaskets",
+  "deployer",
+  "deployers",
+  "collateral",
+  "collaterals",
+  "stTokenDailySnapshot",
+  "stTokenDailySnapshots",
+  "rewardToken",
+  "rewardTokens",
+  "tokenHolder",
+  "tokenHolders",
+  "usageMetricsDailySnapshot",
+  "usageMetricsDailySnapshots",
+  "usageMetricsHourlySnapshot",
+  "usageMetricsHourlySnapshots",
+  "rtokenContract",
+  "rtokenContracts",
+  "entry",
+  "entries",
+  "activeAccount",
+  "activeAccounts"
+]);
+var SHARED = new Set([
+  "account",
+  "accounts",
+  "accountBalance",
+  "accountBalances",
+  "accountBalanceDailySnapshot",
+  "accountBalanceDailySnapshots",
+  "token",
+  "tokens",
+  "tokenDailySnapshot",
+  "tokenDailySnapshots",
+  "tokenHourlySnapshot",
+  "tokenHourlySnapshots",
+  "tokenMonthlySnapshot",
+  "tokenMonthlySnapshots",
+  "proposal",
+  "proposals",
+  "vote",
+  "votes",
+  "delegate",
+  "delegates",
+  "delegateChange",
+  "delegateChanges",
+  "delegateVotingPowerChange",
+  "delegateVotingPowerChanges",
+  "governance",
+  "governances",
+  "governanceTimelock",
+  "governanceTimelocks",
+  "trade",
+  "trades",
+  "voteDailySnapshot",
+  "voteDailySnapshots"
+]);
+function extractRootEntities(query) {
+  const firstBrace = query.indexOf("{");
+  if (firstBrace === -1)
+    return [];
+  const bodyStart = firstBrace + 1;
+  const body = query.slice(bodyStart);
+  const entities = [];
+  let braceDepth = 0;
+  let parenDepth = 0;
+  const tokenRegex = /(\w+)|([{}()])/g;
+  let match;
+  while ((match = tokenRegex.exec(body)) !== null) {
+    if (match[2] === "{")
+      braceDepth++;
+    else if (match[2] === "}")
+      braceDepth--;
+    else if (match[2] === "(")
+      parenDepth++;
+    else if (match[2] === ")")
+      parenDepth--;
+    else if (match[1] && braceDepth === 0 && parenDepth === 0) {
+      entities.push(match[1]);
+    }
+  }
+  return entities;
+}
+function detectSubgraph(query) {
+  const entities = extractRootEntities(query);
+  let hasIndex = false;
+  let hasYield = false;
+  let hasShared = false;
+  let hasUnknown = false;
+  for (const entity of entities) {
+    if (INDEX_ONLY.has(entity))
+      hasIndex = true;
+    else if (YIELD_ONLY.has(entity))
+      hasYield = true;
+    else if (SHARED.has(entity))
+      hasShared = true;
+    else
+      hasUnknown = true;
+  }
+  if (hasIndex && hasYield) {
+    throw new Error("Query contains both index-only and yield-only entities. Use --subgraph to specify which subgraph to query.");
+  }
+  if (hasYield)
+    return { subgraph: "yield" };
+  if (hasIndex)
+    return { subgraph: "index" };
+  return {
+    subgraph: "index",
+    note: "Auto-detected as index subgraph. Use --subgraph yield to query the yield subgraph instead."
+  };
+}
+var YIELD_CHAINS = Object.keys(YIELD_SUBGRAPH_URLS).map(Number);
+async function queryCommand(config, rest) {
+  const query = rest[0];
+  if (!query) {
+    throw new Error("Usage: dtf query '<graphql>' [--subgraph index|yield] [--chain <id|all>]");
+  }
+  let subgraph;
+  let note;
+  if (config.subgraph) {
+    subgraph = config.subgraph;
+  } else {
+    const detected = detectSubgraph(query);
+    subgraph = detected.subgraph;
+    note = detected.note;
+  }
+  const getUrl2 = (chainId) => {
+    if (subgraph === "yield") {
+      const url = YIELD_SUBGRAPH_URLS[chainId];
+      if (!url)
+        throw new Error(`No yield subgraph for chain ${chainId}. Yield DTFs are only on Ethereum (1) and Base (8453).`);
+      return url;
+    }
+    return SUBGRAPH_URLS[chainId];
+  };
+  if (config.allChains) {
+    const chains = subgraph === "yield" ? YIELD_CHAINS : SUPPORTED_CHAINS;
+    const results = await Promise.allSettled(chains.map(async (chainId) => {
+      const url = getUrl2(chainId);
+      const data = await querySubgraph(chainId, query, {}, url);
+      return { chain: chainId, chainLabel: chainLabel(chainId), data };
+    }));
+    const output = results.map((r, i) => {
+      if (r.status === "fulfilled")
+        return r.value;
+      return { chain: chains[i], chainLabel: chainLabel(chains[i]), error: String(r.reason) };
+    });
+    printJson({ subgraph, ...note ? { note } : {}, results: output });
+  } else {
+    const url = getUrl2(config.chainId);
+    const data = await querySubgraph(config.chainId, query, {}, url);
+    printJson({ subgraph, chain: config.chainId, chainLabel: chainLabel(config.chainId), ...note ? { note } : {}, data });
+  }
+}
+
+// src/commands/holders.ts
+async function holdersCommand(address, config) {
+  const { publicClient } = createDtfClients({ chainId: config.chainId, rpc: config.rpc });
+  const dtfType = await resolveDtfType(publicClient, address, config.dtfType);
+  const limit = config.limit ?? 20;
+  const addrLower = address.toLowerCase();
+  if (dtfType === "yield") {
+    await yieldHolders(addrLower, config, limit);
+  } else {
+    await indexHolders(addrLower, config, limit);
+  }
+}
+async function indexHolders(address, config, limit) {
+  const query = `{
+    token(id: "${address}") { currentHolderCount decimals }
+    accountBalances(
+      where: { token: "${address}", amount_gt: "0" }
+      orderBy: amount, orderDirection: desc
+      first: ${limit}
+    ) {
+      account { id }
+      amount
+      delegate { address }
+    }
+  }`;
+  const chainId = config.chainId;
+  const url = SUBGRAPH_URLS[chainId];
+  const [data, prices] = await Promise.all([
+    querySubgraph(chainId, query, {}, url),
+    fetchTokenPrices(chainId, [address]).catch(() => ({}))
+  ]);
+  const decimals = data.token?.decimals ?? 18;
+  const totalHolders = data.token?.currentHolderCount ?? 0;
+  const tokenPrice = prices[address] ?? 0;
+  const holders = data.accountBalances.map((h, i) => {
+    const balance = Number(h.amount) / 10 ** decimals;
+    return {
+      account: h.account.id,
+      balance: h.amount,
+      balanceHuman: balance,
+      balanceUsd: balance * tokenPrice,
+      delegate: h.delegate?.address,
+      rank: i + 1
+    };
+  });
+  if (config.json) {
+    printJson({
+      dtf: address,
+      chain: config.chainId,
+      chainLabel: chainLabel(config.chainId),
+      type: "index",
+      tokenPrice,
+      holders,
+      totalHolders
+    });
+    return;
+  }
+  printHeader(`Top Holders — ${formatAddress(address)} (${chainLabel(config.chainId)})`);
+  console.log(`Total holders: ${totalHolders}`);
+  if (tokenPrice > 0)
+    console.log(`Token price: ${formatUsd(tokenPrice)}`);
+  console.log();
+  printTable([
+    { header: "#", key: "rank", align: "right" },
+    { header: "Account", key: "account" },
+    { header: "Balance", key: "balance", align: "right" },
+    ...tokenPrice > 0 ? [{ header: "USD", key: "usd", align: "right" }] : []
+  ], holders.map((h) => ({
+    rank: String(h.rank),
+    account: formatAddress(h.account),
+    balance: h.balanceHuman.toLocaleString("en-US", { maximumFractionDigits: 2 }),
+    usd: formatUsd(h.balanceUsd)
+  })));
+}
+async function yieldHolders(address, config, limit) {
+  const query = `{
+    token(id: "${address}") { holderCount decimals lastPriceUSD }
+    accountBalances(
+      where: { token: "${address}", amount_gt: "0" }
+      orderBy: amount, orderDirection: desc
+      first: ${limit}
+    ) {
+      account { id }
+      amount
+    }
+  }`;
+  const chainId = config.chainId;
+  const url = YIELD_SUBGRAPH_URLS[chainId];
+  if (!url)
+    throw new Error(`No yield subgraph for chain ${chainId}`);
+  const data = await querySubgraph(chainId, query, {}, url);
+  const decimals = data.token?.decimals ?? 18;
+  const totalHolders = data.token?.holderCount ?? 0;
+  const tokenPrice = Number(data.token?.lastPriceUSD ?? "0");
+  const holders = data.accountBalances.map((h, i) => {
+    const balance = Number(h.amount) / 10 ** decimals;
+    return {
+      account: h.account.id,
+      balance: h.amount,
+      balanceHuman: balance,
+      balanceUsd: balance * tokenPrice,
+      rank: i + 1
+    };
+  });
+  if (config.json) {
+    printJson({
+      dtf: address,
+      chain: config.chainId,
+      chainLabel: chainLabel(config.chainId),
+      type: "yield",
+      tokenPrice,
+      holders,
+      totalHolders
+    });
+    return;
+  }
+  printHeader(`Top Holders — ${formatAddress(address)} (${chainLabel(config.chainId)})`);
+  console.log(`Total holders: ${totalHolders}`);
+  if (tokenPrice > 0)
+    console.log(`Token price: ${formatUsd(tokenPrice)}`);
+  console.log();
+  printTable([
+    { header: "#", key: "rank", align: "right" },
+    { header: "Account", key: "account" },
+    { header: "Balance", key: "balance", align: "right" },
+    ...tokenPrice > 0 ? [{ header: "USD", key: "usd", align: "right" }] : []
+  ], holders.map((h) => ({
+    rank: String(h.rank),
+    account: formatAddress(h.account),
+    balance: h.balanceHuman.toLocaleString("en-US", { maximumFractionDigits: 2 }),
+    usd: formatUsd(h.balanceUsd)
+  })));
+}
+
+// src/commands/delegates.ts
+async function delegatesCommand(address, config) {
+  const { publicClient } = createDtfClients({ chainId: config.chainId, rpc: config.rpc });
+  const dtfType = await resolveDtfType(publicClient, address, config.dtfType);
+  const limit = config.limit ?? 20;
+  const addrLower = address.toLowerCase();
+  if (dtfType === "yield") {
+    await yieldDelegates(addrLower, config, limit);
+  } else {
+    await indexDelegates(publicClient, addrLower, config, limit);
+  }
+}
+async function indexDelegates(publicClient, address, config, limit) {
+  const dtfConfig = await fetchDtfConfigCached(fetchDtfConfig, publicClient, config.chainId, address);
+  const stTokenAddress = dtfConfig.stTokenAddress?.toLowerCase();
+  if (!stTokenAddress) {
+    throw new Error(`No stToken found for DTF ${address}. This DTF may not have governance.`);
+  }
+  const query = `{
+    stakingToken(id: "${stTokenAddress}") {
+      currentDelegates totalDelegates delegatedVotesRaw
+      delegates(
+        first: ${limit}
+        orderBy: delegatedVotesRaw
+        orderDirection: desc
+      ) {
+        address
+        delegatedVotesRaw
+        tokenHoldersRepresentedAmount
+        numberVotes
+      }
+    }
+  }`;
+  const chainId = config.chainId;
+  const url = SUBGRAPH_URLS[chainId];
+  const data = await querySubgraph(chainId, query, {}, url);
+  if (!data.stakingToken) {
+    throw new Error(`StakingToken ${stTokenAddress} not found in subgraph`);
+  }
+  const delegates = data.stakingToken.delegates.map((d, i) => ({
+    address: d.address,
+    delegatedVotes: d.delegatedVotesRaw,
+    delegatedVotesHuman: Number(d.delegatedVotesRaw) / 1000000000000000000,
+    representedHolders: d.tokenHoldersRepresentedAmount,
+    votesCast: d.numberVotes,
+    rank: i + 1
+  }));
+  if (config.json) {
+    printJson({
+      dtf: address,
+      chain: config.chainId,
+      chainLabel: chainLabel(config.chainId),
+      type: "index",
+      governanceToken: stTokenAddress,
+      delegates,
+      totalDelegates: data.stakingToken.currentDelegates
+    });
+    return;
+  }
+  printHeader(`Delegates — ${formatAddress(address)} (${chainLabel(config.chainId)})`);
+  console.log(`Active delegates: ${data.stakingToken.currentDelegates} (${data.stakingToken.totalDelegates} total)`);
+  console.log();
+  printTable([
+    { header: "#", key: "rank", align: "right" },
+    { header: "Delegate", key: "delegate" },
+    { header: "Votes", key: "votes", align: "right" },
+    { header: "Holders", key: "holders", align: "right" },
+    { header: "Cast", key: "cast", align: "right" }
+  ], delegates.map((d) => ({
+    rank: String(d.rank),
+    delegate: formatAddress(d.address),
+    votes: d.delegatedVotesHuman.toLocaleString("en-US", { maximumFractionDigits: 0 }),
+    holders: String(d.representedHolders),
+    cast: String(d.votesCast)
+  })));
+}
+async function yieldDelegates(address, config, limit) {
+  const addrLower = address.toLowerCase();
+  const query = `{
+    governance(id: "${addrLower}") {
+      currentDelegates totalDelegates delegatedVotesRaw
+    }
+    delegates(
+      where: { governance: "${addrLower}" }
+      first: ${limit}
+      orderBy: delegatedVotesRaw
+      orderDirection: desc
+    ) {
+      address
+      delegatedVotesRaw
+      tokenHoldersRepresentedAmount
+      numberVotes
+    }
+  }`;
+  const chainId = config.chainId;
+  const url = YIELD_SUBGRAPH_URLS[chainId];
+  if (!url)
+    throw new Error(`No yield subgraph for chain ${chainId}`);
+  const data = await querySubgraph(chainId, query, {}, url);
+  const delegates = data.delegates.map((d, i) => ({
+    address: d.address,
+    delegatedVotes: d.delegatedVotesRaw,
+    delegatedVotesHuman: Number(d.delegatedVotesRaw) / 1000000000000000000,
+    representedHolders: d.tokenHoldersRepresentedAmount,
+    votesCast: d.numberVotes,
+    rank: i + 1
+  }));
+  if (config.json) {
+    printJson({
+      dtf: address,
+      chain: config.chainId,
+      chainLabel: chainLabel(config.chainId),
+      type: "yield",
+      governanceToken: addrLower,
+      delegates,
+      totalDelegates: data.governance?.currentDelegates ?? 0
+    });
+    return;
+  }
+  printHeader(`Delegates — ${formatAddress(address)} (${chainLabel(config.chainId)})`);
+  if (data.governance) {
+    console.log(`Active delegates: ${data.governance.currentDelegates} (${data.governance.totalDelegates} total)`);
+  }
+  console.log();
+  printTable([
+    { header: "#", key: "rank", align: "right" },
+    { header: "Delegate", key: "delegate" },
+    { header: "Votes", key: "votes", align: "right" },
+    { header: "Holders", key: "holders", align: "right" },
+    { header: "Cast", key: "cast", align: "right" }
+  ], delegates.map((d) => ({
+    rank: String(d.rank),
+    delegate: formatAddress(d.address),
+    votes: d.delegatedVotesHuman.toLocaleString("en-US", { maximumFractionDigits: 0 }),
+    holders: String(d.representedHolders),
+    cast: String(d.votesCast)
+  })));
+}
+
 // src/index.ts
 var HELP = `
-dtf — Reserve Protocol Index DTF CLI
+dtf — Reserve Protocol DTF CLI (Index + Yield)
 
 Usage:
   dtf <command> <address|symbol> [options]
@@ -27719,6 +29193,9 @@ Commands:
   earn                            Vote-lock yield opportunities
   revenue <address> | --all       Revenue breakdown (single DTF or ecosystem)
   rsr-burns                       RSR burn analytics + projections
+  holders <address>               Top token holders with balances
+  delegates <address>             Governance delegation graph
+  query '<graphql>'               Raw subgraph query (auto-detects index vs yield)
   deploy                          Deploy a new DTF (--help for options)
   forum                           Reserve governance forum (monthly top, search, topic detail)
   cache-clear                     Clear local disk cache (~/.dtf/cache)
@@ -27734,6 +29211,7 @@ Command Options:
   --account <address>             Account address for staking command
   --nonce <n>                     Rebalance nonce for history detail
   --performance <period>          Return over period (30d, 3m, 6m, 1y) for discover
+  --subgraph <index|yield>        Subgraph to query (auto-detected from entity names)
 
 Address:
   Use a 0x address or a known DTF symbol (case-insensitive).
@@ -27747,7 +29225,7 @@ Examples:
   dtf discover                    All chains by default
   dtf discover --chain 8453       Single chain
 `;
-var NO_ADDRESS_COMMANDS = new Set(["discover", "earn", "cache-clear", "proposals", "rsr-burns", "revenue", "forum", "deploy"]);
+var NO_ADDRESS_COMMANDS = new Set(["discover", "earn", "cache-clear", "proposals", "rsr-burns", "revenue", "forum", "deploy", "query"]);
 async function main() {
   const args = process.argv.slice(2);
   if (args.length === 0 || args[0] === "help" || args.includes("--help") && !args[0]?.match(/^[a-z]/)) {
@@ -27783,6 +29261,9 @@ async function main() {
       if (!config.chainExplicit) {
         config.chainId = resolved.chainId;
       }
+      config.dtfType = resolved.type;
+    } else {
+      config.dtfType = getRegistryType(address);
     }
   }
   try {
@@ -27821,6 +29302,12 @@ async function main() {
       case "rebalance-history":
         await rebalanceHistoryCommand(resolvedAddress, config, rest);
         break;
+      case "holders":
+        await holdersCommand(resolvedAddress, config);
+        break;
+      case "delegates":
+        await delegatesCommand(resolvedAddress, config);
+        break;
       case "discover":
         await discoverCommand(config);
         break;
@@ -27840,6 +29327,9 @@ async function main() {
       case "deploy":
         await deployCommand(config, args.slice(1));
         break;
+      case "query":
+        await queryCommand(config, address ? [address, ...rest] : rest);
+        break;
       case "forum":
         await forumCommand(config, address ? [address, ...rest] : rest);
         break;