As of 19 Nov 2026, Strata has 2 audit reports by 1 security firm on Trustblock; the latest is by Quantstamp, dated 11 Aug 2026. Those reports list no open critical findings.
Record last updated . It holds audits and findings, contracts and incidents up to Nov 2026. Trustblock does not review code.
Newest first
| Report | Security firm | Date | Scope | Critical findings | Source |
|---|---|---|---|---|---|
| Strata Markets Update - Isolated and Saturn Strate | Security firm: Quantstamp | Date: | Scope: —Not recorded; see the report | None open | certificate.quantstamp.com ↗ |
| Strata - Discrete Accounting | Security firm: Quantstamp | Date: | Scope: —Not recorded; see the report | None open | certificate.quantstamp.com ↗ |
Statuses are the security firm’s own, from each report.
| Severity | Open | Acknowledged | Fixed | Mitigated |
|---|---|---|---|---|
| Critical | 0 | 0 | 0 | 0 |
| High | 0 | 0 | 0 | 0 |
| Medium | 0 | 0 | 7 | 1 |
| Low | 0 | 2 | 6 | 0 |
Marked Informational by the firms. 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.
Open the report`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.
Open the report`getOracleRate()` calls `oracle.latestRoundData()` but only validates that `answer > 0`. It does not check the `updatedAt` timestamp for staleness. If the custom aggregator v3 feed stops updating, the strategy would continue using a stale rate for all conversions, affecting deposits, withdrawals, `totalAssets()`, and NAV calculations. The oracle updates by Midas are infrequent, occurring around every 2-5 days, so a staleness threshold should be chosen with some headroom. Note that the overloaded `totalAssets(latestNav, timestamp)` does check `updatedAt` against the accounting timestamp, but `getOracleRate()` which is used in `convertToAssets` and `convertToTokens` for all other operations does not.
Open the report`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.
Open the report`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.
Open the reportSub-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.
Open the report`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.
Open the report`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.
Open the reportEvery 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.
Open the reportWhen `MidasCooldownRequestImpl.request()` falls back to `redeemRequest()`, the proxy sets `pending = true` and stores only an expected amount, but it does not persist the external request identifier. If a Midas admin later cancels the redemption request (`RedemptionVault.rejectRequest()`, `MidasCooldownRequestImpl` has no status check or cancellation path to clear local state, so `pending` remains true and future `request()` calls revert.
Open the reportIn the current implementation of the `MidasCooldownImpl` proxy contract, a user is unable to recover their funds if the Midas protocol fulfils their withdrawal request with less than 90% of the expected value. In this scenario the `finalize()` function will always revert until at least 90% of the `requestedAmount` of `baseAsset` tokens are present in the contract. This means the only way for a user to successfully recover the funds in this scenario would be to transfer the necessary amount of `baseAssets` into the contract to reach the `requestedAmount` value, unlocking the `finalize()` function and allowing them to redeem the contract's entire `baseAsset` token balance.
Open the reportThe reports name a repository or files. Open a report to see its scope.
Is this your project? Show this record on your own website. The label states what the record holds, links to this page and updates by itself. It is free and needs no sign-in.
Automatic: the three strongest facts of this project’s own record (its last audit and two more), highlighted. They update with the record. Picking a fact turns Automatic off.
<head><script src="https://widget.trustblock.run/project-widget.min.js" defer></script></head><body><divdata-tb-project-widgetdata-tb-project-slug="strata-1"></div></body>
Paste the code where the label should appear. It uses no API credit and updates by itself.
Something 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