// SPDX-License-Identifier: GPL-2.0-or-later pragma solidity ^0.8.24; /// @title TickMath (vendored from Uniswap v3-core, math unchanged) /// @notice Computes sqrt(1.0001^tick) as a Q64.96, exactly as the canonical /// pool contracts do, so TWAP ticks decode to the same prices the /// pool itself trades at. Only getSqrtRatioAtTick is vendored. library TickMath { error TickOutOfRange(); int24 internal constant MIN_TICK = -887272; int24 internal constant MAX_TICK = 887272; function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) { unchecked { uint256 absTick = tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick)); if (absTick > uint256(int256(MAX_TICK))) revert TickOutOfRange(); uint256 ratio = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000; if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128; if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128; if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128; if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128; if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128; if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128; if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128; if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128; if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128; if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128; if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128; if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128; if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128; if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128; if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128; if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128; if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128; if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128; if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128; if (tick > 0) ratio = type(uint256).max / ratio; // Round up on the downcast, matching the canonical library. sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1)); } } }

// SPDX-License-Identifier: AGPL-3.0-only pragma solidity ^0.8.24; /// @notice Chainlink AggregatorV3 surface the desk needs: the latest round /// for marks/guards plus historical rounds for the §4 round proofs /// (`liquidate` / `settle`). The uiMultiplier lives on the TOKEN /// (ERC-8056), never here. interface ITurboFeed { function decimals() external view returns (uint8); function latestRoundData() external view returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); function getRoundData(uint80 roundId) external view returns ( uint80 roundId_, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); } /// @notice The feed adapter surface (§4 "session state"): the pinned /// RwaFeedAdapter serves both — `priceWad` with market-hours-aware /// staleness + the uiMultiplier identity assert, and `sessionOpen`, /// the ONE market-hours predicate behind spread selection, the /// rung-4 cap and every session readout. interface ITurboFeedAdapter { function priceWad(address feed, address token) external view returns (uint256); function sessionOpen(uint256 timestamp) external view returns (bool); } /// @notice Minimal Uniswap v3 pool surface for rung 2 (§5.6): the pinned /// stock-token/USDG pool's 30-min TWAP via `observe`, plus /// `liquidity`/`slot0` for the §6.4 MIN_POOL_DEPTH displacement bar. interface ITurboPool { function token0() external view returns (address); function token1() external view returns (address); function liquidity() external view returns (uint128); function slot0() external view returns ( uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol ); function observe(uint32[] calldata secondsAgos) external view returns ( int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s ); } /// @notice ERC-1155 receiver hooks (cards are ordinary ERC-1155s, §3.6b). interface ITurboCardReceiver { function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns (bytes4); function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns (bytes4); } /// @title ITurboDesk — the TURBO Long-Dated Desk (specs/turbo.md v2.8) /// @notice Knock-out cards (turbo warrants) on the three menu names. A CALL /// card is `units × max(mark − K, 0)` of upside, physically reserved /// from the equity pot; a PUT card is `units × max(K − mark, 0)`, /// cash-secured by a full `units × K` USDG reservation from a /// separate per-name put pot (§3.4, v2.8). The bar IS K on both /// sides — one touch kills, all-or-nothing, nothing withheld. Cards /// are ERC-1155, one id per series, freely transferable; transfers /// never touch desk accounting (§3.6b / I-10). interface ITurboDesk { // ── Types ── enum Side { CALL, PUT } /// @notice Series lifecycle. Monotone: OPEN → KNOCKED | EXPIRED | VOID, /// and nothing ever leaves a terminal state (I-4). enum SeriesState { NONE, OPEN, KNOCKED, EXPIRED, VOID } /// @notice One strike/leverage listing (§3.1) — terms immutable once /// opened (I-3). There is deliberately NO barWad: the bar IS /// `strikeWad` (§3.2, all-or-nothing). struct Series { address asset; // menu token (registry-pinned with feed + pool) Side side; SeriesState state; bool salesHalted; // blocks buy ONLY (§3.3.3) uint64 expiry; // backstop, ≤ MAX_TENOR uint64 createdAt; uint32 maxCards; // reservation-backed capacity uint32 sold; uint32 outstanding; // minted minus burned (cash-out/claim/refund) uint256 strikeWad; // K, financing level AND the bar (feed USD, wad) uint256 unitsPerCard; // 18-dec underlying units per card uint256 baseUiMultiplier; // corporate-action snapshot (§5.3) uint256 listLeverageWad; // leverage at listing (§3.1 drift guard) uint256 premiumUsdgRaw; // Σ net premium paid in (VOID refund basis) uint256 settleMarkWad; // M at settle (EXPIRED) / last mark (VOID) uint256 settlePerCard; // per-card entitlement at M: CALL asset units, // PUT raw USDG (0 until settled) uint80 liqRoundId; // audit trail only — no payout depends on it uint80 settleRoundId; uint64 knockCheckpointAt; // §4 rung-2 checkpoint (0 = none) uint64 driftOnsetAt; // §5.3 uiMultiplier-drift grace clock (0 = none) uint80 offHoursWindowId; // rung-4 window id = last in-session round uint32 soldInWindow; uint32 windowCapCards; } /// @notice Per-wallet, per-series basis ledger (§3.7, v2.7): written at /// `buy` only, drawn down at close only; transfers never touch /// it (I-10), so transferred-in cards carry zero basis. struct Basis { uint256 costUsdgRaw; // Σ full USDG paid (value + spread + fee) uint256 count; // cards bought (still un-closed against basis) } /// @notice Per-asset buckets (§3.6). The equity side (CALL cover) and /// the put side (§3.4 USDG put pot) live side by side but are /// strictly isolated: no operation moves value between them /// (I-13). struct AssetBook { uint256 potUnits; // free equity pot (18-dec units) uint256 reservedUnits; // Σ CALL reservations (units) uint256 putPotUsdg; // free put pot (raw USDG) uint256 putReservedUsdg; // Σ PUT reservations (raw USDG) uint256 premiumUsdg; // CALL premiums awaiting conversion (raw USDG) uint256 feeManagerTok; // CALL performance-fee buckets (token units) uint256 feeSleeveTok; } /// @notice USDG fee buckets: open fees + PUT performance fees. struct UsdgFees { uint256 feeManager; uint256 feeSleeve; } // ── Errors ── error ZeroAddress(); error InvalidConfig(); error NotManager(); error NotHalter(); error Reentrancy(); error TransferFailed(); error UnexpectedInflow(); error SwapFailed(); error RouterUnavailable(); error MinOutNotMet(); error OracleValueTooLow(); error NothingToConvert(); error UnknownAsset(address asset); error UnknownSeries(uint256 seriesId); error BadSeriesState(); error SalesHalted(); error SeriesSoldOut(); error SeriesExpired(); error ZeroCount(); error ZeroValueCard(); error BadStrike(); error BadTenor(); error BadLeverage(uint256 leverageWad); error LeverageDrifted(uint256 effectiveWad, uint256 floorWad); error MarkThroughStrike(uint256 markWad, uint256 strikeWad); error RecentRoundBreached(uint80 roundId); error KnockCheckpointPending(uint64 recordedAt); error NoCheckpoint(); error ChainlinkProvesAlive(); error CheckpointExists(uint64 recordedAt); error PersistNotMet(uint64 recordedAt); error Rung2Unavailable(); error Rung2NotServing(); error NotBreached(); error InvalidRound(uint80 roundId); error RoundBeforeCreation(uint80 roundId); error RoundNotBeforeExpiry(uint80 roundId); error RoundBeforeExpiry(uint80 roundId); error NotFirstRoundAfterExpiry(uint80 roundId); error RoundOffSession(uint80 roundId); error SlippageExceeded(uint256 actual, uint256 bound); error InsufficientPot(uint256 needed, uint256 free); error OffHoursWindowCap(uint256 requested, uint256 left); error PayoutExceedsReservation(); error UiMultiplierDrift(uint256 got, uint256 snapshot); error NoDriftChange(); error DriftGraceNotStarted(); error MarketClosed(); error GraceNotElapsed(uint256 quietSeconds, uint256 grace); error NoOpenPositions(); error CoverageFloor(); error BelowOperatingFloor(uint256 remaining, uint256 floor); error SessionRequired(); error FreshMarkRequired(uint256 updatedAt, uint256 maxAge); error SettleWalkTooDeep(); error SkimUnderflow(); // ── Events ── event SeriesCreated( uint256 indexed seriesId, address indexed asset, Side side, uint256 strikeWad, uint256 unitsPerCard, uint64 expiry, uint32 maxCards, uint256 listLeverageWad, uint256 listMarkWad ); event CardsBought( uint256 indexed seriesId, address indexed buyer, uint256 count, uint8 rung, uint256 markWad, uint256 premiumUsdgRaw, uint256 feeUsdgRaw ); event CardsCashedOut( uint256 indexed seriesId, address indexed holder, uint256 count, uint8 rung, uint256 markWad, uint256 payoutGross, // CALL asset units / PUT raw USDG uint256 perfFee ); event SeriesKnocked(uint256 indexed seriesId, uint80 roundId, uint256 reservationReleased); event KnockRecorded(uint256 indexed seriesId, uint64 at, uint256 twapWad); event KnockCleared(uint256 indexed seriesId, uint256 twapWad); event SeriesSettled( uint256 indexed seriesId, uint80 roundId, uint256 settleMarkWad, uint256 settlePerCard ); event ExpiryClaimed( uint256 indexed seriesId, address indexed holder, uint256 count, uint256 payoutGross, uint256 perfFee ); event DriftRecorded(uint256 indexed seriesId, uint256 multiplier, uint64 at); event DriftCleared(uint256 indexed seriesId, uint256 multiplier); event SeriesVoided(uint256 indexed seriesId, uint256 lastMarkWad); event Refunded(uint256 indexed seriesId, address indexed holder, uint256 count, uint256 amount); event HouseDeposited(address indexed asset, address indexed from, uint256 amount, uint256 pot); event HouseWithdrawn(address indexed asset, uint256 amount, uint256 pot); event PutPotDeposited(address indexed asset, address indexed from, uint256 amount, uint256 pot); event PutPotWithdrawn(address indexed asset, uint256 amount, uint256 pot); event SalesHaltSet(uint256 indexed seriesId, bool halted, address by); // id 0 = all event FeesSwept(address indexed caller, uint256 managerUsdg, uint256 sleeveUsdg); event TokenFeesSwept(address indexed asset, uint256 managerTok, uint256 sleeveTok); event PremiumsConverted(address indexed asset, uint256 usdgIn, uint256 tokensOut); event SleeveFeesConverted(address indexed asset, uint256 usdgIn, uint256 tokensOut); event Skimmed(address indexed token, uint256 amount); // ── User surface ── function buy(uint256 seriesId, uint256 count, uint256 maxPriceUsdg) external returns (uint256 paidUsdgRaw); function cashOut(uint256 seriesId, uint256 count, uint256 minOut) external returns (uint256 paidOut); function claimExpiry(uint256 seriesId, uint256 count) external returns (uint256 paidOut); function refund(uint256 seriesId, uint256 count) external returns (uint256 refunded); // ── Permissionless lifecycle ── function liquidate(uint256 seriesId, uint80 roundId) external; function recordDrift(uint256 seriesId) external; function recordKnock(uint256 seriesId) external; function liquidateKnock(uint256 seriesId) external; function clearKnock(uint256 seriesId) external; function settle(uint256 seriesId, uint80 roundId) external; function markVoid(uint256 seriesId) external; // ── House / fees ── function depositHouse(address asset, uint256 amount) external; function withdrawHouse(address asset, uint256 amount) external; function depositPutPot(address asset, uint256 usdgRaw) external; function withdrawPutPot(address asset, uint256 usdgRaw) external; function sweepFees() external; function convertPremiums(address asset, uint256 minTokensOut, bytes calldata swapCalldata) external returns (uint256 tokensOut); function convertSleeveFees(address asset, uint256 minTokensOut, bytes calldata swapCalldata) external returns (uint256 tokensOut); function skim(address token) external; // ── Manager surface ── function createSeries( address asset, Side side, uint256 strikeWad, uint256 unitsPerCard, uint64 expiry, uint32 maxCards ) external returns (uint256 seriesId); function haltSales(uint256 seriesId) external; function resumeSales(uint256 seriesId) external; // ── Views ── function seriesCount() external view returns (uint256); function seriesOf(uint256 seriesId) external view returns (Series memory); /// @notice The per-asset buckets in one read (freePot/reserved and the /// put-side mirrors are its fields). function bookOf(address asset) external view returns (AssetBook memory); function usdgFees() external view returns (UsdgFees memory); function servingRung(address asset) external view returns (uint8 rung, uint256 markWad); function rung2Available(address asset) external view returns (bool ok, uint256 twapWad); /// @notice The board row (§4 views): serving rung, mark, haircut in /// force, live effective leverage and distance-to-K. function seriesLive(uint256 seriesId) external view returns ( uint8 rung, uint256 markWad, uint256 haircutBps, uint256 effLeverageWad, uint256 distanceBps ); function quoteBuy(uint256 seriesId, uint256 count) external view returns (uint256 totalUsdgRaw, uint8 rung, uint256 markWad); function quoteCashOut(uint256 seriesId, uint256 count, address holder) external view returns (uint256 netOut, uint256 perfFee, uint8 rung, uint256 markWad); function offHoursWindowLeft(uint256 seriesId) external view returns (uint256); function markAge(address asset) external view returns (uint256); function basisOf(uint256 seriesId, address wallet) external view returns (uint256 costUsdgRaw, uint256 count); function unrealizedProfitUsdWad(uint256 seriesId, address wallet) external view returns (int256); }

// SPDX-License-Identifier: AGPL-3.0-only pragma solidity ^0.8.24; import {ITurboCardReceiver} from "./ITurboDesk.sol"; /// @title TurboCards — minimal in-house ERC-1155 base for TURBO cards /// @notice specs/turbo.md §3.6b: cards are ERC-1155, one id per series, /// freely transferable. This base is written in-house because the /// repo vendors no token library (only forge-std) and the registry /// rule forbids pulling one from memory. It is deliberately hookless: /// transfers move balances and NOTHING else — no desk accounting, no /// basis-ledger writes, no balance-based restriction of any kind /// (O-6/I-10) — so a transfer can never revert on desk state and an /// integrating contract may hold an arbitrary quantity. Dead /// (KNOCKED) ids stay transferable by design; §3.6b hazard 2 is a UI /// duty, not a token one. abstract contract TurboCards { error NotAuthorized(); error LengthMismatch(); error InsufficientBalance(); error UnsafeRecipient(); event TransferSingle( address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value ); event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values ); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); event URI(string value, uint256 indexed id); mapping(address => mapping(uint256 => uint256)) public balanceOf; mapping(address => mapping(address => bool)) public isApprovedForAll; /// @notice On-chain card metadata (§3.6b): the series terms, so a card /// is self-describing in any wallet without an indexer. function uri(uint256 id) public view virtual returns (string memory); function setApprovalForAll(address operator, bool approved) external { isApprovedForAll[msg.sender][operator] = approved; emit ApprovalForAll(msg.sender, operator, approved); } function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes calldata data ) external { if (msg.sender != from && !isApprovedForAll[from][msg.sender]) { revert NotAuthorized(); } _move(from, to, id, amount); emit TransferSingle(msg.sender, from, to, id, amount); if (to.code.length != 0) { if ( ITurboCardReceiver(to).onERC1155Received(msg.sender, from, id, amount, data) != ITurboCardReceiver.onERC1155Received.selector ) revert UnsafeRecipient(); } else if (to == address(0)) { revert UnsafeRecipient(); } } function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data ) external { if (ids.length != amounts.length) revert LengthMismatch(); if (msg.sender != from && !isApprovedForAll[from][msg.sender]) revert NotAuthorized(); for (uint256 i = 0; i < ids.length; i++) { _move(from, to, ids[i], amounts[i]); } emit TransferBatch(msg.sender, from, to, ids, amounts); if (to.code.length != 0) { if ( ITurboCardReceiver(to).onERC1155BatchReceived(msg.sender, from, ids, amounts, data) != ITurboCardReceiver.onERC1155BatchReceived.selector ) revert UnsafeRecipient(); } else if (to == address(0)) { revert UnsafeRecipient(); } } function balanceOfBatch(address[] calldata owners, uint256[] calldata ids) external view returns (uint256[] memory balances) { if (owners.length != ids.length) revert LengthMismatch(); balances = new uint256[](owners.length); for (uint256 i = 0; i < owners.length; i++) { balances[i] = balanceOf[owners[i]][ids[i]]; } } function supportsInterface(bytes4 interfaceId) external pure returns (bool) { return interfaceId == 0x01ffc9a7 // ERC-165 || interfaceId == 0xd9b67a26 // ERC-1155 || interfaceId == 0x0e89341c; // ERC-1155 metadata URI } function _move(address from, address to, uint256 id, uint256 amount) private { uint256 bal = balanceOf[from][id]; if (bal < amount) revert InsufficientBalance(); unchecked { balanceOf[from][id] = bal - amount; } balanceOf[to][id] += amount; } /// @dev Mint on `buy` only — every card in existence was paid for at the /// printed price against reserved cover (§3.6b: games buy, they /// never mint). function _mint(address to, uint256 id, uint256 amount) internal { balanceOf[to][id] += amount; emit TransferSingle(msg.sender, address(0), to, id, amount); if (to.code.length != 0) { if ( ITurboCardReceiver(to).onERC1155Received(msg.sender, address(0), id, amount, "") != ITurboCardReceiver.onERC1155Received.selector ) revert UnsafeRecipient(); } } /// @dev Burn on close (cash-out / claim / refund) — caller's own cards. function _burn(address from, uint256 id, uint256 amount) internal { uint256 bal = balanceOf[from][id]; if (bal < amount) revert InsufficientBalance(); unchecked { balanceOf[from][id] = bal - amount; } emit TransferSingle(msg.sender, from, address(0), id, amount); } }

// SPDX-License-Identifier: AGPL-3.0-only pragma solidity ^0.8.24; import {RwaConstants} from "../rwa/RwaConstants.sol"; /// @title TurboConstants — TURBO Long-Dated Desk parameters /// @notice Single source of truth for the resolved §12 numbers of /// `specs/turbo.md` (v2.8, O-1..O-12 all RESOLVED 2026-08-16/17). /// Mirrors the FlipConstants / InvaderConstants pattern: standalone /// additive product, its own constant table. The immutable, /// trust-critical economics are passed to the desk constructor from /// these constants by the deploy script and frozen there. /// /// The price-ladder rung numbering is 1 / 2 / 4 ON PURPOSE: rung 3 /// (the signed Rialto quote) does NOT exist in code — the O-12 /// ruling ships rungs 1/2/4 only, `quoteRungEnabled` is false at /// launch, and enabling rung 3 is a redeploy that belongs in the §11 /// audit + legal pass as an explicit change of trust model. Nothing /// here reserves state for it. library TurboConstants { uint256 internal constant WAD = 1e18; uint256 internal constant BPS = 10_000; // ── Fees (§3.7, O-8) ── /// @dev 5% of card premium (not notional), charged on top at `buy`. uint256 internal constant FEE_BPS = 500; /// @dev Split 50/50: 2.5% Manager / 2.5% Sleeve. MUST sum to FEE_BPS. uint256 internal constant MANAGER_FEE_BPS = 250; uint256 internal constant SLEEVE_FEE_BPS = 250; /// @dev v2.7: 5% of net profit on a profitable close (`cashOut` / /// `claimExpiry`), taken in the payout asset at the closing mark. /// Never charged on knock-outs, VOID or refunds. Same 50/50 split. uint256 internal constant PERF_FEE_BPS = 500; // ── Spreads and the off-hours band (§3.2/§3.3, O-5/O-9/O-12) ── /// @dev 100 bps each side, on premium, accruing to the house pot (pot /// income, never fee-bucket income). uint256 internal constant ENTRY_SPREAD_BPS = 100; uint256 internal constant EXIT_SPREAD_BPS = 100; /// @dev Rung-4 band on the quoted mark (O-9: 50 bps). Value form: /// haircut = min(L_eff × band, OFF_HAIRCUT_MAX). uint256 internal constant OFF_MARK_BAND_BPS = 50; /// @dev Rung-2 live band (O-12: 20 bps) — TWAP granularity + thin-book /// slippage, not gap risk. uint256 internal constant OFF_MARK_BAND_LIVE_BPS = 20; /// @dev The §3.2 cap, binding on EVERY rung (v2.6): a living card always /// quotes above zero. uint256 internal constant OFF_HAIRCUT_MAX_BPS = 2500; // ── Rung-4 window cap + keeper divergence bound (§3.3, O-9) ── /// @dev Per series, per off-hours window: rung-4 buys capped at 25% of /// the tranche's remaining capacity at the window's first buy. uint256 internal constant OFF_HOURS_CAP_BPS = 2500; /// @dev Keeper divergence-halt threshold (§7.6a) — an off-chain alarm /// input recorded here for one-source-of-truth; never read on-chain. uint256 internal constant OFF_HOURS_DIVERGENCE_BPS = 100; // ── Leverage and tenor bounds (§3.1, O-5) ── uint256 internal constant LEV_MIN_WAD = 5e18; uint256 internal constant LEV_MAX_WAD = 25e18; /// @dev §3.1 drift guard: `buy` reverts once effective leverage falls /// below 50% of the listed leverage. Exits are untouched. uint256 internal constant LEV_BADGE_FLOOR_BPS = 5000; uint256 internal constant MIN_TENOR = 7 days; /// @dev "6 months" (O-5) in the 30-day-month convention the listing /// tenor uses (LIST_TENOR = 30 days). uint256 internal constant MAX_TENOR = 180 days; /// @dev Operational listing tenor (§3.1) — a Manager convention, not an /// on-chain bound. uint256 internal constant LIST_TENOR = 30 days; // ── Ladder parameters (§5.6, O-10/O-12) ── /// @dev Rung-2 TWAP window (O-10 measurement: cardinality supports 30 /// min on every measured pool). uint32 internal constant TWAP_WINDOW = 30 minutes; /// @dev Rung-2 kill persistence: `liquidateKnock` needs a checkpoint at /// least this old with the TWAP still through K (O-12: 10 min). uint256 internal constant LIQ_PERSIST = 10 minutes; /// @dev O-3/§6.4: the per-name rung-2 admission bar is the board seed — /// a 1% single-block push must cost at least this much (the /// MIN_POOL_DEPTH displacement bar; deploy config passes it). uint256 internal constant BOARD_SEED_USD_WAD = 10_000e18; /// @dev √1.01 (wad) — the sqrt-price ratio of a 1% displacement. uint256 internal constant SQRT_101_WAD = 1_004_987_562_112_089_027; // ── uiMultiplier plausibility band (Q43, human 2026-08-17) ── /// @dev The TURBO adapter carries NO identity assert (the RwaFeedAdapter /// one was an implementation artifact stricter than turbo.md /// §3.1/§5.3): the authoritative guard is the per-series /// `baseUiMultiplier` snapshot, asserted on every settlement- /// relevant op, with drift fail-closing that asset. These bounds /// are a wide FAT-FINGER guard on the live read only — a /// plausibility claim (±20% of identity covers ERC-8056 /// dividend-style adjustments like AAPL's live 1.000566e18 by three /// orders of magnitude), never a semantics claim. uint256 internal constant UI_MULT_MIN_WAD = 0.8e18; uint256 internal constant UI_MULT_MAX_WAD = 1.2e18; // ── Feed staleness (§5.1, finding-3b; v1.1 ruling 2026-08-18) ── /// @dev The single ABSOLUTE feed-age bound (96h): past it `priceWad` /// reverts StaleFeed and the §5.2 VOID clock is the escape. Raised /// from the RWA desk's shared 80h so a Monday/Friday NYSE-holiday /// long weekend still prices the frozen last close on rung 4 /// (structural worst Fri-close → Tue-open over a Monday holiday /// ≈ 90h; the observed July-4-2026 gap was 79.7h; 96h clears it /// with ~6h of margin). This is a TURBO-only immutable; the RWA /// desk's 80h is untouched. uint256 internal constant FEED_MAX_AGE_IDLE = 96 hours; /// @dev Rung-1 freshness bound (v1.1 ruling 2026-08-18): a mark older /// than this NEVER fail-closes trading — it selects rung 2/4, the /// same degraded-price ladder that serves nights and weekends (the /// 2026-08-18 feed-cadence incident: these deviation-triggered /// feeds legitimately sit quiet >4h on a calm in-session /// afternoon). The bound still gates the two house-side legs that /// MUST price off a live mark: `createSeries` and the conversion /// legs (FreshMarkRequired). uint256 internal constant FEED_MAX_AGE_ACTIVE = RwaConstants.FEED_MAX_AGE_ACTIVE; // ── Expiry / VOID (§5.1–§5.2, O-5) ── /// @dev Feed-death grace before a series may be VOIDed: 14 days of /// IN-SESSION quiet (§5.2 — the clock counts in-session seconds /// only, so no holiday weekend walks a healthy series toward VOID). /// Also the §5.3 drift-onset grace (finding-1): once uiMultiplier /// drift is recorded, `markVoid` opens after this many in-session /// seconds of persisted drift, measured from the drift-onset clock. uint256 internal constant SETTLE_GRACE = 14 days; /// @dev Bound on the §5.1 "first valid in-session round at/after expiry" /// back-walk (skipping off-session prints); fail-closed above it. uint256 internal constant MAX_SETTLE_WALK = 64; /// @notice The per-premium open fee: ceil(premium × 5%) — rounds up so /// the house is never undercharged by dust. function feeFor(uint256 premium) internal pure returns (uint256) { uint256 fee = premium * FEE_BPS / BPS; if (fee * BPS < premium * FEE_BPS) fee += 1; return fee; } /// @notice US equity full-day market closures (NYSE), as Unix epoch-day /// numbers (`floor(timestamp / 1 days)`), sorted ascending, /// covering 2025–2027 (the deployment window + MAX_TENOR). On /// these WEEKDAYS the `us_equities_24/5` feed is dark exactly as /// it is on a weekend, so the market-hours predicate must treat /// them as CLOSED (finding-3a): otherwise `sessionOpen()` reports /// a live session, the §5.6 ladder picks rung 1, and `priceWad` /// reverts `StaleFeed` against a legitimately frozen close — /// trapping cash-out on a weekday holiday. Treated-closed routes /// the mark to rung 2 (token TWAP) or rung 4 (frozen close under /// the 96h idle bound), so every exit stays reachable. The /// authoritative holiday source + refresh cadence past 2027 is a /// human decision (see specs/OPEN_QUESTIONS.md). function isHoliday(uint256 timestamp) internal pure returns (bool) { uint256 day = timestamp / 1 days; // Cheap reject for anything outside the encoded span (hot path). if (day < 20_089 || day > 21_176) return false; uint16[30] memory h = [ uint16(20_089), // 2025-01-01 New Year's Day 20_108, // 2025-01-20 MLK Day 20_136, // 2025-02-17 Washington's Birthday 20_196, // 2025-04-18 Good Friday 20_234, // 2025-05-26 Memorial Day 20_258, // 2025-06-19 Juneteenth 20_273, // 2025-07-04 Independence Day 20_332, // 2025-09-01 Labor Day 20_419, // 2025-11-27 Thanksgiving 20_447, // 2025-12-25 Christmas 20_454, // 2026-01-01 New Year's Day 20_472, // 2026-01-19 MLK Day 20_500, // 2026-02-16 Washington's Birthday 20_546, // 2026-04-03 Good Friday 20_598, // 2026-05-25 Memorial Day 20_623, // 2026-06-19 Juneteenth 20_637, // 2026-07-03 Independence Day (observed) 20_703, // 2026-09-07 Labor Day 20_783, // 2026-11-26 Thanksgiving 20_812, // 2026-12-25 Christmas 20_819, // 2027-01-01 New Year's Day 20_836, // 2027-01-18 MLK Day 20_864, // 2027-02-15 Washington's Birthday 20_903, // 2027-03-26 Good Friday 20_969, // 2027-05-31 Memorial Day 20_987, // 2027-06-18 Juneteenth (observed) 21_004, // 2027-07-05 Independence Day (observed) 21_067, // 2027-09-06 Labor Day 21_147, // 2027-11-25 Thanksgiving 21_176 // 2027-12-24 Christmas (observed) ]; uint256 lo = 0; uint256 hi = 29; while (lo <= hi) { uint256 mid = (lo + hi) / 2; uint256 v = h[mid]; if (v == day) return true; if (v < day) { lo = mid + 1; } else { if (mid == 0) break; hi = mid - 1; } } return false; } /// @notice In-session seconds in [a, b) under the RwaConstants session /// window (weekdays 14:00–20:30 UTC — the same predicate the /// deployed RwaFeedAdapter serves). Closed form, O(1); drives /// the §5.2 in-session-quiet VOID clock. function inSessionSecondsBetween(uint256 a, uint256 b) internal pure returns (uint256) { if (b <= a) return 0; return _inSessionSecondsSinceEpoch(b) - _inSessionSecondsSinceEpoch(a); } /// @dev Total in-session seconds in [0, t). function _inSessionSecondsSinceEpoch(uint256 t) private pure returns (uint256) { uint256 sessionLen = RwaConstants.SESSION_CLOSE_UTC_MIN - RwaConstants.SESSION_OPEN_UTC_MIN; uint256 day = t / 1 days; uint256 full = _weekdaysBefore(day) * sessionLen; // Partial current day (epoch day 0 was a Thursday; weekday 0 = Mon). if ((day + 3) % 7 < 5) { uint256 tod = t % 1 days; if (tod > RwaConstants.SESSION_OPEN_UTC_MIN) { uint256 inDay = tod - RwaConstants.SESSION_OPEN_UTC_MIN; full += inDay > sessionLen ? sessionLen : inDay; } } return full; } /// @dev Number of weekday (Mon–Fri) days among epoch days [0, d). function _weekdaysBefore(uint256 d) private pure returns (uint256) { uint256 weeks_ = d / 7; uint256 rem = d % 7; // Partial-week days start on a Thursday (epoch alignment): the // cumulative weekday count over Thu,Fri,Sat,Sun,Mon,Tue,Wed. uint8[7] memory cum = [0, 1, 2, 2, 2, 3, 4]; return weeks_ * 5 + cum[rem]; } }

// SPDX-License-Identifier: AGPL-3.0-only pragma solidity ^0.8.24; import {ITurboDesk, ITurboFeed, ITurboFeedAdapter, ITurboPool} from "./ITurboDesk.sol"; import {TurboConstants} from "./TurboConstants.sol"; import {IRouterSource, IUiMultiplierToken} from "../rwa/RwaAdapters.sol"; import {IERC20, IERC20Metadata} from "../interfaces/external/IERC20.sol"; import {DeskMath} from "../rwa/DeskMath.sol"; import {FixedPointMath} from "../libraries/FixedPointMath.sol"; import {TickMath} from "../perp/libraries/TickMath.sol"; /// @title TurboLogic — TurboDesk's operation legs, deployed as an external /// library (specs/turbo.md v2.8) /// @notice The desk's oracle proofs, price ladder, pricing formulas, bucket /// legs and metadata live here so the desk contract itself stays /// under the EIP-170 size limit. External-library functions run via /// DELEGATECALL in the desk's own context: storage pointers the desk /// passes in are the desk's own buckets and series, and the swap /// leg's approvals/calls are made by the desk address exactly as if /// inlined. The desk owns every external entrypoint, every guard /// ordering, and all token transfers; nothing here can be reached /// except through it. library TurboLogic { // ═════════════════════════════ Rung 2 (§5.6/§6.4) ═══════════════════════ /// @notice The rung-2 source: the pinned v3 pool's TWAP_WINDOW TWAP, /// admitted only above the §6.4 manipulation-cost bar (a 1% /// single-block push must cost ≥ the name's board seed). Falls /// through (`ok = false`) rather than reverting on any failure — /// missing observations, drained liquidity, a bricked pool /// (I-11). function rung2Twap(address pool, bool assetIsToken0, uint256 depthBarUsdWad, uint256 usdgWadFactor) public view returns (bool ok, uint256 twapWad) { uint128 liq; uint160 sqrtP; try ITurboPool(pool).liquidity() returns (uint128 l) { liq = l; } catch { return (false, 0); } if (liq == 0) return (false, 0); try ITurboPool(pool).slot0() returns (uint160 sp, int24, uint16, uint16, uint16, uint8) { sqrtP = sp; } catch { return (false, 0); } if (sqrtP == 0) return (false, 0); if (_displacementCostUsdWad(liq, sqrtP, assetIsToken0, usdgWadFactor) < depthBarUsdWad) { return (false, 0); } uint32[] memory ago = new uint32[](2); ago[0] = TurboConstants.TWAP_WINDOW; ago[1] = 0; try ITurboPool(pool).observe(ago) returns (int56[] memory ticks, uint160[] memory) { int56 delta = ticks[1] - ticks[0]; int56 window = int56(uint56(TurboConstants.TWAP_WINDOW)); int24 avgTick = int24(delta / window); // Round toward negative infinity, as the canonical OracleLibrary. if (delta < 0 && delta % window != 0) avgTick--; twapWad = _tickToMarkWad(avgTick, assetIsToken0, usdgWadFactor); ok = twapWad != 0; } catch { return (false, 0); } } /// @dev USD (wad) cost of pushing the pool's asset price up 1% in one /// block against in-range liquidity — the §6.4 MIN_POOL_DEPTH /// displacement bar, computable from `liquidity()` and `slot0`. function _displacementCostUsdWad(uint128 liq, uint160 sqrtP, bool assetIsToken0, uint256 usdgWadFactor) private pure returns (uint256) { uint256 a = sqrtP; uint256 costRaw; if (assetIsToken0) { // USDG is token1: cost = L × (√P' − √P) / 2^96, √P' = √P·√1.01. uint256 b = a * TurboConstants.SQRT_101_WAD / DeskMath.WAD; costRaw = FixedPointMath.mulDiv(liq, b - a, 1 << 96); } else { // USDG is token0: asset price up 1% ⇒ √P down by 1/√1.01; // cost = L × 2^96 × (√P − √P') / (√P·√P'). uint256 b = a * DeskMath.WAD / TurboConstants.SQRT_101_WAD; if (b == 0) return 0; costRaw = FixedPointMath.mulDiv(FixedPointMath.mulDiv(liq, 1 << 96, b), a - b, a); } return costRaw * usdgWadFactor; } /// @dev Average tick → USD (wad) price of one whole asset. The pool is /// asset/USDG (constructor-validated); decimals: asset 18, USDG 6. function _tickToMarkWad(int24 avgTick, bool assetIsToken0, uint256 usdgWadFactor) private pure returns (uint256) { uint256 sqrtP = TickMath.getSqrtRatioAtTick(avgTick); uint256 p1p0Wad = FixedPointMath.mulDiv(FixedPointMath.mulDiv(sqrtP, sqrtP, 1 << 96), DeskMath.WAD, 1 << 96); if (p1p0Wad == 0) return 0; if (assetIsToken0) return p1p0Wad * usdgWadFactor; return FixedPointMath.mulDiv(DeskMath.WAD * usdgWadFactor, DeskMath.WAD, p1p0Wad); } // ═══════════════════════ Round proofs (§4/§5.1) ═════════════════════════ /// @notice A valid historical round for the §4 proofs, priced through /// the series' uiMultiplier snapshot. function provenRound(address feed, uint80 roundId, uint256 baseUiMultiplier) private view returns (uint256 answerWad, uint256 updatedAt) { (, int256 answer,, uint256 upd,) = ITurboFeed(feed).getRoundData(roundId); if (answer <= 0 || upd == 0) revert ITurboDesk.InvalidRound(roundId); answerWad = DeskMath.feedAnswerToWad(uint256(answer), ITurboFeed(feed).decimals(), baseUiMultiplier); updatedAt = upd; } /// @notice §5.1 first-after proof for `settle`: every earlier round /// at/after expiry must have printed off-session (the feed's /// rare off-hours prints are skipped); the walk back is bounded /// and fails closed on a phase boundary. function assertFirstAfterExpiry(address feed, address adapter, uint64 expiry, uint80 roundId) private view { uint80 pid = roundId; for (uint256 steps = 0; steps < TurboConstants.MAX_SETTLE_WALK; steps++) { if (pid == 0) return; // beginning of feed history pid--; (bool ok, int256 pAnswer, uint256 pUpdatedAt) = _tryRound(ITurboFeed(feed), pid); if (!ok || pAnswer <= 0 || pUpdatedAt == 0) { // Phase boundary / invalid history — unprovable. Fail closed // (§5.2's VOID path is the eventual escape). revert ITurboDesk.NotFirstRoundAfterExpiry(roundId); } if (pUpdatedAt < expiry) return; // proven first if (ITurboFeedAdapter(adapter).sessionOpen(pUpdatedAt)) { revert ITurboDesk.NotFirstRoundAfterExpiry(roundId); } // off-session print ≥ expiry: skip it and keep walking } revert ITurboDesk.SettleWalkTooDeep(); } /// @notice The v2.6 recent-round guard leg shared by buy and cashOut: /// reverts if the LATEST or the immediately previous Chainlink /// round (since series creation) printed through K. function checkRecentRounds(address feed, uint64 createdAt, uint256 strikeWad, bool isCall, uint256 baseUiMultiplier) external view { ITurboFeed f = ITurboFeed(feed); (uint80 rid, int256 answer,, uint256 updatedAt,) = f.latestRoundData(); uint8 dec = f.decimals(); if (_breachRound(answer, updatedAt, createdAt, strikeWad, isCall, dec, baseUiMultiplier)) { revert ITurboDesk.RecentRoundBreached(rid); } if (rid == 0) return; // Phase boundary: no previous round to consult (_tryRound → !ok). (bool ok, int256 pAnswer, uint256 pUpdatedAt) = _tryRound(f, rid - 1); if (ok && _breachRound(pAnswer, pUpdatedAt, createdAt, strikeWad, isCall, dec, baseUiMultiplier)) { revert ITurboDesk.RecentRoundBreached(rid - 1); } } function _tryRound(ITurboFeed f, uint80 id) private view returns (bool ok, int256 answer, uint256 updatedAt) { try f.getRoundData(id) returns (uint80, int256 a, uint256, uint256 u, uint80) { return (true, a, u); } catch { return (false, 0, 0); } } function _breachRound( int256 answer, uint256 updatedAt, uint64 createdAt, uint256 strikeWad, bool isCall, uint8 dec, uint256 baseUiMultiplier ) private pure returns (bool) { if (answer <= 0 || updatedAt == 0 || updatedAt < createdAt) { return false; } uint256 wad = DeskMath.feedAnswerToWad(uint256(answer), dec, baseUiMultiplier); return isCall ? wad <= strikeWad : wad >= strikeWad; } /// @notice Opportunistic Chainlink read for the desk's per-asset /// snapshot (the §5.2 VOID fallback); never reverts. Returns the /// RAW feed answer as a wad — deliberately WITHOUT any /// uiMultiplier (the snap is per ASSET while multiplier /// snapshots are per SERIES; {voidLeg} applies the series' /// `baseUiMultiplier` at use time, Q43). function snapFeed(address feed) external view returns (uint256 markWad, uint256 updatedAt) { (bool ok, int256 answer, uint256 upd) = _tryLatest(ITurboFeed(feed)); if (!ok || answer <= 0 || upd == 0) return (0, 0); return (DeskMath.feedAnswerToWad(uint256(answer), ITurboFeed(feed).decimals(), DeskMath.WAD), upd); } function _tryLatest(ITurboFeed f) private view returns (bool ok, int256 answer, uint256 updatedAt) { try f.latestRoundData() returns (uint80, int256 a, uint256, uint256 u, uint80) { return (true, a, u); } catch { return (false, 0, 0); } } /// @notice v1.1 (2026-08-18): true when Chainlink is the AUTHORITATIVE /// rung-1 oracle right now (session open AND the latest round is /// fresh, ≤ FEED_MAX_AGE_ACTIVE) and that round does NOT breach K — /// i.e. the honest feed proves the series alive. Only then may it /// VETO the rung-2 pool knock: an in-session manipulated pool /// cannot overrule a fresh honest feed (the manufactured-knock /// fix). The session gate is load-bearing — OFF-HOURS the frozen /// close is NOT a live proof of life and the §4 pool checkpoint /// kill must work exactly as before (rung 2 is the intended /// oracle), so this returns false whenever the market is closed or /// the mark is stale. A fresh round that ITSELF breaches also /// returns false: `liquidate(roundId)` handles that kill and the /// pool agrees. function freshRoundProvesAlive( address adapter, address feed, bool isCall, uint256 strikeWad, uint256 baseUiMultiplier ) public view returns (bool) { if (!ITurboFeedAdapter(adapter).sessionOpen(block.timestamp)) return false; (bool ok, int256 answer, uint256 updatedAt) = _tryLatest(ITurboFeed(feed)); if (!ok || answer <= 0 || updatedAt == 0) return false; if (block.timestamp - updatedAt > TurboConstants.FEED_MAX_AGE_ACTIVE) return false; uint256 wad = DeskMath.feedAnswerToWad(uint256(answer), ITurboFeed(feed).decimals(), baseUiMultiplier); return !_isBreach(isCall, wad, strikeWad); } /// @notice §5.6 (v1.1) price ladder, whole selection in one place to keep /// TurboDesk under EIP-170: rung 1 only when the session is open /// AND the mark is fresh (≤ FEED_MAX_AGE_ACTIVE); an in-session /// quiet feed routes to rung 2 (pinned pool TWAP, depth-gated) or /// rung 4 (last print under the 96h bound) — the same containment /// as nights/weekends, so trading is 24/7. Rung 3 is not in code. function servingRung(address adapter, address feed, address asset, PoolCfg memory pc, uint256 usdgWadFactor) public view returns (uint8 rung, uint256 markWad) { if (ITurboFeedAdapter(adapter).sessionOpen(block.timestamp) && markFresh(feed)) { return (1, ITurboFeedAdapter(adapter).priceWad(feed, asset)); } (bool ok, uint256 twapWad) = rung2Twap(pc.pool, pc.assetIsToken0, pc.depthBarUsdWad, usdgWadFactor); if (ok) return (2, twapWad); return (4, ITurboFeedAdapter(adapter).priceWad(feed, asset)); } /// @notice v1.1 rung-1 freshness: the feed's latest round is ≤ /// FEED_MAX_AGE_ACTIVE old. Lives here (not on the desk) to keep /// TurboDesk under the EIP-170 limit. A bricked feed reads /// not-fresh (rung 2/4 handles it) rather than reverting the ladder. function markFresh(address feed) public view returns (bool) { try ITurboFeed(feed).latestRoundData() returns (uint80, int256, uint256, uint256 updatedAt, uint80) { return block.timestamp - updatedAt <= TurboConstants.FEED_MAX_AGE_ACTIVE; } catch { return false; } } /// @dev v1.1 freshness gate for the house-side legs (`createChecks`, /// `convert`): the latest round must be ≤ FEED_MAX_AGE_ACTIVE old. function _requireFreshMark(address feed) private view { (,,, uint256 updatedAt,) = ITurboFeed(feed).latestRoundData(); if (block.timestamp - updatedAt > TurboConstants.FEED_MAX_AGE_ACTIVE) { revert ITurboDesk.FreshMarkRequired(updatedAt, TurboConstants.FEED_MAX_AGE_ACTIVE); } } // ═════════════════════════ Pricing (§3.2/§3.4/§3.7) ═════════════════════ /// @dev One quote's inputs (stack relief): side, terms, size, and the /// serving rung's mark. struct Quote { bool isCall; uint256 strikeWad; uint256 unitsPerCard; uint256 count; uint8 rung; uint256 markWad; uint256 usdgWadFactor; } /// @notice Buy pricing (§3.2/§3.7): premium = value × (1 + h) × /// (1 + ENTRY_SPREAD) rounded up to raw USDG; the 5% open fee is /// charged on the BANDED premium `value × (1 + h)` — the quoted /// number on the ticket — never on the spread (human 2026-08-17). function buyPrice(Quote memory q) public pure returns (uint256 premiumRaw, uint256 feeRaw) { if (q.count == 0) revert ITurboDesk.ZeroCount(); uint256 valueWad = _intrinsicWad(q, q.count); if (valueWad == 0 || _intrinsicWad(q, 1) == 0) revert ITurboDesk.ZeroValueCard(); uint256 h = haircutBps(q.rung, q.isCall, q.markWad, q.strikeWad); uint256 bandedWad = FixedPointMath.mulDiv(valueWad, TurboConstants.BPS + h, TurboConstants.BPS); uint256 premiumWad = FixedPointMath.mulDiv(bandedWad, TurboConstants.BPS + TurboConstants.ENTRY_SPREAD_BPS, TurboConstants.BPS); premiumRaw = FixedPointMath.mulDivUp(premiumWad, 1, q.usdgWadFactor); feeRaw = TurboConstants.feeFor(FixedPointMath.mulDivUp(bandedWad, 1, q.usdgWadFactor)); } /// @notice Cash-out gross payout (§3.2/§3.4): value × (1 − h) × /// (1 − EXIT_SPREAD), paid as stock units (CALL, ÷ mark) or raw /// USDG (PUT). Strictly inside the reservation (I-6). function cashOutGross(Quote memory q) public pure returns (uint256 gross) { if (q.count == 0) revert ITurboDesk.ZeroCount(); uint256 valueWad = _intrinsicWad(q, q.count); uint256 h = haircutBps(q.rung, q.isCall, q.markWad, q.strikeWad); uint256 paidWad = FixedPointMath.mulDiv( FixedPointMath.mulDiv(valueWad, TurboConstants.BPS - h, TurboConstants.BPS), TurboConstants.BPS - TurboConstants.EXIT_SPREAD_BPS, TurboConstants.BPS ); if (q.isCall) { gross = FixedPointMath.mulDiv(paidWad, DeskMath.WAD, q.markWad); if (gross >= q.unitsPerCard * q.count) revert ITurboDesk.PayoutExceedsReservation(); } else { // I-13: a zero mark must fail closed, never pay the reservation. if (q.markWad == 0) revert ITurboDesk.MarkThroughStrike(0, q.strikeWad); gross = paidWad / q.usdgWadFactor; uint256 perCard = _putPerCardReserveRaw(q.unitsPerCard, q.strikeWad, q.usdgWadFactor); if (gross >= perCard * q.count) revert ITurboDesk.PayoutExceedsReservation(); } } /// @dev Intrinsic value (USD wad) of `count` cards, floored at zero on /// both sides (§3.2/§3.4). function _intrinsicWad(Quote memory q, uint256 count) private pure returns (uint256) { uint256 dist; if (q.isCall) dist = q.markWad > q.strikeWad ? q.markWad - q.strikeWad : 0; else dist = q.markWad < q.strikeWad ? q.strikeWad - q.markWad : 0; return FixedPointMath.mulDiv(q.unitsPerCard * count, dist, DeskMath.WAD); } /// @notice §3.2 haircut ladder: 0 on rung 1; min(L_eff × band, cap) with /// the live band on rung 2 and the wide band on rung 4. The cap /// binds on EVERY rung (v2.6) so a living card always quotes /// above zero. function haircutBps(uint8 rung, bool isCall, uint256 markWad, uint256 strikeWad) public pure returns (uint256) { if (rung == 1) return 0; uint256 dist = isCall ? (markWad > strikeWad ? markWad - strikeWad : 0) : (markWad < strikeWad ? strikeWad - markWad : 0); if (dist == 0) return TurboConstants.OFF_HAIRCUT_MAX_BPS; uint256 band = rung == 2 ? TurboConstants.OFF_MARK_BAND_LIVE_BPS : TurboConstants.OFF_MARK_BAND_BPS; uint256 h = FixedPointMath.mulDiv(markWad, band, dist); return h > TurboConstants.OFF_HAIRCUT_MAX_BPS ? TurboConstants.OFF_HAIRCUT_MAX_BPS : h; } /// @notice USD (wad) value of a gross payout at the closing mark — the /// §3.7 "proceeds" the performance fee is measured on. function proceedsUsdWad(bool isCall, uint256 gross, uint256 markWad, uint256 usdgWadFactor) public pure returns (uint256) { if (isCall) return FixedPointMath.mulDiv(gross, markWad, DeskMath.WAD); return gross * usdgWadFactor; } /// @notice Performance fee in payout-asset terms (§3.7): 5% × /// max(proceeds − basis, 0), converted at the closing mark. /// Bounded at 5% of the payout (zero basis), so the payout stays /// inside the reservation (I-6). function perfFeeOnClose(bool isCall, uint256 gross, uint256 markWad, uint256 basisRaw, uint256 usdgWadFactor) public pure returns (uint256) { uint256 proceeds = proceedsUsdWad(isCall, gross, markWad, usdgWadFactor); uint256 basisWad = basisRaw * usdgWadFactor; if (proceeds <= basisWad) return 0; uint256 feeUsdWad = FixedPointMath.mulDiv(proceeds - basisWad, TurboConstants.PERF_FEE_BPS, TurboConstants.BPS); if (isCall) return FixedPointMath.mulDiv(feeUsdWad, DeskMath.WAD, markWad); return feeUsdWad / usdgWadFactor; } /// @notice The PUT reservation per card (§3.4): units × K in raw USDG, /// rounded UP once so reserve and release always agree. function putPerCardReserveRaw(ITurboDesk.Series storage s, uint256 usdgWadFactor) public view returns (uint256) { return _putPerCardReserveRaw(s.unitsPerCard, s.strikeWad, usdgWadFactor); } /// @notice The board row's live numbers (§4 views): haircut in force, /// effective leverage (max-uint at/through the bar) and /// distance-to-K in bps of the mark. function liveStats(ITurboDesk.Series storage s, uint8 rung, uint256 markWad) external view returns (uint256 haircut, uint256 effLeverageWad, uint256 distanceBps) { bool isCall = s.side == ITurboDesk.Side.CALL; haircut = haircutBps(rung, isCall, markWad, s.strikeWad); uint256 dist = isCall ? (markWad > s.strikeWad ? markWad - s.strikeWad : 0) : (markWad < s.strikeWad ? s.strikeWad - markWad : 0); effLeverageWad = dist == 0 ? type(uint256).max : FixedPointMath.mulDiv(markWad, DeskMath.WAD, dist); distanceBps = markWad == 0 ? 0 : FixedPointMath.mulDiv(dist, TurboConstants.BPS, markWad); } /// @notice One-call cash-out quote for a holder (§3.7): gross at the /// serving mark, then the performance fee against the wallet's /// average basis (peeked, not drawn). function quoteClose(ITurboDesk.Series storage s, ITurboDesk.Basis storage basis, Quote memory q) external view returns (uint256 netOut, uint256 perfFee) { uint256 gross = cashOutGross(q); uint256 cb = q.count < basis.count ? q.count : basis.count; uint256 basisRaw = cb == 0 ? 0 : basis.costUsdgRaw * cb / basis.count; perfFee = perfFeeOnClose(q.isCall, gross, q.markWad, basisRaw, q.usdgWadFactor); if (perfFee > gross) perfFee = gross; netOut = gross - perfFee; } function _putPerCardReserveRaw(uint256 unitsPerCard, uint256 strikeWad, uint256 usdgWadFactor) private pure returns (uint256) { return FixedPointMath.mulDivUp(unitsPerCard, strikeWad, DeskMath.WAD * usdgWadFactor); } /// @notice §3.3.2 rung-4 window cap formula (human 2026-08-17): /// max(1, floor(remaining × OFF_HOURS_CAP_BPS)) — a strict floor /// would zero every sub-4-card tranche. function windowCap(uint256 remaining) public pure returns (uint256) { uint256 cap = remaining * TurboConstants.OFF_HOURS_CAP_BPS / TurboConstants.BPS; return cap == 0 && remaining != 0 ? 1 : cap; } /// @notice Rung-4 capacity left in the current off-hours window (§4 /// views). Before the window's first buy the cap is a preview of /// its snapshot. function windowLeft(ITurboDesk.Series storage s, address feed) external view returns (uint256) { if (s.state != ITurboDesk.SeriesState.OPEN) return 0; (uint80 rid,,,,) = ITurboFeed(feed).latestRoundData(); if (s.offHoursWindowId != rid) return windowCap(uint256(s.maxCards) - s.sold); return uint256(s.windowCapCards) - s.soldInWindow; } // ═════════════════════ Operation legs (desk storage in) ═════════════════ /// @dev Bundled buy inputs (stack relief). struct BuyParams { address feed; uint256 count; uint8 rung; uint256 markWad; uint256 usdgWadFactor; } /// @notice The buy leg (§3.2/§3.6): rung-4 window cap, alive + §3.1 /// drift guards, pricing, full reservation from the side-correct /// pot, premium credit (CALL → conversion bucket, PUT → put pot /// directly), fee split, basis write, series counters. The desk /// pulls the USDG and mints after this returns. function buyLeg( ITurboDesk.Series storage s, ITurboDesk.AssetBook storage book, ITurboDesk.UsdgFees storage fees, ITurboDesk.Basis storage basis, BuyParams memory p ) external returns (uint256 premiumRaw, uint256 feeRaw) { // The wide-band window cap binds on rung 4 only (§5.6). if (p.rung == 4) _consumeWindow(s, p.feed, p.count); bool isCall = s.side == ITurboDesk.Side.CALL; uint256 strike = s.strikeWad; // The serving mark must leave the card alive (§3.2: the desk never // sells a card at or through the bar). if (isCall ? p.markWad <= strike : p.markWad >= strike) { revert ITurboDesk.MarkThroughStrike(p.markWad, strike); } // §3.1 drift guard, buy only: a "25X" badge stops selling below // LEV_BADGE_FLOOR of its listed leverage. Exits untouched. { uint256 dist = isCall ? p.markWad - strike : strike - p.markWad; uint256 effWad = FixedPointMath.mulDiv(p.markWad, DeskMath.WAD, dist); uint256 floorWad = s.listLeverageWad * TurboConstants.LEV_BADGE_FLOOR_BPS / TurboConstants.BPS; if (effWad < floorWad) revert ITurboDesk.LeverageDrifted(effWad, floorWad); } (premiumRaw, feeRaw) = buyPrice( Quote({ isCall: isCall, strikeWad: strike, unitsPerCard: s.unitsPerCard, count: p.count, rung: p.rung, markWad: p.markWad, usdgWadFactor: p.usdgWadFactor }) ); // Full reservation at sale (§2.4/§3.4): CALL locks the units from // the equity pot; PUT locks units × K raw USDG from the put pot. // Premium: CALL → the per-asset conversion bucket; PUT → straight // into the put pot (§3.4 — no conversion leg). Spread income rides // inside the premium, never the fee buckets (§3.7). if (isCall) { uint256 needed = s.unitsPerCard * p.count; if (needed > book.potUnits) revert ITurboDesk.InsufficientPot(needed, book.potUnits); book.potUnits -= needed; book.reservedUnits += needed; book.premiumUsdg += premiumRaw; } else { uint256 neededRaw = _putPerCardReserveRaw(s.unitsPerCard, strike, p.usdgWadFactor) * p.count; if (neededRaw > book.putPotUsdg) { revert ITurboDesk.InsufficientPot(neededRaw, book.putPotUsdg); } book.putPotUsdg = book.putPotUsdg - neededRaw + premiumRaw; book.putReservedUsdg += neededRaw; } _splitUsdgFee(fees, feeRaw); // §3.7 basis ledger: the FULL price paid (value + spread + fee). basis.costUsdgRaw += premiumRaw + feeRaw; basis.count += p.count; s.premiumUsdgRaw += premiumRaw; s.sold += uint32(p.count); s.outstanding += uint32(p.count); } /// @notice Rung-4 per-window purchase cap (§3.3.2): window id derives /// from the feed's last in-session round (no wall clock), the /// cap snapshots remaining capacity at the window's first buy, /// and it resets exactly once when the next session's first /// round prints. function _consumeWindow(ITurboDesk.Series storage s, address feed, uint256 count) private { (uint80 rid,,,,) = ITurboFeed(feed).latestRoundData(); if (s.offHoursWindowId != rid) { s.offHoursWindowId = rid; s.soldInWindow = 0; s.windowCapCards = uint32(windowCap(uint256(s.maxCards) - s.sold)); } uint256 left = uint256(s.windowCapCards) - s.soldInWindow; if (count > left) revert ITurboDesk.OffHoursWindowCap(count, left); s.soldInWindow += uint32(count); } /// @dev Bundled close inputs (stack relief). `gross` is in payout-asset /// terms; `markWad` is the closing mark the performance fee /// converts at. struct CloseParams { uint256 count; uint256 gross; uint256 markWad; uint256 usdgWadFactor; } /// @notice Shared close leg for cashOut/claimExpiry (§3.7): draws the /// wallet's average basis (cards beyond the bought count arrived /// by transfer and carry zero basis — never a revert), takes the /// performance fee, releases the reservation, splits the fee. function closeLeg( ITurboDesk.Series storage s, ITurboDesk.AssetBook storage book, ITurboDesk.UsdgFees storage fees, ITurboDesk.Basis storage basis, CloseParams memory p ) external returns (uint256 net, uint256 perfFee) { uint256 cb = p.count < basis.count ? p.count : basis.count; uint256 basisRaw; if (cb != 0) { basisRaw = basis.costUsdgRaw * cb / basis.count; basis.costUsdgRaw -= basisRaw; basis.count -= cb; } bool isCall = s.side == ITurboDesk.Side.CALL; perfFee = perfFeeOnClose(isCall, p.gross, p.markWad, basisRaw, p.usdgWadFactor); if (perfFee > p.gross) perfFee = p.gross; // dust guard; fee ≤ 5% of gross net = p.gross - perfFee; releaseReservation(s, book, p.count, p.gross, p.usdgWadFactor); if (perfFee != 0) { if (isCall) { uint256 sleeveCut = perfFee * TurboConstants.SLEEVE_FEE_BPS / TurboConstants.FEE_BPS; book.feeSleeveTok += sleeveCut; book.feeManagerTok += perfFee - sleeveCut; } else { _splitUsdgFee(fees, perfFee); } } } /// @notice Releases `count` cards' reservation, paying `grossOut` of it /// onward and returning the remainder to the SIDE-CORRECT pot — /// call-side stock can never fund a put payout or vice versa /// (I-13). function releaseReservation( ITurboDesk.Series storage s, ITurboDesk.AssetBook storage book, uint256 count, uint256 grossOut, uint256 usdgWadFactor ) public { if (count == 0) return; if (s.side == ITurboDesk.Side.CALL) { uint256 rel = s.unitsPerCard * count; book.reservedUnits -= rel; book.potUnits += rel - grossOut; } else { uint256 rel = _putPerCardReserveRaw(s.unitsPerCard, s.strikeWad, usdgWadFactor) * count; book.putReservedUsdg -= rel; book.putPotUsdg += rel - grossOut; } } /// @notice The §4 round-proof liquidation: ANY breaching round since /// series creation (and before expiry — the first-after round /// belongs to `settle`, §5.1) kills the series whenever the /// proof is presented. function liquidateByRound( ITurboDesk.Series storage s, ITurboDesk.AssetBook storage book, address feed, uint80 roundId, uint256 usdgWadFactor ) external returns (uint256 released) { (uint256 answerWad, uint256 updatedAt) = provenRound(feed, roundId, s.baseUiMultiplier); if (updatedAt < s.createdAt) revert ITurboDesk.RoundBeforeCreation(roundId); if (updatedAt >= s.expiry) revert ITurboDesk.RoundNotBeforeExpiry(roundId); if (!_isBreach(s.side == ITurboDesk.Side.CALL, answerWad, s.strikeWad)) { revert ITurboDesk.NotBreached(); } released = _knockLeg(s, book, roundId, usdgWadFactor); } /// @dev Bundled rung-2 pool pin (stack relief). struct PoolCfg { address pool; bool assetIsToken0; uint256 depthBarUsdWad; } /// @notice §4 checkpoint step 2: the checkpoint has persisted /// LIQ_PERSIST and the rung-2 mark is still through K now → /// KNOCKED. Reads the pool directly (no serving-rung /// requirement — §4's condition is on the rung-2 mark itself). function liquidateByCheckpoint( ITurboDesk.Series storage s, ITurboDesk.AssetBook storage book, PoolCfg memory pc, address adapter, address feed, uint256 usdgWadFactor ) external returns (uint256 released) { uint64 at = s.knockCheckpointAt; if (at == 0) revert ITurboDesk.NoCheckpoint(); if (block.timestamp < uint256(at) + TurboConstants.LIQ_PERSIST) { revert ITurboDesk.PersistNotMet(at); } // v1.1 (2026-08-18): a fresh IN-SESSION Chainlink round proving the // series alive VETOES the pool kill — a manipulated in-session-quiet // TWAP can never overrule the honest feed. Off-hours or stale → this // is false → the pool remains the oracle exactly as before (§4 design). if (freshRoundProvesAlive(adapter, feed, s.side == ITurboDesk.Side.CALL, s.strikeWad, s.baseUiMultiplier)) { revert ITurboDesk.ChainlinkProvesAlive(); } (bool ok, uint256 twapWad) = rung2Twap(pc.pool, pc.assetIsToken0, pc.depthBarUsdWad, usdgWadFactor); if (!ok) revert ITurboDesk.Rung2Unavailable(); if (!_isBreach(s.side == ITurboDesk.Side.CALL, twapWad, s.strikeWad)) { revert ITurboDesk.NotBreached(); } released = _knockLeg(s, book, 0, usdgWadFactor); } /// @dev The bar test, side-aware (§3.2/§3.4): CALL dies at/below K, PUT /// dies at/above K. function _isBreach(bool isCall, uint256 markWad, uint256 strikeWad) private pure returns (bool) { return isCall ? markWad <= strikeWad : markWad >= strikeWad; } /// @notice Terminal knock (§3.2 all-or-nothing): the WHOLE reservation /// returns to the pot in this tx; nothing remains claimable by /// anyone. KNOCKED never un-knocks (I-4). function _knockLeg( ITurboDesk.Series storage s, ITurboDesk.AssetBook storage book, uint80 roundId, uint256 usdgWadFactor ) private returns (uint256 released) { released = s.side == ITurboDesk.Side.CALL ? s.unitsPerCard * s.outstanding : _putPerCardReserveRaw(s.unitsPerCard, s.strikeWad, usdgWadFactor) * s.outstanding; s.state = ITurboDesk.SeriesState.KNOCKED; s.liqRoundId = roundId; s.knockCheckpointAt = 0; releaseReservation(s, book, s.outstanding, 0, usdgWadFactor); } /// @notice The whole settle path (§5.1): the round proof (first valid /// IN-SESSION round at/after expiry — rung 1 only, v2.6), then /// the per-card entitlement at M — CALL `units × max(M − K, 0) /// / M` in stock, PUT `units × max(K − M, 0)` in raw USDG — then /// EXPIRED. When nothing is claimable the whole reservation /// returns now rather than stranding. function settleAll( ITurboDesk.Series storage s, ITurboDesk.AssetBook storage book, address feed, address adapter, uint80 roundId, uint256 usdgWadFactor ) external returns (uint256 answerWad, uint256 perCard) { uint256 updatedAt; (answerWad, updatedAt) = provenRound(feed, roundId, s.baseUiMultiplier); if (updatedAt < s.expiry) revert ITurboDesk.RoundBeforeExpiry(roundId); if (!ITurboFeedAdapter(adapter).sessionOpen(updatedAt)) { revert ITurboDesk.RoundOffSession(roundId); } assertFirstAfterExpiry(feed, adapter, s.expiry, roundId); perCard = _settleLeg(s, book, roundId, answerWad, usdgWadFactor); } function _settleLeg( ITurboDesk.Series storage s, ITurboDesk.AssetBook storage book, uint80 roundId, uint256 answerWad, uint256 usdgWadFactor ) private returns (uint256 perCard) { if (s.side == ITurboDesk.Side.CALL) { if (answerWad > s.strikeWad) { perCard = FixedPointMath.mulDiv(s.unitsPerCard, answerWad - s.strikeWad, answerWad); } } else { if (answerWad < s.strikeWad) { perCard = FixedPointMath.mulDiv(s.unitsPerCard, s.strikeWad - answerWad, DeskMath.WAD * usdgWadFactor); } } s.state = ITurboDesk.SeriesState.EXPIRED; s.settleRoundId = roundId; s.settleMarkWad = answerWad; s.settlePerCard = perCard; s.knockCheckpointAt = 0; if (perCard == 0) releaseReservation(s, book, s.outstanding, 0, usdgWadFactor); } /// @notice The VOID leg (§5.2/§5.3), the guaranteed degraded-state exit. /// Two grace triggers, whichever the desk is in: /// - **Feed death** (`liveMultiplier == baseUiMultiplier`): /// SETTLE_GRACE of IN-SESSION quiet since the last known /// Chainlink print → VOID. /// - **uiMultiplier drift** (`liveMultiplier != baseUiMultiplier`, /// finding-1): the feed keeps printing FRESH through a /// dividend-style drift, so the quiet clock never trips; the /// grace is instead SETTLE_GRACE of in-session time since /// `recordDrift` first observed the drift (`s.driftOnsetAt`). /// The onset must have been recorded first (DriftGraceNotStarted /// otherwise) — a successful recording is what persists the /// clock a revert could not. /// Both price the refund mark through the series' multiplier /// SNAPSHOT so a fail-closed corporate action still reaches the /// bounded refund path. function voidLeg(ITurboDesk.Series storage s, address feed, uint256 snapMarkWad, uint256 snapUpdatedAt) external returns (uint256 lastMarkWad) { uint256 liveMultiplier = IUiMultiplierToken(s.asset).uiMultiplier(); uint256 lastUpdatedAt; (bool ok, int256 answer, uint256 upd) = _tryLatest(ITurboFeed(feed)); if (ok && answer > 0 && upd != 0) { lastMarkWad = DeskMath.feedAnswerToWad(uint256(answer), ITurboFeed(feed).decimals(), s.baseUiMultiplier); lastUpdatedAt = upd; } else { if (snapUpdatedAt == 0) revert ITurboDesk.InvalidRound(0); // The snap stores the RAW answer-wad ({snapFeed}); price it // through THIS series' multiplier snapshot (Q43). lastMarkWad = FixedPointMath.mulDiv(snapMarkWad, s.baseUiMultiplier, DeskMath.WAD); lastUpdatedAt = snapUpdatedAt; } if (liveMultiplier != s.baseUiMultiplier) { // §5.3 drift branch: grace runs off the drift-onset clock. uint256 onset = s.driftOnsetAt; if (onset == 0) revert ITurboDesk.DriftGraceNotStarted(); uint256 elapsed = TurboConstants.inSessionSecondsBetween(onset, block.timestamp); if (elapsed < TurboConstants.SETTLE_GRACE) { revert ITurboDesk.GraceNotElapsed(elapsed, TurboConstants.SETTLE_GRACE); } } else { // §5.2 feed-death branch: grace runs off the last-print quiet. uint256 quiet = TurboConstants.inSessionSecondsBetween(lastUpdatedAt, block.timestamp); if (quiet < TurboConstants.SETTLE_GRACE) { revert ITurboDesk.GraceNotElapsed(quiet, TurboConstants.SETTLE_GRACE); } } s.state = ITurboDesk.SeriesState.VOID; s.settleMarkWad = lastMarkWad; s.knockCheckpointAt = 0; s.driftOnsetAt = 0; } /// @notice The refund leg (§5.2): net premium in-kind at the last mark, /// capped by the reservation. Per-card premium is the series /// average (all cards in a series are identical; the desk is /// blind to transfers). CALL refunds pay stock; PUT refunds pay /// raw USDG. No performance fee: a refund is not a close (§3.7). function refundLeg( ITurboDesk.Series storage s, ITurboDesk.AssetBook storage book, uint256 count, uint256 usdgWadFactor ) external returns (uint256 refunded) { uint256 avgPremiumRaw = s.premiumUsdgRaw / s.sold; if (s.side == ITurboDesk.Side.CALL) { uint256 perCardTok = FixedPointMath.mulDiv(avgPremiumRaw * usdgWadFactor, DeskMath.WAD, s.settleMarkWad); if (perCardTok > s.unitsPerCard) perCardTok = s.unitsPerCard; refunded = perCardTok * count; } else { uint256 cap = _putPerCardReserveRaw(s.unitsPerCard, s.strikeWad, usdgWadFactor); refunded = (avgPremiumRaw > cap ? cap : avgPremiumRaw) * count; } releaseReservation(s, book, count, refunded, usdgWadFactor); } function _splitUsdgFee(ITurboDesk.UsdgFees storage fees, uint256 feeRaw) private { uint256 sleeveCut = feeRaw * TurboConstants.SLEEVE_FEE_BPS / TurboConstants.FEE_BPS; fees.feeSleeve += sleeveCut; fees.feeManager += feeRaw - sleeveCut; } /// @dev Same signature as ITurboDesk.TokenFeesSwept — under delegatecall /// the log carries the desk's address, so consumers see one event. event TokenFeesSwept(address indexed asset, uint256 managerTok, uint256 sleeveTok); // Mirror ITurboDesk's drift events (delegatecall carries the desk address). event DriftRecorded(uint256 indexed seriesId, uint256 multiplier, uint64 at); event DriftCleared(uint256 indexed seriesId, uint256 multiplier); /// @notice §5.3 drift-grace recorder (finding-1), moved off the desk to /// keep TurboDesk under the EIP-170 size limit. Starts the VOID /// grace clock the first time uiMultiplier drift is observed and /// clears it when the multiplier returns to the series snapshot. /// Permissionless; never keeper-dependent. function recordDriftLeg(ITurboDesk.Series storage s, uint256 seriesId) external { uint256 m = IUiMultiplierToken(s.asset).uiMultiplier(); if (m != s.baseUiMultiplier) { if (s.driftOnsetAt != 0) revert ITurboDesk.NoDriftChange(); s.driftOnsetAt = uint64(block.timestamp); emit DriftRecorded(seriesId, m, uint64(block.timestamp)); } else { if (s.driftOnsetAt == 0) revert ITurboDesk.NoDriftChange(); s.driftOnsetAt = 0; emit DriftCleared(seriesId, m); } } /// @notice The sweep leg (§3.7): Manager USDG out, per-asset token /// performance-fee buckets to Manager/Sleeve. Sleeve USDG stays /// put — it converts via `convertSleeveFees` (COINflip pattern). function sweepFeesLeg( mapping(address => ITurboDesk.AssetBook) storage books, ITurboDesk.UsdgFees storage fees, address usdgToken, address manager, address sleeve, address[3] memory assets ) external returns (uint256 mUsdg, uint256 sUsdg) { mUsdg = fees.feeManager; if (mUsdg != 0) { fees.feeManager = 0; if (!IERC20(usdgToken).transfer(manager, mUsdg)) revert ITurboDesk.TransferFailed(); } sUsdg = fees.feeSleeve; for (uint256 i = 0; i < 3; i++) { ITurboDesk.AssetBook storage b = books[assets[i]]; uint256 mTok = b.feeManagerTok; uint256 sTok = b.feeSleeveTok; if (mTok != 0) { b.feeManagerTok = 0; if (!IERC20(assets[i]).transfer(manager, mTok)) { revert ITurboDesk.TransferFailed(); } } if (sTok != 0) { b.feeSleeveTok = 0; if (!IERC20(assets[i]).transfer(sleeve, sTok)) revert ITurboDesk.TransferFailed(); } if (mTok != 0 || sTok != 0) emit TokenFeesSwept(assets[i], mTok, sTok); } } /// @notice The skim leg: strays to the Sleeve. Menu assets are skimmable /// only above every equity bucket, USDG only above the premium / /// put / fee buckets — the desk can never be swept of user or /// house funds. function skimLeg( mapping(address => ITurboDesk.AssetBook) storage books, ITurboDesk.UsdgFees storage fees, address token, address usdgToken, address sleeve, address[3] memory assets ) external returns (uint256 amount) { uint256 bal = IERC20(token).balanceOf(address(this)); uint256 reserved; if (token == assets[0] || token == assets[1] || token == assets[2]) { ITurboDesk.AssetBook storage b = books[token]; reserved = b.potUnits + b.reservedUnits + b.feeManagerTok + b.feeSleeveTok; } else if (token == usdgToken) { for (uint256 i = 0; i < 3; i++) { ITurboDesk.AssetBook storage b = books[assets[i]]; reserved += b.premiumUsdg + b.putPotUsdg + b.putReservedUsdg; } reserved += fees.feeManager + fees.feeSleeve; } if (bal < reserved) revert ITurboDesk.SkimUnderflow(); amount = bal - reserved; if (amount != 0) { if (!IERC20(token).transfer(sleeve, amount)) revert ITurboDesk.TransferFailed(); } } // ═══════════════════════ Series listing checks (§3.1/§4) ════════════════ /// @notice `createSeries` validation off a live IN-SESSION mark (§4 — /// listing K off a frozen close would hand the open a /// pre-arbitraged tranche): strike on the side-correct side of /// the mark, leverage within [LEV_MIN, LEV_MAX], tenor within /// [MIN_TENOR, MAX_TENOR]. function createChecks(address adapter, address feed, address asset, bool isCall, uint256 strikeWad, uint256 expiry) external view returns (uint256 levWad, uint256 markWad) { if (!ITurboFeedAdapter(adapter).sessionOpen(block.timestamp)) { revert ITurboDesk.SessionRequired(); } // v1.1: priceWad's bound is the absolute 96h; listing keeps its own // ≤ FEED_MAX_AGE_ACTIVE freshness gate — K off a stale mark would // hand the open a pre-arbitraged tranche. _requireFreshMark(feed); markWad = ITurboFeedAdapter(adapter).priceWad(feed, asset); if (isCall ? strikeWad >= markWad : strikeWad <= markWad) revert ITurboDesk.BadStrike(); uint256 dist = isCall ? markWad - strikeWad : strikeWad - markWad; levWad = FixedPointMath.mulDiv(markWad, DeskMath.WAD, dist); if (levWad < TurboConstants.LEV_MIN_WAD || levWad > TurboConstants.LEV_MAX_WAD) { revert ITurboDesk.BadLeverage(levWad); } if (expiry < block.timestamp + TurboConstants.MIN_TENOR || expiry > block.timestamp + TurboConstants.MAX_TENOR) revert ITurboDesk.BadTenor(); } // ═══════════════════ Conversion leg (§3.7, keeper) ══════════════════════ /// @dev Bundled parameters for {convert} (stack relief). struct ConvertParams { address routerSource; address adapter; address usdg; address asset; address feed; uint256 budget; uint256 minTokensOut; uint256 maxDevBps; uint256 usdgWadFactor; } /// @notice One Rialto USDG → asset conversion: market-open + fresh-feed /// gated, tight oracle floor on the output value (the calldata /// is caller-supplied over house/Sleeve funds). Runs via /// delegatecall, so approvals and the router call are the /// desk's own. function convert(ConvertParams memory p, bytes calldata swapCalldata) external returns (uint256 tokensOut, uint256 consumed) { if (!ITurboFeedAdapter(p.adapter).sessionOpen(block.timestamp)) { revert ITurboDesk.MarketClosed(); } // v1.1: the oracle floor on caller-supplied calldata over house // funds must be measured against a LIVE mark (priceWad alone now // admits up to 96h). _requireFreshMark(p.feed); uint256 markWad = ITurboFeedAdapter(p.adapter).priceWad(p.feed, p.asset); (tokensOut, consumed) = _swap(p.routerSource, p.usdg, p.asset, p.budget, swapCalldata); uint256 floorWad = FixedPointMath.mulDiv(p.budget * p.usdgWadFactor, TurboConstants.BPS - p.maxDevBps, TurboConstants.BPS); if (DeskMath.rwaValueWad(tokensOut, markWad) < floorWad) { revert ITurboDesk.OracleValueTooLow(); } if (tokensOut < p.minTokensOut) revert ITurboDesk.MinOutNotMet(); } /// @dev One Rialto swap (rwa-desk/COINflip pattern): approve the budget, /// call the discovered router with caller-authorized calldata, /// measure what landed; inflow of tokenIn is rejected. function _swap( address routerSourceAddr, address tokenIn, address tokenOut, uint256 budget, bytes calldata swapCalldata ) private returns (uint256 out, uint256 consumed) { address router; try IRouterSource(routerSourceAddr).router() returns (address r) { router = r; } catch { revert ITurboDesk.RouterUnavailable(); } if (router == address(0)) revert ITurboDesk.RouterUnavailable(); uint256 inBefore = IERC20(tokenIn).balanceOf(address(this)); uint256 outBefore = IERC20(tokenOut).balanceOf(address(this)); if (!IERC20(tokenIn).approve(router, budget)) revert ITurboDesk.TransferFailed(); (bool okCall,) = router.call(swapCalldata); if (!okCall) revert ITurboDesk.SwapFailed(); if (!IERC20(tokenIn).approve(router, 0)) revert ITurboDesk.TransferFailed(); out = IERC20(tokenOut).balanceOf(address(this)) - outBefore; uint256 inAfter = IERC20(tokenIn).balanceOf(address(this)); if (inAfter > inBefore) revert ITurboDesk.UnexpectedInflow(); consumed = inBefore - inAfter; } // ═══════════════════════════ Metadata (§3.6b) ═══════════════════════════ /// @notice The on-chain card JSON: series terms straight from state, so /// a card is self-describing in any wallet without an indexer. function buildUri(ITurboDesk.Series storage s, address asset) external view returns (string memory) { // symbol + the state string are built HERE (not on the desk) to keep // TurboDesk under the EIP-170 runtime-size limit. string memory symbol = IERC20Metadata(asset).symbol(); string memory stateStr = s.state == ITurboDesk.SeriesState.OPEN ? "OPEN" : s.state == ITurboDesk.SeriesState.KNOCKED ? "KNOCKED" : s.state == ITurboDesk.SeriesState.EXPIRED ? "EXPIRED" : "VOID"; return string( abi.encodePacked( "data:application/json,{\"name\":\"", symbol, " TURBO ", _toString((s.listLeverageWad + DeskMath.WAD / 2) / DeskMath.WAD), "X ", s.side == ITurboDesk.Side.CALL ? "CALL" : "PUT", "\",\"strikeWad\":\"", _toString(s.strikeWad), "\",\"unitsPerCard\":\"", _toString(s.unitsPerCard), "\",\"expiry\":\"", _toString(uint256(s.expiry)), "\",\"state\":\"", stateStr, "\"}" ) ); } function _toString(uint256 value) private pure returns (string memory) { if (value == 0) return "0"; uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits--; buffer[digits] = bytes1(uint8(48 + value % 10)); value /= 10; } return string(buffer); } }

// SPDX-License-Identifier: AGPL-3.0-only pragma solidity ^0.8.24; import {FixedPointMath} from "../libraries/FixedPointMath.sol"; /// @title DeskMath — every RWA Desk unit conversion, in one place /// @notice specs/rwa-desk.md §4.6 ("bug farm — invariant-tested"). All mixed /// decimals — NET 9-dec, USDG 6-dec, Stock Tokens 18-dec, Chainlink /// 8-dec × ERC-8056 uiMultiplier, WAD prices/backing — are converted /// here with explicit unit-suffixed names, fuzz round-tripped in §11. /// The Loopback build shipped a 1e9 sizing slip a fork test caught; /// this library is deliberately the ONLY place decimals move. /// /// @dev Fee (corrected §4.2, backing-neutral form): the per-fill Treasury fee /// is `mulDivUp(payoutNet9, bHwm−1e18, NET_UNIT·usdgWadFactor)` — i.e. /// `(bHwm − 1) USDG per WHOLE NET`, matching §3.1's backing-neutrality /// proof and §3.2a's worked split. A 1-NET fill at bHwm 4.83 remits 3.83 /// USDG. (The `NET_UNIT` in the denominator is load-bearing — the earlier /// draft's `/1e18` was the "1e9 sizing slip" §4.6 warns about.) library DeskMath { uint256 internal constant WAD = 1e18; uint256 internal constant BPS = 10_000; /// @dev NET has 9 decimals; 1 whole NET = 1e9 base units. uint256 internal constant NET_UNIT = 1e9; /// @notice NET payout (9-dec) for `usdgInRaw` (raw USDG units) at `priceWad` /// (WAD USDG per whole NET). Floors (mirrors depository / §4.2 step /// 2 — the desk is never overpaid in NET). /// payout = usdgInWad · NET_UNIT / priceWad, usdgInWad = raw·factor. function payoutNet9(uint256 usdgInRaw, uint256 usdgWadFactor, uint256 priceWad) internal pure returns (uint256) { return FixedPointMath.mulDiv(usdgInRaw * usdgWadFactor, NET_UNIT, priceWad); } /// @notice Backing-neutrality fee (raw USDG, 6-dec) for a `payoutNet9_` /// payout at high-water backing `bHwmWad`. Rounds UP so the /// Treasury is never underpaid (matches PTeam's strike rounding). /// fee = (bHwm − 1) USDG per WHOLE NET = /// ceil(payoutNet9 · (bHwm − 1e18) / (NET_UNIT · factor)). /// @dev Assumes `bHwmWad ≥ WAD` (backing never below the 1 USDG floor by /// protocol invariant); the desk enforces this before calling. function feeUsdgRaw(uint256 payoutNet9_, uint256 bHwmWad, uint256 usdgWadFactor) internal pure returns (uint256) { uint256 premiumWad = bHwmWad - WAD; if (premiumWad == 0) return 0; return FixedPointMath.mulDivUp(payoutNet9_, premiumWad, NET_UNIT * usdgWadFactor); } /// @notice Desk price (WAD) = TWAP × (1 − discountBps/10_000). §3.2/§4.2. function discountedPriceWad(uint256 twapWad, uint256 discountBps) internal pure returns (uint256) { return twapWad * (BPS - discountBps) / BPS; } /// @notice Hard floor price (WAD) = bHwm × MIN_PREMIUM_WAD / 1e18. §3.2. function floorPriceWad(uint256 bHwmWad, uint256 minPremiumWad) internal pure returns (uint256) { return FixedPointMath.mulDiv(bHwmWad, minPremiumWad, WAD); } /// @notice USD value (WAD) of `rwaOut18` (18-dec Stock Token units) at a /// WAD unit price. §4.2 step 4b oracle sanity. function rwaValueWad(uint256 rwaOut18, uint256 unitPriceWad) internal pure returns (uint256) { return FixedPointMath.mulDiv(rwaOut18, unitPriceWad, WAD); } /// @notice Raw USDG (6-dec) → WAD. function usdgToWad(uint256 raw, uint256 usdgWadFactor) internal pure returns (uint256) { return raw * usdgWadFactor; } /// @notice Chainlink answer (feed-dec) × ERC-8056 uiMultiplier → WAD USD /// unit price (V-2 ANSWERED, §7.5). uiMultiplier is a WAD scalar /// (1e18 = ×1); the feed adapter asserts identity and reverts on /// any other value (corporate-action fail-safe), so no unverified /// multiplier math ever reaches a fill. The math stays isolated in /// the adapter (RwaAdapters.sol) so a verified split multiplier can /// be handled by swapping that contract, not RwaDesk. function feedAnswerToWad(uint256 answer, uint8 feedDecimals, uint256 uiMultiplierWad) internal pure returns (uint256) { uint256 scale = 10 ** (18 - uint256(feedDecimals)); return FixedPointMath.mulDiv(answer * scale, uiMultiplierWad, WAD); } }

// SPDX-License-Identifier: AGPL-3.0-only pragma solidity ^0.8.24; import {DeskMath} from "./DeskMath.sol"; import {RwaConstants} from "./RwaConstants.sol"; /// @notice Resolves the live Rialto RialtoRouter address (specs/rwa-desk.md /// §2/§4.4/§7.5). Router discovery is a LIVENESS convenience, not a /// security boundary — the desk verifies all swap output on-chain /// regardless of which router the source returns. interface IRouterSource { /// @dev Current RialtoRouter. Reverts when the registry is paused; the /// desk maps that revert to a clean halt. function router() external view returns (address); } /// @notice Prices one whole menu equity in WAD USD from its Chainlink feed /// (price) and the token's ERC-8056 uiMultiplier (scale), applying /// market-hours-aware staleness and the uiMultiplier identity fail-safe /// (specs/rwa-desk.md §4.2 step 4b / §4.6 / §7.5). Behind this interface /// so a corporate action can be handled by swapping the implementation /// without touching RwaDesk. interface IRwaFeedAdapter { /// @dev WAD USD price of one whole `token`, from Chainlink `feed`. Reverts /// fail-closed on a zero/negative answer, an incomplete round, a stale /// feed (market-hours-aware), or a token uiMultiplier that is no longer /// identity. The uiMultiplier is read from the TOKEN (ERC-8056), NOT /// the feed — standard Chainlink proxies do not expose it (V-5, /// fork-caught: reading it from the feed reverted every real fill). function priceWad(address feed, address token) external view returns (uint256); } /// @notice Rialto Router Registry surface (V-1 ANSWERED, §7.5): the active /// taker router is `ownerOf(2)` (selector 0x6352211e); the call /// reverts when the registry is paused/uninitialized. interface IRouterRegistry { function ownerOf(uint256 tokenId) external view returns (address); } /// @notice Stock-Token Chainlink price proxy. A standard AggregatorV3 proxy — /// it does NOT expose ERC-8056 uiMultiplier (that lives on the token; /// V-5, fork-caught 2026-07-24). interface IRwaFeed { function decimals() external view returns (uint8); function latestRoundData() external view returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); } /// @notice ERC-8056 uiMultiplier extension on the Stock TOKEN (V-2/V-5, §7.5): /// `uiMultiplier()` reads 1e18 identity today; a corporate action /// (split) posts a non-identity value the adapter fails closed on. interface IUiMultiplierToken { function uiMultiplier() external view returns (uint256); } /// @title RouterSource — Rialto Router Registry discovery (§7.5, V-1 ANSWERED) /// @notice `registry.ownerOf(ROUTER_TOKEN_ID)` is the active taker router /// (docs.rialto.xyz/developers/router-registries.md; cross-validated /// against the quote API's `tx.to`). A paused registry reverts here — /// a free liveness guard the desk treats as a halt. The adapter /// boundary is kept so a registry migration only changes this contract. contract RouterSource is IRouterSource { error ZeroAddress(); IRouterRegistry public immutable registry; uint256 public immutable routerTokenId; constructor(address registry_, uint256 routerTokenId_) { if (registry_ == address(0)) revert ZeroAddress(); registry = IRouterRegistry(registry_); routerTokenId = routerTokenId_; } /// @inheritdoc IRouterSource function router() external view returns (address) { return registry.ownerOf(routerTokenId); } } /// @title RwaFeedAdapter — Chainlink + ERC-8056 pricing (§7.5, V-2 ANSWERED) /// @notice Market-hours-aware staleness (O-5 RESOLVED, reusing the perp's /// proven session logic — perp.md §13.4): the equity feeds are /// us_equities_24/5 and legitimately go quiet nights/weekends, so a /// naive fixed max-age would revert weekend fills. Fails closed only /// when the feed is stale during hours it should be updating; off-hours /// the last close is accepted (the per-fill deviation bound in RwaDesk /// still applies to every fill). /// /// uiMultiplier fail-safe (§7.5): asserts the TOKEN's `uiMultiplier() /// == 1e18` every read and reverts otherwise, so a corporate action /// (split) halts that name's fills until the human verifies the /// multiplier direction and swaps this implementation. The multiplier /// is read from the TOKEN, not the feed — standard Chainlink proxies do /// not expose it (V-5, fork-caught: the earlier feed-side read reverted /// every real fill). No unverified math ships. contract RwaFeedAdapter is IRwaFeedAdapter { error BadFeedPrice(); error StaleFeed(uint256 updatedAt, uint256 maxAge); error UiMultiplierChanged(uint256 got); error IncompleteRound(uint80 roundId, uint80 answeredInRound); /// @inheritdoc IRwaFeedAdapter function priceWad(address feed, address token) external view returns (uint256) { IRwaFeed f = IRwaFeed(feed); (uint80 roundId, int256 answer,, uint256 updatedAt, uint80 answeredInRound) = f.latestRoundData(); if (answer <= 0) revert BadFeedPrice(); // Round completeness: reject a carried-over answer from a prior round // (standard Chainlink hygiene — audit LOW). if (answeredInRound < roundId) revert IncompleteRound(roundId, answeredInRound); uint256 maxAge = sessionOpen(block.timestamp) ? RwaConstants.FEED_MAX_AGE_ACTIVE : RwaConstants.FEED_MAX_AGE_IDLE; if (block.timestamp - updatedAt > maxAge) revert StaleFeed(updatedAt, maxAge); // ERC-8056 uiMultiplier lives on the TOKEN, not the Chainlink proxy // (V-5, §7.5). Identity today; a split posts a non-identity value and // halts that name until the human verifies it and swaps this adapter. uint256 mult = IUiMultiplierToken(token).uiMultiplier(); if (mult != RwaConstants.UI_MULTIPLIER_IDENTITY) revert UiMultiplierChanged(mult); return DeskMath.feedAnswerToWad(uint256(answer), f.decimals(), mult); } /// @notice Whether `timestamp` falls in the conservative "feed should be /// updating" window: weekdays 14:00–20:30 UTC (perp.md §13.4). function sessionOpen(uint256 timestamp) public pure returns (bool) { // Unix epoch day 0 (1970-01-01) was a Thursday; weekday 0 = Monday. uint256 weekday = (timestamp / 1 days + 3) % 7; if (weekday >= 5) return false; // Saturday / Sunday uint256 secondsIntoDay = timestamp % 1 days; return secondsIntoDay >= RwaConstants.SESSION_OPEN_UTC_MIN && secondsIntoDay < RwaConstants.SESSION_CLOSE_UTC_MIN; } } /// @title RwaFeedAdapterV2 — corporate-action-aware Chainlink + ERC-8056 pricing /// @notice V1's identity assert, resolved (V-2's own procedure, verified /// 2026-08-17 against AAPL's first corporate action — the $0.27/sh /// dividend paid 2026-08-13, reinvested on-chain as `uiMultiplier` /// 1e18 → 1.000566080061092436e18): /// /// - The pinned "Robinhood <SYM> / USD" feeds report the PER-SHARE /// price (measured: the AAPL feed matched the real NBBO close to /// −0.2 bps while the multiplier sat +5.66 bps away). /// - One raw token is a claim on `uiMultiplier/1e18` shares /// (ERC-8056), so one whole token is worth /// `feed × uiMultiplier` — exactly `DeskMath.feedAnswerToWad` /// with the live multiplier passed through. /// /// So V2 keeps every hygiene check V1 ran (positive answer, round /// completeness, market-hours-aware staleness) and simply APPLIES the /// multiplier instead of halting on it. Splits and reverse splits are /// handled by the same product: a 2:1 split halves the per-share feed /// and doubles the multiplier. No bound is placed on the multiplier /// beyond nonzero — the desks' oracle deviation gates fail closed if /// feed semantics and multiplier ever disagree at scale, and the /// keeper pages on every multiplier change for a human re-check. contract RwaFeedAdapterV2 is IRwaFeedAdapter { error BadFeedPrice(); error StaleFeed(uint256 updatedAt, uint256 maxAge); error BadUiMultiplier(); error IncompleteRound(uint80 roundId, uint80 answeredInRound); /// @inheritdoc IRwaFeedAdapter function priceWad(address feed, address token) external view returns (uint256) { IRwaFeed f = IRwaFeed(feed); (uint80 roundId, int256 answer,, uint256 updatedAt, uint80 answeredInRound) = f.latestRoundData(); if (answer <= 0) revert BadFeedPrice(); // Round completeness: reject a carried-over answer from a prior round // (standard Chainlink hygiene — audit LOW). if (answeredInRound < roundId) revert IncompleteRound(roundId, answeredInRound); uint256 maxAge = sessionOpen(block.timestamp) ? RwaConstants.FEED_MAX_AGE_ACTIVE : RwaConstants.FEED_MAX_AGE_IDLE; if (block.timestamp - updatedAt > maxAge) revert StaleFeed(updatedAt, maxAge); // ERC-8056 uiMultiplier lives on the TOKEN, not the Chainlink proxy // (V-5, §7.5). Verified per-share feed semantics make this a pure // pass-through into the price; only zero is malformed (it would price // every fill at nothing and the desks would fail their value gates // with a misleading error). uint256 mult = IUiMultiplierToken(token).uiMultiplier(); if (mult == 0) revert BadUiMultiplier(); return DeskMath.feedAnswerToWad(uint256(answer), f.decimals(), mult); } /// @notice Whether `timestamp` falls in the conservative "feed should be /// updating" window: weekdays 14:00–20:30 UTC (perp.md §13.4). function sessionOpen(uint256 timestamp) public pure returns (bool) { // Unix epoch day 0 (1970-01-01) was a Thursday; weekday 0 = Monday. uint256 weekday = (timestamp / 1 days + 3) % 7; if (weekday >= 5) return false; // Saturday / Sunday uint256 secondsIntoDay = timestamp % 1 days; return secondsIntoDay >= RwaConstants.SESSION_OPEN_UTC_MIN && secondsIntoDay < RwaConstants.SESSION_CLOSE_UTC_MIN; } }

// SPDX-License-Identifier: AGPL-3.0-only pragma solidity ^0.8.24; /// @title RwaConstants — RWA Desk ("Real World Bonds") parameters /// @notice Single source of truth for the resolved §13 numbers of /// `specs/rwa-desk.md`. Mirrors the LendingConstants / PerpConstants /// pattern: standalone additive product, its own constant table. /// The immutable, trust-critical economics (`MAX_DISCOUNT_BPS`, /// `MIN_PREMIUM_WAD`, `INVENTORY_HARD_CAP`, `MAX_ORACLE_DEV_BPS`) are /// passed to the desk constructor from these constants by the deploy /// script and frozen there. Feed staleness is NOT a desk immutable — /// it lives in the market-hours-aware feed adapter (§7.5). The /// Manager-settable launch values (`INITIAL_DISCOUNT_BPS`, /// `LAUNCH_INVENTORY_MAX`) are the desk's starting mutable state. library RwaConstants { uint256 internal constant WAD = 1e18; uint256 internal constant BPS = 10_000; /// @dev NET has 9 decimals; 1 whole NET = 1e9 base units. uint256 internal constant NET_UNIT = 1e9; // ── Pricing (specs/rwa-desk.md §3.2, O-2 RESOLVED 2026-07-23) ── /// @dev Manager-settable launch discount vs the PairOracle TWAP (6.5%). uint256 internal constant INITIAL_DISCOUNT_BPS = 650; /// @dev IMMUTABLE flip-safety cap; `setDiscount` reverts above it (7.5%). uint256 internal constant MAX_DISCOUNT_BPS = 750; /// @dev Floor guard (O-3 RESOLVED): fills revert below /// `bHwm × MIN_PREMIUM_WAD / 1e18` (1.20×). uint256 internal constant MIN_PREMIUM_WAD = 1.2e18; // ── Inventory (specs/rwa-desk.md §3.4, O-4 RESOLVED 2026-07-23) ── /// @dev Manager-settable launch inventory ceiling (150 NET). uint256 internal constant LAUNCH_INVENTORY_MAX = 150e9; /// @dev IMMUTABLE ceiling on `inventoryMax`; `setInventoryMax` reverts /// above it (300 NET). Bounds the transient backing dip (§3.1) and /// the stranded-inventory worst case (§3.4). uint256 internal constant INVENTORY_HARD_CAP = 300e9; /// @dev Operational (keeper/frontend only, §5): draw-refill watermark. uint256 internal constant REFILL_WATERMARK = 50e9; // ── Note-array bound (anti-griefing, audit MED) ── /// @dev Max vesting notes per address. `bond()` reverts above it, so a /// third party cannot spray dust notes into a victim's address until /// the full-array `redeem(to)` runs out of gas. 256 is generous for a /// real user (each fill = one note) and kills the spray; the paginated /// `redeem(uint256[])` variant is the escape hatch regardless. uint256 internal constant MAX_NOTES_PER_ADDRESS = 256; // ── Rialto output verification (specs/rwa-desk.md §4.1/§4.4, O-5) ── /// @dev Hard revert gate on the swap-leg value check in bond(): received /// equity value at the Chainlink mark must be ≥ swapAmount × /// (1 − 5%). RESOLVED 2026-07-23 (human): 500 bps, sized to tolerate /// off-hours feed drift (equity feeds freeze nights/weekends while /// Rialto keeps quoting; in-session legit deviation at max fill is /// only +44–66 bps, but weekend gaps can exceed 150). The tighter /// 150-bps figure is a keeper-land off-chain soft alarm, NOT on-chain. /// Applies to EVERY fill, in or out of market hours. uint256 internal constant MAX_ORACLE_DEV_BPS = 500; // ── Feed staleness (O-5 RESOLVED 2026-07-23: market-hours-aware, reusing // the perp's proven logic — specs/rwa-desk.md §7.5, perp.md §13.4). // The equity feeds are us_equities_24/5: they legitimately go quiet // nights/weekends, so a naive fixed max-age would revert weekend fills. // Policy lives in the feed adapter, NOT as a desk immutable. ── /// @dev Conservative "feed should be updating" window: weekdays /// 14:00–20:30 UTC (inside US-equity hours under both EST and EDT, so /// a DST shift never marks a live session stale). uint256 internal constant SESSION_OPEN_UTC_MIN = 14 hours; uint256 internal constant SESSION_CLOSE_UTC_MIN = 20 hours + 30 minutes; /// @dev Max feed age while the session window is open (fail closed on a /// dead feed that should be live). uint256 internal constant FEED_MAX_AGE_ACTIVE = 4 hours; /// @dev Max feed age outside the window (covers the weekend gap; the /// last close is legitimately frozen and still deviation-gated). uint256 internal constant FEED_MAX_AGE_IDLE = 80 hours; // ── Rialto Router Registry discovery (V-1 ANSWERED, §7.5) ── /// @dev The active taker router is `registry.ownerOf(ROUTER_TOKEN_ID)`; /// the call reverts when the registry is paused/uninitialized, which /// the desk treats as a clean halt. uint256 internal constant ROUTER_TOKEN_ID = 2; /// @dev ERC-8056 uiMultiplier identity (V-2 ANSWERED, §7.5): all three /// stock tokens read 1e18 today; the adapter reverts if it ever /// differs (corporate-action fail-safe). uint256 internal constant UI_MULTIPLIER_IDENTITY = 1e18; }