[RFC] A User-centric DeFi Collateral Transparency Framework - Phase 1

v0.5 — June 2026

Abstract

The Problem: Four illusions at the heart of onchain lending

Morpho’s isolated market architecture is a genuine advance: each market is a standalone unit, and a default in one market does not mechanically drain another. But this architectural compartmentalisation has created a false sense of independence among lenders and borrowers alike. The DeFi Integration Graph (DIG) and Yield Tree Decomposition (YTD), two tools we are building and are running on live blockchain states reveal a quadruple root of confusion that persists across lending platforms:

1. The collateral independence: markets that appear isolated share hidden dependencies through their collateral assets. A vault may lend on market M₁: siUSD/USDC, where the collateral siUSD, a staked form of vault token contains wsrUSD (itself another staked form of vault token from Reservoir) in its yield tree decomposition. A depeg of wsrUSD propagates upward through the YTD and depegs siUSD; the default probability of M₁ therefore depends on the default probability of a market it has no direct contractual link to. Isolated markets are not independent markets when their collateral assets share recursive roots.

2. The TVL: headline TVL figures count the same capital multiple times as it flows through layers of wrapping, vaulting, and re-depositing. A single dollar of USDC deposited into a vault, lent against collateral that is itself a vault token backed by the same USDC, inflates reported TVL at every layer. The aggregate number suggests depth and diversification that do not exist. The DIG traces capital through these recursive loops and reports the actual terminal exposure at each leaf.

3. The diversification: a vault allocating across five Morpho markets appears diversified. But if 85% of the underlying collateral across those markets resolves to two BTC custodians (e.g., Coinbase and BitGo) through the YTD, the vault holds a concentrated BTC custody bet dressed up as a multi-market strategy. Diversification measured at the market level can vanish entirely when measured at the terminal asset level.

4. The (non-)leverage: a passive depositor in a vault may believe their exposure is unleveraged. But if another user loops through the same vault, depositing the vault token as collateral to borrow the underlying, redepositing, and repeating, the passive depositor’s capital is silently leveraged by the looper’s activity. The increased risk is not visible at the investment surface. These dark loops are detectable from onchain state but are not surfaced by any existing interface.

These four illusions are not edge cases. They are structural features of composable DeFi that affect the majority of Morpho vaults by TVL today. Our tooling exists to make them visible.

What we are building today

Sigma Labs has started to build and validate two operational tools currently running on live onchain data.

The Dependency Graph Engine (DIG) monitors 7+ protocol integrations and maps the full onchain relationship graph of any EVM asset, including wrappers, LP positions, Pendle PT/YT structures, lending markets, and pledge relationships, producing structured JSON output and visual dependency trees. Live outputs cover assets with 500+ nodes in their dependency graph.

The Yield Tree Decomposition (YTD) translates the dependency graph into a recursive breakdown of yield sources, collateral allocation, LLTV exposure, and concentration risk at every layer of a composed asset.

The reUSD graph and the wsrUSD decomposition in First results below are direct outputs of these tools running on live blockchain state, not illustrations or mock-ups.

First results

Dependency Graph: reUSD

The graph below illustrates the recursive dependency unwrapping engine applied to reUSD (Re Protocol), tracing every wrapper, LP position, Pendle market, and Morpho lending market from the top-level asset down to individual collateral markets.

Yield Tree Decomposition: wsrUSD (Reservoir)

Wrapped Savings rUSD (wsrUSD) [4626] | rate: 1.074463
└── rUSD [Reservoir]
    ├── steakUSDC (Morpho) [V1] — $20M
    │   ├── cbBTC/USDC (86% LLTV) — $109,717,726.65 (52.8%) @ 1.89% APY
    │   │   ├── [collateral] cbBTC
    │   │   └── [borrow] USDC
    │   ├── WBTC/USDC (86% LLTV) — $68,514,103.88 (33.0%) @ 1.89% APY
    │   │   ├── [collateral] WBTC
    │   │   └── [borrow] USDC
    │   ├── wstETH/USDC (86% LLTV) — $29,464,000.85 (14.2%) @ 1.89% APY
    │   │   ├── [collateral] wstETH [4626] (rate: 1.231065)
    │   │   │   └── stETH [4626] (rate: 1.0)
    │   │   │       └── ETH
    │   │   └── [borrow] USDC
    │   ├── WETH/USDC (86% LLTV) — $39,277.73 (0.0%) @ 1.89% APY
    │   │   ├── [collateral] WETH
    │   │   └── [borrow] USDC
    │   └── IDLE/USDC (0% LLTV) — $0.00 (0.0%) @ 0.00% APY
    │       ├── [collateral] IDLE [IDLE]
    │       └── [borrow] USDC
    ├── [PSM] PSM-USDC — $500K
    ├── steakRUSD — $53K
    ├── Steakhouse High Yield — $6
    └── smokeUSDT [V1] — $2
        ├── wsrUSD/USDT (94% LLTV) — $39,551,744.73 (99.6%) @ 3.37% APY
        │   ├── [collateral] wsrUSD
        │   └── [borrow] USDT
        ├── sUSDe/USDT (92% LLTV) — $43,943.56 (0.1%) @ 3.51% APY
        │   ├── [collateral] sUSDe [4626] (rate: 1.226156)
        │   │   └── USDe
        │   └── [borrow] USDT
        ├── PT-cUSD-23JUL2026/USDT (92% LLTV) — $82,057.94 (0.2%) @ 3.36% APY
        │   ├── [collateral] PT-cUSD-23JUL2026 [PT]
        │   │   └── SY-cUSD [SY] (rate: 1.0)
        │   │       └── cUSD
        │   └── [borrow] USDT
        ├── weETH/USDT (86% LLTV) — $15,079.95 (0.0%) @ 3.36% APY
        │   ├── [collateral] weETH [4626] (rate: 1.09191)
        │   │   └── eETH [4626] (rate: 1.0)
        │   │       └── ETH
        │   └── [borrow] USDT
        ├── sUSDS/USDT (96% LLTV) — $0.00 (0.0%) @ 2.99% APY
        │   ├── [collateral] sUSDS [Sky] (rate: 1.092186)
        │   │   ├── [Lending] Spark — $3.60B (return: 4.53%)
        │   │   │   ├── DAI — $273M @ 2.68% APY
        │   │   │   ├── USDT — $261M @ 1.99% APY
        │   │   │   ├── USDS — $144M @ 2.55% APY
        │   │   │   ├── PYUSD — $100M @ 0.72% APY
        │   │   │   ├── USDC — $18M @ 4.14% APY
        │   │   │   ├── sUSDS — $3M
        │   │   │   ├── wstETH — $468K
        │   │   │   ├── WETH — $264K @ 1.64% APY
        │   │   │   ├── sDAI — $38K
        │   │   │   ├── weETH — $31K
        │   │   │   ├── ezETH — $14K
        │   │   │   ├── rETH — $11K
        │   │   │   ├── rsETH — $4K
        │   │   │   ├── LBTC — $3K
        │   │   │   ├── cbBTC — $396 @ 0.03% APY
        │   │   │   ├── WBTC — $362 @ 0.00% APY
        │   │   │   └── tBTC — $23
        │   │   ├── [RWA] Bloom/Grove — $2.94B
        │   │   ├── [RWA] Obex — $606M
        │   │   └── [underlying] USDS [Sky] (price: 1.464347)
        │   │       ├── [PSM] Lite-PSM USDC — $4.85B
        │   │       ├── Allocator: Spark — $3.60B
        │   │       ├── Allocator: Bloom/Grove — $2.94B
        │   │       ├── Allocator: Obex — $606M
        │   │       ├── [CDP] ETH-C (ETH) — $317M
        │   │       ├── [CDP] ETH-A (ETH) — $164M
        │   │       ├── [CDP] RWA002-A (RWA) — $34M
        │   │       ├── [CDP] WSTETH-A (wstETH) — $20M
        │   │       ├── [CDP] WSTETH-B (wstETH) — $13M
        │   │       ├── [CDP] ETH-B (ETH) — $8M
        │   │       ├── [CDP] WBTC-C (WBTC) — $1M
        │   │       ├── [CDP] WBTC-A (WBTC) — $847K
        │   │       └── [CDP] WBTC-B (WBTC) — $186K
        │   └── [borrow] USDT
        ├── wstETH/USDT (86% LLTV) — $0.00 (0.0%) @ 3.00% APY
        │   ├── [collateral] wstETH [4626] (rate: 1.231065)
        │   │   └── stETH [4626] (rate: 1.0)
        │   │       └── ETH
        │   └── [borrow] USDT
        ├── WBTC/USDT (86% LLTV) — $0.00 (0.0%) @ 2.98% APY
        │   ├── [collateral] WBTC
        │   └── [borrow] USDT
        ├── cbBTC/USDT (86% LLTV) — $0.00 (0.0%) @ 2.20% APY
        │   ├── [collateral] cbBTC
        │   └── [borrow] USDT
        ├── syrupUSDT/USDT (92% LLTV) — $0.00 (0.0%) @ 1.66% APY
        │   ├── [collateral] syrupUSDT [4626] (rate: 1.122055)
        │   │   └── USDT
        │   └── [borrow] USDT
        ├── syrupUSDC/USDT (92% LLTV) — $0.00 (0.0%) @ 4.29% APY
        │   ├── [collateral] syrupUSDC [4626] (rate: 1.158423)
        │   │   └── USDC
        │   └── [borrow] USDT
        ├── PT-srUSDe-2APR2026/USDT (92% LLTV) — $231.48 (0.0%) @ 3.36% APY
        │   ├── [collateral] PT-srUSDe-2APR2026 [PT]
        │   │   └── SY-srUSDe [SY] (rate: 1.017289)
        │   │       └── srUSDe [4626]
        │   │           └── USDe
        │   └── [borrow] USDT
        ├── stcUSD/USDT (92% LLTV) — $0.11 (0.0%) @ 3.37% APY
        │   ├── [collateral] stcUSD [4626] (rate: 1.055424)
        │   │   └── cUSD
        │   └── [borrow] USDT
        ├── PT-stcUSD-23JUL2026/USDT (92% LLTV) — $0.11 (0.0%) @ 3.37% APY
        │   ├── [collateral] PT-stcUSD-23JUL2026 [PT]
        │   │   └── SY-stcUSD [SY] (rate: 1.055424)
        │   │       └── stcUSD [4626]
        │   │           └── cUSD
        │   └── [borrow] USDT
        ├── PT-srUSDe-25JUN2026/USDT (92% LLTV) — $0.06 (0.0%) @ 3.38% APY
        │   ├── [collateral] PT-srUSDe-25JUN2026 [PT]
        │   │   └── SY-srUSDe [SY] (rate: 1.017289)
        │   │       └── srUSDe [4626]
        │   │           └── USDe
        │   └── [borrow] USDT
        ├── PT-USDG-28MAY2026/USDT (94% LLTV) — $0.00 (0.0%) @ 2.94% APY
        │   ├── [collateral] PT-USDG-28MAY2026 [PT]
        │   │   └── SY-USDG [SY] (rate: 1.0)
        │   │       └── USDG
        │   └── [borrow] USDT
        └── IDLE/USDT (0% LLTV) — $0.00 (0.0%) @ 0.00% APY
            ├── [collateral] IDLE [IDLE]
            └── [borrow] USDT

wsrUSD is 96%+ a wrapper around steakUSDC, itself a Morpho vault with 85.8% BTC concentration at 86% LLTV, 4–5 layers of recursive smart contract risk, a circular reflexivity loop via smokeUSDT, and a base APY of ~1.89% inadequate for this structural complexity.

The Morpho curationship model and its structural consequences

Morpho has redefined lending protocol design by separating infrastructure from risk management. Anyone can spin up an ERC-4626 vault, define collateral exposure, set supply caps, choose oracles, and offer curated lending strategies to depositors. The protocol provides the rails; the curator provides the judgment.

The model’s appeal is real. But its rapid expansion has exposed a structural gap: the rigor of collateral risk assessment varies enormously across curators, and depositors have consistently lacked the tools to evaluate it. The avent of Morpho Midnight makes this even more urgent. Permissionless vault creation will accelerate curator proliferation faster than any informal assessment process can track. A shared transparency framework becomes a prerequisite.

This gap is not a matter of opinion. Independent research published in April 2026 by Luca Prosperi (Physics of On-Chain Lending) documented 20–100x mispricing of collateral risk across major DeFi lending markets. Risk analytics firm Chaos Labs, in its post-mortem of the Resolv/USR exploit, documented the same structural failure: hardcoded oracles, unchecked minting roles, and leverage loops that were all readable from public blockchain state before any damage occurred. The problem is architectural, not incidental, and it recurs because no shared framework exists to read the onchain signals systematically.

A growing pattern of confidence failures

Two recent episodes made curator collateral risk impossible to ignore:

  • November 2025, Stream Finance / xUSD: Curators routed USDC deposits into recursive leverage loops backed by the synthetic stablecoin xUSD, leaving an estimated $285M–$700M at risk across multiple lending protocols when its oracle refused to update.
  • March 2026, Resolv / USR Exploit: An attacker exploited a flaw in Resolv’s USR minting contract, creating approximately 80 million unbacked tokens from roughly $200,000 in USDC. The oracle was hardcoded and never repriced: wstUSR was marked at $1.13 while trading at $0.63 on secondary markets. Fifteen Morpho vaults were impacted. Chaos Labs founder Omer Goldberg documented the mechanism in real time.

In both case, our tooling is designed to detect recursive leverage loop structures and oracle staleness.

Motivation

These incidents share a common thread: they were visible. Early warning signals were present onchain, in oracle configurations, minting mechanics, governance structures, liquidity depth, and backing ratios. What was missing was a systematic disclosure framework to read those signals and make them visible to curators and depositors before contagion.

This RFC proposes to build that framework: a modular, open-source disclosure infrastructure for Morpho collateral assets, delivered as a public good and community-verified. Its goals are concrete:

  • Continuity: disclosures update from live onchain data, not from periodic manual reviews.
  • Comparability: structural features are labelled consistently across asset types using categorical badges, not aggregate grades.
  • Auditability: every output is traceable to a specific onchain read and a documented methodology.
  • Reproducibility: any third party can verify any disclosure from the same blockchain state.

Prior Art: Credora by RedStone

Credora (acquired by RedStone in September 2025) introduced consensus-based risk ratings on Morpho in March 2025 and deserves credit for establishing that collateral risk transparency belongs in the protocol interface. Our work operates at a different layer: rather than producing periodic, curator-opt-in ratings, we produce a continuous, fully onchain-derivable disclosure infrastructure that updates from live blockchain state and is available for any asset, any vault, without opt-in. The two approaches are complementary; ours does not replace Credora’s ratings but fills structural gaps that point-in-time ratings cannot address by design.

What this grant delivers

This grant covers the top whitelisted Morpho vaults by TVL (snapshot taken at Month 1), including all major collateral types: wrapped BTC variants (cbBTC, WBTC), LSTs (wstETH, weETH, rsETH), synthetic stablecoins (USDe, sUSDe, USD0), and RWA. Each vault entry includes a dependency graph, a full recursive yield tree, categorical badges, a nutrition label, and an alert configuration. All recursive dependencies representing ≥5% of any covered vault’s backing are traced to their terminal assets.

We are not building a risk authority. We are not producing safe/unsafe verdicts, aggregate grades, or composite risk scores. We are building a disclosure layer: structured, reproducible, cadenced, machine-readable facts about what a collateral asset actually is, what it depends on, and how those dependencies change over time.

The data intelligence layer

We are building a data intelligence layer for Morpho collateral assets, infrastructure that continuously reads, decomposes, and discloses the structural reality of onchain collateral. It has four concrete outputs:

1. The collateral registry: a public registry covering every collateral asset in the top whitelisted Morpho vaults (by TVL, snapshot at Month 1), plus all recursive dependencies representing ≥5% of any covered vault’s backing. Each registry entry contains a full DIG dependency graph, a recursive YTD yield tree, terminal asset exposure, and categorical badges for structural features (circularity, single-EOA roles, hardcoded oracles, leverage loops, concentrated custody).

2. The diff stream: a continuous onchain monitoring feed that tracks mutations to registered assets: oracle configuration changes, governance role transfers, timelock modifications, supply velocity anomalies, new leverage loop formation, and liquidity deterioration. The diff stream turns static decompositions into a live surveillance layer. Alerts fire on specific structural events, not on aggregate score thresholds.

3. The labels: a standardised summary for each covered vault that answers: what does this collateral actually depend on? How deep is the wrapping? Where is the concentration? What governance controls exist? What oracle architecture is in use? labels use categorical badges only (e.g., “4+ recursive layers”, “85%+ single-asset concentration”, “no timelock on admin role”), no aggregate grade, no safe/unsafe language.

4. The Manifest template: an open-source template that any Morpho curator can adopt to produce standardised structural disclosures for their own vaults, regardless of whether Sigma Labs covers them. The manifest template is designed to be self-serve: a curator fills in the structural fields, and the template generates a nutrition label. The goal is to make disclosure the default, not the exception.

Delivery Schedule

All deliverables are public, free, and community-verifiable from day one.

Deliverable Target
Yield Tree Decomposition live on whitelisted Morpho Vaults Months 1 & 2
DeFi Integration Graph live on whitelisted Morpho Vaults Months 3 & 4
Oracle staleness, governance mutation, leverage-loop alert system, and exhaustive evidence detection (diff stream) Months 4 & 5
Dashboard v1 (draft available): per-vault dependency graphs, yield trees, nutrition labels Month 5 & 6
Manifest template published for curator self-serve disclosure Month 6

Proposed Budget

Total Grant Request: $110,000 in $MORPHO tokens

All amounts denominated in USD equivalent, paid in $MORPHO tokens at the 7-day TWAP price on the disbursement date.

Category Description Amount
Infrastructure & Data RPC nodes, archive access, cryo data pipeline, WebSocket monitoring, API $25,000
DIG / YTD Engineering Protocol watchers on major DeFi venues (top 15) and standards, dependency graph engine, yield tree engine $45,000
Dashboard & Alerts Dashboard v1, nutrition labels, oracle/governance/leverage-loop alert system, integrable telegram alerting system pipeline $20,000
Operations & Legal Entity costs, legal review, open-source licensing $15,000
Contingency $5,000
Total $110,000

Team: Sigma Labs

Sigma Labs is a French quantitative research team, combining academic backgrounds from École Polytechnique, École Normale Supérieure (ENS), Université Paris Dauphine–PSL and ESILV with hands-on experience co-founding and operating DeFi protocols. The live DIG/YTD outputs in this RFC are our primary proof of work.

Vincent Danos: École Polytechnique alumnus, co-founder of DeFi protocols and Research Director at CNRS.

Amaury Denny: Paris Dauphine–PSL, Quantitative Finance & Technology; 42 School Paris. Former VC research at KuCoin Labs, co-founder of a crypto family office with $20M+ AuM.

Hamza E.: ENS alumnus, PhD in Financial Markets, co-founder of DeFi protocols and quant prop shops.

Daniel J.: ESILV alumnus, co-founder of a liquid fund, treasury manager and investor.

Sustainability and exit clause

This framework is designed to outlast its initial grant. All code, models, and outputs will be fully open-sourced under the MIT License upon delivery, with the GitHub repository public and forkable by any community member, curator, or independent researcher from Month 1 onward.

If milestones are not delivered by Month 6, the community retains full ownership of all outputs produced to date. If Sigma Labs ceases operations or is unable to continue at any point during the project, all data pipelines, specifications, and documentation will be transferred to a community-designated maintainer. No single entity, including Sigma Labs, should be a point of failure for disclosure infrastructure that the Morpho ecosystem depends on.

What Comes Next

This RFC covers a nine-month disclosure infrastructure build and one year maintenance. We have further plans: a quantitative risk translation layer that takes the structural decompositions produced here and translates them into calibrated, cross-asset comparable risk signals, factor scores, effective volatility estimates, and contextual default probabilities conditioned on specific Morpho market structures. The mathematical foundation for this layer is documented in our DeFi Collateral Asset Risk Model — Mathematical Reference v3.0. Whether and when to propose this as a follow-on grant will depend on the evidence produced by this Phase 1 delivery, and will be submitted as a separate RFC for community evaluation on its own merits.

Next steps

The feedback window is three weeks from the date of this post. We welcome input from curators, depositors, risk researchers, and the broader Morpho community on scope, milestone structure, and budget before the vote is called.

To engage: comment directly on this thread or reach out at research@sigmalabs.fi. Once rough consensus is reached, this proposal will be submitted for onchain vote.

Considerations

All code will be fully open-sourced upon delivery under the MIT License. The GitHub repository will be public and accessible to the entire community, including dependency graph engines, yield tree decomposition scripts, alert pipelines, dashboard code, and manifest templates. Every output will be traceable to a specific onchain read and a documented methodology. Community members, independent researchers, and third-party auditors are explicitly encouraged to verify, challenge, and build on top of the framework.

This RFC is accompanied by an Evidence Appendix containing the claim register, and the retroactive case studies against xUSD and Resolv/USR.


Evidence Appendix

E1. Claim Register

Component Status Evidence
Dependency Graph Engine (DIG) Building 7+ protocol watchers, live outputs (reUSD, wsrUSD, cUSD: 500+ nodes)
Yield Tree Decomposition (YTD) Building Structured JSON + visual trees (wsrUSD, reUSD, Sentora PYUSD)
Recursive structural decomposition Building wsrUSD analysis: 6 findings, scorecard, circular exposure identified
Oracle / governance / leverage-loop alert system Phase 1 deliverable Not yet built; Month 3 target
Dashboard v1 + nutrition labels Phase 1 deliverable Not yet built; Month 5 target
Manifest template Phase 1 deliverable Not yet built; Month 6 target

E2. Retroactive Case Study

The following analysis documents what was visible onchain before two major Morpho incidents. The purpose is not to claim predictive certainty but to demonstrate that the structural signals behind each failure were present and readable from public blockchain state before the damage occurred. Our tooling is designed to detect each of these signal categories systematically.

Case 1: Stream Finance / xUSD (November 2025)

What happened: curators routed USDC deposits into recursive leverage loops backed by xUSD. When xUSD’s oracle refused to update, an estimated $285M–$700M was left at risk across Morpho, Euler, and Silo. Curators who had publicly claimed zero exposure were found to hold significant positions when the protocol collapsed.

What was visible onchain before the incident:

  • Leverage loop structure (YTD): the recursive loop, USDC deposits → xUSD collateral → USDC borrow → repeat, was fully visible from Morpho market interactions and supply/borrow balances at each layer, with leverage ratios reportedly reaching 10x. The YTD is designed to detect and flag this structure.
  • Supply velocity and redemption queue: xUSD’s totalSupply growth rate in the weeks before the collapse was abnormally high relative to its backing. The 65-day redemption queue was readable from the protocol contract and created a structural mismatch with 10x leverage positions.

Case 2: Resolv / USR Exploit (March 22, 2026)

What happened: an attacker exploited a flaw in Resolv’s USR minting contract, minting 80 million unbacked USR tokens from approximately $200,000 in USDC and extracting roughly $25 million in ETH. The wstUSR oracle was hardcoded and never repriced: wstUSR was marked at $1.13 while trading at $0.63 on secondary markets. Fifteen Morpho vaults were impacted. Some curators’ automated systems continued supplying liquidity into compromised markets hours after the exploit began.

What was visible onchain before the incident:

  • Hardcoded oracle: The wstUSR:USDC oracle was hardcoded with no secondary market reference and no circuit breaker. Once USR depegged, the oracle continued reporting stale prices while the asset traded at a steep discount, exactly the mechanism that enabled the collateral arbitrage.
  • Leverage loop and contract age: Resolv’s TVL grew from under $50M to over $650M in under three months, driven by leveraged looping on Morpho and Euler. The minting contract had high TVL relative to its age.

In both cases, the reserve shock created an onchain price that reflected the true value of the affected assets. The YTD’s structural decomposition allowed us to identify the exposure upstream, while the DIG enabled to obtain exit signals before the market shock propagation.

2 Likes

The “What Comes Next” section stood out, especially the idea of a quantitative risk translation layer on top of the structural DIG/YTD map: calibrated signals, factor scores, effective volatility estimates, and default probabilities conditioned on specific Morpho market structures.

That seems like a logical second layer once the Phase 1 structural outputs are validated against live vaults.

One question on future scope: how are you thinking about EVM-level simulation relative to the quantitative modeling approach?

For example, forking live chain state and propagating a depeg, oracle failure, or collateral impairment through the dependency graph to observe concrete outcomes: which Morpho markets become liquidatable, in what order, under which liquidity assumptions, and where losses could concentrate.

That feels different from factor-based scoring. It is less about estimating probability and more about making the onchain consequence path visible. In our experience from another DeFi context, this kind of scenario simulation is often what risk operators and curators want alongside risk labels: not only “this collateral has elevated structural risk,” but “if this dependency breaks, these markets are affected first.”

Is EVM-level scenario simulation something you see as part of the Phase 2 quantitative layer, or would you treat it as a separate module/scope from the DIG/YTD disclosure framework?

Strong support for the direction, from someone who does this by hand as a depositor.

Before I put capital in any vault I decompose three things at the contract level: how the share price is formed (balance ratio vs rate accumulator, a donation can inflate one and not the other), whether I can actually exit (redemption mechanics plus the real composition of the exit pool), and who can change what (caps, keeper roles, oracle admins, timelocks). Your DIG/YTD work systematizes the structural half of that checklist, and the wsrUSD decomposition in the RFC is the clearest argument for why it should exist as a public good.

One piece of feedback from the receipts I keep: consider making exit reality a first-class dimension of the registry, alongside structure. In early July, MIM read fine on price feeds while its main Curve pool sat 99.7% one-sided, roughly $12.5k of real stablecoins behind the exit of a 20M+ supply. Resolv’s hardcoded oracle failed exactly at the seam between reported price and exitable price. The dependency graph tells me what I own; what killed depositors in MIM, Resolv and xUSD was what they could not sell, at the moment they could not sell it. Pool composition snapshots and redemption-path capacity under the nutrition label would close that gap, and both are readable from the same public state your tooling already consumes.

Happy to share the exact queries behind any of the numbers above. As a user, I would adopt this framework the day it ships.

Really enjoyed reading this — the wsrUSD decomposition is such a clear way to show that “isolated markets” aren’t actually independent.

I recently stumbled on FIBO, the shared financial ontology that came out of the 2008 crisis (built in OWL). It was meant to answer a similar kind of question: what’s my real exposure to X when the links aren’t direct? Beyond describing structure, OWL also gives you reasoning and a way to validate that a configuration is consistent.

I know your work is more rule-based / graph-driven (Kappa territory), so this might be a bit of a different angle — but I wondered whether you see a role for something like an OWL ontology somewhere in DeFi. Maybe as a shared vocabulary so different tools and curators mean the same thing by “collateral” or “terminal exposure”? Or is that just the wrong tool for this domain?

Would love to hear your take.

Interesting angle. My take from doing the verification work by hand: the failures I keep finding are rarely vocabulary problems, they are stale data problems. In the wsrUSD case the terms were clear enough, what was missing was anyone re-checking contract state after the docs were written. A shared ontology helps tools talk to each other, but the binding constraint today is simpler: definitions age faster than anyone re-verifies them. I would take a “last verified at block X” field over a full OWL layer any day.

Hi @Antoine, @SrAugust, @chainza,

We appreciate your comments and feedback on our proposal.

On EVM-level scenario simulation: the YTD is built for exactly this. It recursively decomposes every allocation node (amounts, weights, LLTV, collateral type, borrow asset), giving you the precise input structure a fork-based simulation needs. Apply a shock at any node (depeg, oracle freeze, collateral impairment) and the dependency tree tells you which markets cross their LLTV threshold first and in what order. The DIG’s pathfinding algorithm then computes the optimal exit sequence given pool depths, withdrawal queue constraints, and the time information takes to propagate through multi-level graphs. That propagation window (measured in blocks), is where structural knowledge gives you an edge over reactive repricing. You can see this granularity live on real portfolios, the yield tree for Ellen Capital (a regulated asset manager we partner with. Full EVM fork simulation is Phase 3; the substrate is already there),

On shared ontology and stale data: both observations are correct and complementary. The DIG addresses the staleness problem directly; every node is derived from a live contract read, every edge carries a block timestamp. But the deeper Phase 2 vision is a TradFi-grade risk rating methodology adapted to onchain structures. We start from a Merton-style credit model — the standard reference in traditional credit risk (extended with six factors built specifically for blockchain): oracle reliability, governance mutation risk, smart contract exploit probability, liquidity depth under stress, counterparty concentration, and normalised market volatility. The structural advantage DeFi gives us that TradFi never had is per-block resolution: one block from the moment an event occurs, before multi-level graphs have finished propagating a shock to their terminal nodes. Combined with continuous structural decomposition and pathfinding, this creates the pricing inputs onchain insurance protocols need to underwrite collateral risk without systematically mispricing tail events. A natural extension of this work post Phase 2.

These tools are not purely theoretical. We use them to manage our own quantitative strategies, which means every layer of the stack is tested against real capital allocation decisions in production.

If you want to discuss further or explore integration, reach out at research@sigmalabs.fi

2 Likes

Following on the exit capacity point, here is a live case for why I think it belongs in Phase 1 rather than later.

Read from the Morpho public API on 15 August 2026, mainnet. The two USD3 markets, USD3/USDC at 92 percent LLTV and PT-USD3-17DEC2026/USDC at 86, together carry 28,923,238 dollars of borrow against 2,686,849 of liquidity. That is 9.3 percent, with utilisation at 91.5 percent on both.

What makes it a yield tree question rather than a utilisation question is the layer underneath. USD3 is the senior tranche over uncollateralised USDC lending, and its own liquid window read 10 million against 64 million lent on 13 August, down 33.4 percent over the previous 30 days.

So a depositor sees one liquidity number at the market, and there is a second one below it that moves independently. The two are not additive.

The same read on PT-reUSD-10DEC2026/USDC gives 55,887,325 borrowed against 7,309,040 liquid at 92 percent LLTV.

Every figure comes from the public GraphQL endpoint and reproduces in a single query. I have not measured the limit order book on any of these, so this is depth at the lending venue and not the full exit path.

For the registry, would a nutrition label carry liquidity at each layer separately, or one figure for the market?

1 Like

On the point in #7 that lending-venue depth is not the full exit path: I measured that missing half for the equities venues on Base and published it, so it can be cited rather than assumed. Pinned block 52175000; reads pinned by block hash with requireCanonical; both legs priced against the same state; a size ladder, a failure class per row, and the raw read logs in the same directory: https://github.com/dirkdiggler1026/executability-report/tree/main/measurements/base-depth

It is a concrete instance of the first post’s point about aggregate numbers suggesting depth that does not exist. At that block two NVDAc/USDC pools differ by roughly 600x on a USD 100 exit: one returns 99.31%, the other cannot return more than 0.168% — not because of slippage, but because that is all it holds. The two rows are published as different classes of evidence: the first is the measured path, the second is an on-chain holdings bound, and the walk value is shown beside it without being the claim.

Two things worth knowing before citing it. My largest published tier in that first class is USD 1,000. Correction, 2026-10-07: an earlier version of this paragraph said the larger tiers were “measured but withheld”. That is accurate for the sealed rows and not for five rows, which have no figure at all — those rows issue the most reads and failed with HTTP 429 on tickBitmap in each run, and the two runs lost different rows. Their absence is a property of our read budget in that run, not of the pool. The README lists them as rows with no number, and DISCLOSURE.md carries the per-run columns.

And the rounds are composed as a defined method — leg one’s output, net of fee, as leg two’s input against the same pinned state — separately validated per leg, not against real round-trip swaps.

Would a per-venue exit figure like this be useful as an input to the framework’s Phase 1 — and if so, which venues would you want covered first?

Yes, useful, and I would start with thin venues where a quoted number reads like depth. Pendle ORBIO, the Robinhood Chain pool maturing 8 October, is a clean case. Its implied rate went from 4.34% to 13.65% in two swaps and then sat there five days with no swap, on about 39.5k of liquidity (6 October). An exit figure there would say more than the rate. The USD3 markets from my earlier post would be my second pick.

Two corrections to my own wording above, both of which claimed more than the artifacts hold.

First, on the larger tiers: I wrote that they are measured but withheld. For five of the 43 rows that is not what happened — their reads failed with HTTP 429 on tickBitmap, on the rows that issue the most reads, and they have no figure at all. The two runs lost different rows, so their absence is a property of my read budget in that run rather than of any pool. The README has always listed them as rows with no number; my sentence did not.

Second, on the evidence: I called reads-Y1.json / reads-Y2.json the raw read logs. They are a sample. Each run issued about 2,450 calls and each file keeps the first 400, with the head of each response rather than the response, so they show which rows failed and why but cannot recompute the figures. That is now stated in DISCLOSURE.md beside the files, along with what can still be rechecked — the chain at that block hash, while the roughly 30-day provable window still serves it — and what changes from the next run on: the complete list kept, each entry with its request parameters and the sha256 of its full response, and the full responses shipped beside it.

The table itself is unchanged. Both of these were wording, not figures.

Thank you — and that is a better target than the ones I would have picked, because “a quoted number reads like depth” is the thing I measure.

Before anything else, one fact that changes what is still possible, and it is a property of the chain rather than of my schedule. I run a daily series on Robinhood Chain, and its public endpoint retains only about five to ten minutes of state: no rolling provable window exists on it. That is published in the verification block of my weekly feed, measured on 2026-09-11 and marked derived. The market you named, 0x752057e7a63d0a7f15b740d41ef484fdec459ead, expired at 00:00 UTC today. So the pre-expiry state of that pool is gone from the public endpoint. Recovering it would need an archival node for this chain, which I do not have — and a figure read from one would not be independently checkable by you either, which is why I do not use keyed endpoints for published numbers. Either way I am not going to pretend I can reconstruct it. What is still measurable there is the post-maturity side: PT redeeming against the market’s accounting asset, and the LP exit path. That is a different question from the pre-expiry trade and I would not publish the two under one label.

The same question is still live on a sibling market: the second ORBIO market on the same chain, 0x25ee3232421a08f390ef25a34b1d2ccc8394bd05, expires 22 October. A pre-expiry exit-cost measurement there can be read and archived properly, before expiry, with the state committed.

Two things about the work itself, so you know what you would be getting. Pendle is not the shape my current reader handles: the Base work reads Uniswap v3 state — tick bitmap, per-tick liquidityNet — and a PT market has its own yield-range curve. The quantity transfers exactly; the implementation does not, so this is a new adapter rather than a re-run. And my own failure archive says the first measurement of a venue I have not read before is the one most likely to be wrong, which is why I would rather publish it late with its failure classes than early without them. The 22 October maturity leaves enough time to do it the way the Base rows were done — two independent runs required to agree bit-for-bit, and rows that fail a read published as failures rather than dropped.

You mentioned doing these reads by hand. If you have your own numbers for either market, I would like to see them before I publish mine — an independent second reading of the same pool at the same pinned block is worth more to me than agreement from my own tooling.

One question, so I know which to start with: is it the pre-expiry exit cost on the 22 October market you would cite, or the post-maturity redemption path on the one that just expired?

Thanks, that’s very fair. I’d start with the pre-expiry exit cost on the 22 October market, since it can still be read and archived properly.

One thing that may help on the one that expired. The state is gone, but the event logs are still served. I pulled the UpdateImpliedRate and Swap events from the public RPC today. In the last two hours before expiry the implied rate went 4.32%, 20.91%, 30.50% and 54.28%, on three PT sales, the last one 36 minutes out. Happy to share the transaction hashes and the script so you can check them yourself.

Thanks — and the correction first, because it changed something I had published.

You were right about the logs, and I checked it rather than taking it. On the public endpoint, at 200,000 blocks back eth_getBalance returns historical state is not available, while eth_getLogs over the same fifty-block range returns 524 events. Events are still served at 1,000,000 blocks back (677), at 5,000,000 (960) and at 20,000,000 (1,318). At 50,000,000 the log query times out, which is a timeout and not an absence, and I record it as a timeout. The probe is code/measure_retention.py in the repository, with the artifact it produced, so you can run the same ladder against the same endpoint rather than take my numbers either.

So a sentence in the verification block of every weekly issue — “no rolling provable window exists on this chain” — was wrong as written. It is true of state and false of events. The claim is now read from that measurement instead of being held as a literal, and the generator refuses to publish an issue without one. It is also entry 17 in the published error archive, marked as reported by a reader: of the ten entries caught after publication, yours is the first that was not found inside the project. The archive says this project corrects itself; until today every one of those corrections had been self-inflicted and self-found, which is a weaker claim than it sounds.

The narrower lesson, which is the one I will carry: a retention claim has to name which retention class it is about. State and events are pruned on different schedules, so a sentence about the chain is almost always a sentence about one of them. The same shape as several other entries in that archive — a limit on what I could obtain, written as a property of the thing.

On the target: the 22 October market, pre-expiry. Two weeks is enough to do it the way the Base rows were done — two independent runs required to agree bit-for-bit, rows that fail a read published as failures rather than dropped, and the reads archived at the time with their digests, since by your own finding the state will be gone afterwards even though the events will not.

Please do send the hashes and the script. One thing I would want to do differently with them, and it is the reason I would rather re-derive than cite.

Implied rate is hypersensitive near maturity, and your four readings are at four different horizons. Taking a simple annualisation and par as the reference, the annualisation factor at two hours out is about 4,380 and at 36 minutes about 14,600. So those four rates correspond to price discounts of roughly 0.00099%, 0.00358%, 0.00348% and 0.00372%. The quoted rate rose about 12.6-fold; the discount it implies rose about 3.8-fold, and most of the rest is the clock. Pendle’s own rate is continuously compounded rather than simply annualised, which moves these figures slightly and does not change the order of magnitude.

That does not make the path uninteresting — a near-quadrupling of the discount on three sales may well be thin depth. It means the rate cannot distinguish thin depth from an approaching maturity, and if the number gets cited as evidence of the first, the second will be the obvious objection.

What can distinguish them is in the same logs you already pulled: the notional and the execution price of each of those three sales. Price-based slippage is comparable across the maturity; annualised rate is not. If your script reads the Swap amounts, that is the whole input — I would compute the discount per trade and the size that produced it, publish both with the method and the block hashes, and leave the mechanism open rather than assert it.

Which is your own point from #7 pointed at a different number: this time the quote that reads like depth is a rate, and it nearly took me in as well.