Quantstamp reviewed Strata (Strata Markets Update - Isolated and Saturn Strate) on 11 Aug 2026: 13 findings, 0 critical; 11 marked fixed, 2 acknowledged; 1 more marked mitigated.
Report hosted on certificate.quantstamp.com.
Trustblock does not review code.
Statuses are the security firm’s own, from its report.
| Severity | Open | Acknowledged | Fixed | Mitigated |
|---|---|---|---|---|
| Critical | 0 | 0 | 0 | 0 |
| High | 0 | 0 | 0 | 0 |
| Medium | 0 | 0 | 6 | 1 |
| Low | 0 | 2 | 5 | 0 |
Marked Informational by the firm. Not counted as findings.
The `cancelRebalance()` function checks the aggregate share-token balance held by the `Rebalancer` rather than proving that the cooldown request associated with the selected pending rebalance has completed. Share tokens recovered from another request can therefore satisfy `minShares`, allowing the selected pending entry to be removed while its own proxy remains active. If that proxy returns its shares later, the shares arrive at the `Rebalancer` after the corresponding accounting entry has already been deleted. There is no dedicated recovery path for those late tokens, so they can remain stranded or be incorrectly consumed by a future cancellation.
`SaturnCooldownRequestImpl` always passes zero as `minUsdatReceived` when requesting redemption from `sUSDat`. The withdrawal queue therefore applies no request-specific minimum and relies only on Saturn's global execution tolerance, which is initially wide and can be configured up to one hundred percent. A redemption may consequently settle for materially less USDat than the value recorded when the request was created, with the shortfall borne by the withdrawing user. A simple fixed minimum also risks leaving an asynchronous request unprocessable if market conditions change, so recovery behavior must be considered.
`MultiStrategy` stores a separate `accounting` reference even though its allocation calculations must use the accounting contract configured in its parent `StrataCDO`. The reference is independently mutable through `setAccounting()`, allowing it to diverge from the source used for tranche pricing and balance updates. If the two values differ, `IsolatedStrategy.imbalances()` calculates deficits and surpluses from unrelated NAV data. Deposits and rebalances may consequently be routed in the wrong direction.
`liquidAllocationFloor` can be initialized or updated to a value greater than `1e18`, even though the value represents a percentage of total NAV. Such a value produces a Junior target greater than total Junior and Senior NAV combined. The subsequent calculation of `totalNav - target` underflows and causes `imbalances()` to revert, which can block deposit routing and rebalancing operations.
Sub-strategies configured under a `MultiStrategy` treat that composite strategy as their `cdo`. Several strategy implementations call `cdo.isJrt(tranche)` to select tranche-specific cooldowns or configuration, but `MultiStrategy` does not expose that function. These calls revert when reached, which can block otherwise supported withdrawals from Midas, Saturn, Ethena, Neutrl, or Figure sub-strategies. Spark's local fallback avoids a revert but can apply the Senior cooldown to a Junior withdrawal instead.
`completeRebalance()` deposits the lesser of the available token balance and `pending.baseAssets` into the destination strategy. It nevertheless emits `RebalanceCompleted` with the original `pending.baseAssets`, even when the actual deposit was smaller. Off-chain accounting, monitoring, and automation that rely on the event can therefore record a larger completed rebalance than occurred on-chain.
`maxDeposit()` limits how much Senior can deposit so that Junior stays at least `minimumJrtSrtRatioBuffer` (6%) of Senior. It does this by measuring Junior and Senior *before* the deposit and allowing Senior to grow up to the point where Junior would equal 6% of it. Normally this is exact. When the asset trades at par, a Senior deposit only adds to Senior and leaves Junior untouched — it moves one side of the ratio by exactly the deposited amount and nothing else. So the "before" snapshot predicts the "after" state perfectly, and depositing the maximum lands the ratio right on 6%. During a de-peg this breaks, because `calcEffectiveNav()` marks Senior back up to par by pulling value out of Junior, and the size of that transfer grows with Senior. Now a Senior deposit no longer touches just one side of the ratio, it touches both. The new Senior demands its own top-up, so Junior is drained further (the numerator drops), and the new Senior is itself marked up to par (the denominator grows by more than the deposit). The `maxDeposit()` cap does not consider both effects because it sized the deposit against the smaller, pre-deposit Senior without any effective nav markup. So it approves a deposit it believes lands at 6%, while the real result is a lower Junior over a higher Senior, pushing the effective ratio below the 6% buffer. The size of this gap scales with how deep the de-peg is, since a larger de-peg means a larger Senior top-up drawn from Junior. Under an extreme de-peg a single permitted deposit can therefore breach the ratio far more heavily. In the current implementation deposits should be paused once the valuation price is below `1e18`, however this problem becomes apparent if deposits are later reenabled without the peg returning to 1e18.
Every deferred rebalance appends an entry to `pendingRebalances`, while `Rebalancer.totalAssets()` loops over the complete array. A privileged operator can create many small pending rebalances by splitting an available deficit, causing the cost of accounting reads to grow without a fixed bound. Because `totalAssets()` is used by protocol accounting and user flows, a sufficiently large array can make those transactions exceed the block gas limit. The role restriction makes this primarily an operational and configuration risk rather than an unprivileged denial of service.
The report names a repository or files. Open the report to see its scope.
240 projects reviewed · 338 reports · latest Nov 2026
See Quantstamp’s auditsSomething wrong on this page? A missing report, a wrong date, a finding that was fixed since. Tell us and we check it against its source.
Tell us