/// @notice Mask constant for identifying sector types.    bytes12 private constant SECTOR_PREFIX_MASK = 0xFF0000000000000000000000;            function isVehicleSector(Sector self) internal pure returns (bool) {        return bytes12(Sector.unwrap(self)) & SECTOR_PREFIX_MASK == VEHICLE_SECTOR_PREFIX;    }

function isVehicleSector(Sector self) internal pure returns (bool) {        return bytes12(Sector.unwrap(self)) == VEHICLE_SECTOR_PREFIX;    }

function _totalAssets() internal view override returns (uint256) {        MultiVehicleStore.Storage storage $ = MultiVehicleStore.getStorage();        return $.accountingEngine.totalAssets() + $.redeemQueue.retrievable();    }

// SPDX-License-Identifier: BUSL-1.1pragma solidity >=0.8.33;
import {IVehicle} from "src/steam/IVehicle.sol";import {Roles} from "src/libs/Roles.sol";import {Target} from "src/vehicles/multi/libs/Target.sol";import {IBaseVehicle} from "src/vehicles/base/interfaces/IBaseVehicle.sol";import {FeeManager, IFeeManager} from "src/vehicles/base/FeeManager.sol";import {FeeManagerFactory} from "src/factories/vehicles/FeeManagerFactory.sol";import {ModulesManager} from "src/vehicles/base/ModulesManager.sol";import {MultiVehicle} from "src/vehicles/multi/MultiVehicle.sol";import {QueueStrategyEngine} from "src/vehicles/multi/QueueStrategyEngine.sol";import {SectorAccountingEngine} from "src/vehicles/multi/SectorAccountingEngine.sol";import {VehicleRegistry} from "src/vehicles/multi/VehicleRegistry.sol";import {IQueueStrategyEngine} from "src/vehicles/multi/interfaces/IQueueStrategyEngine.sol";import {SectorLib} from "src/vehicles/multi/libs/Sector.sol";import {MultiVehicleFactory} from "src/factories/vehicles/MultiVehicleFactory.sol";import {Interceptor} from "src/abstracts/Interceptor.sol";import {Query, State} from "src/steam/Query.sol";
import {MultiVehicleTestInternals} from "test/vehicles/multi/MultiVehicleTestInternals.sol";
/// @title Nested MultiVehicle Redeem Fee NAV Standalone Test/// @notice Shows that top-level MultiVehicle NAV can overstate what a full unwind actually realizes///         when nested child MultiVehicles charge redeem payout fees.contract MultiVehicleNestedRedeemFeeNAVStandaloneTest is MultiVehicleTestInternals {    using SectorLib for IBaseVehicle;
    struct NestedMV {        MultiVehicle mv;        SectorAccountingEngine ae;        QueueStrategyEngine se;        VehicleRegistry vr;    }
    uint32 internal constant HIGH_REDEEM_FEE_BPS = 5_000; // 50%
    function test_topMultivehicle_totalAssets_overstates_full_unwind_value_under_nested_redeem_fees() external {        _grant(Roles.MULTI_VEHICLE_SET_VEHICLE_AUTHORIZATION, address(this));        _grant(Roles.MULTI_VEHICLE_SET_QUEUES, address(this));
        FeeManager _bottomFeeManager = _deployFeeManagerWithRedeemFee(keccak256("BOTTOM_FEE_MANAGER"));        FeeManager _middleFeeManager = _deployFeeManagerWithRedeemFee(keccak256("MIDDLE_FEE_MANAGER"));
        NestedMV memory _bottom = _deployNestedMultiVehicle(keccak256("BOTTOM_MULTI_VEHICLE"), _bottomFeeManager);        NestedMV memory _middle = _deployNestedMultiVehicle(keccak256("MIDDLE_MULTI_VEHICLE"), _middleFeeManager);
        _authorizeVehicle(_middle.vr, IBaseVehicle(address(_bottom.mv)));        _setSingleVehicleQueues(_middle.se, IBaseVehicle(address(_bottom.mv)));
        _authorize_vehicle(IBaseVehicle(address(_middle.mv)));        _single_vehicle_queues(IBaseVehicle(address(_middle.mv)));
        address _user = makeAddr("user");        _quick_deposit(_user, _unit(100));
        // Deposit chain is fully synchronous:        //   Top seed 1 + user 100 = 101        //   Middle seed 1 + Top deposit 101 = 102        //   Bottom seed 1 + Middle deposit 102 = 103        uint256 _grossTopAssets = $multiVehicle.totalAssets();        assertEq(_grossTopAssets, _unit(101), "top gross NAV mismatch");        assertEq(_middle.mv.totalAssets(), _unit(102), "middle gross NAV mismatch");        assertEq(_bottom.mv.totalAssets(), _unit(103), "bottom gross NAV mismatch");
        // First force the middle MV to unwind its bottom-MV position.        // Bottom charges a 50% redeem fee, so middle's realizable assets are halved.        uint256 _middleGrossAssets = _middle.mv.totalAssets();        vm.prank(address(_middle.mv));        _middle.ae.requestWithdrawable(_middleGrossAssets);
        uint256 _topAssetsAfterBottomUnwind = $multiVehicle.totalAssets();        assertEq(_middle.mv.totalAssets(), _unit(51), "middle should only realize half after bottom redeem fee");        assertEq(_topAssetsAfterBottomUnwind, _grossTopAssets / 2, "top view should reflect bottom fee loss");
        // Then force the top MV to unwind its middle-MV position.        // Middle also charges a 50% redeem fee, so top realizes only half again.        vm.prank(address($multiVehicle));        $accountingEngine.requestWithdrawable(_topAssetsAfterBottomUnwind);
        uint256 _realizedTopWithdrawable = $accountingEngine.withdrawable();        assertEq(_realizedTopWithdrawable, _grossTopAssets / 4, "top full unwind value mismatch");        assertEq($multiVehicle.totalAssets(), _realizedTopWithdrawable, "top NAV should equal realized withdrawable");
        assertLt(_realizedTopWithdrawable, _grossTopAssets, "top gross NAV must overstate realizable value");        assertEq(_topAssetsAfterBottomUnwind, _grossTopAssets / 2, "bottom fee should halve top view");        assertEq(_realizedTopWithdrawable, _grossTopAssets / 4, "nested fees should quarter final unwind value");    }
    function test_topMultivehicle_first_exit_drains_liquid_assets_and_second_exit_is_fee_constrained() external {        _grant(Roles.MULTI_VEHICLE_SET_VEHICLE_AUTHORIZATION, address(this));        _grant(Roles.MULTI_VEHICLE_SET_QUEUES, address(this));        _grant(Roles.MULTI_VEHICLE_MOVE_ASSETS, address(this));        _grant(Roles.MULTI_VEHICLE_DISPATCH, address(this));
        FeeManager _childFeeManager = _deployFeeManagerWithRedeemFee(keccak256("CHILD_FEE_MANAGER"));        NestedMV memory _child = _deployNestedMultiVehicle(keccak256("CHILD_MULTI_VEHICLE"), _childFeeManager);        IBaseVehicle _childVehicle = IBaseVehicle(address(_child.mv));
        _authorize_vehicle(_childVehicle);
        IQueueStrategyEngine.QueueEntry[] memory _depositQueue = new IQueueStrategyEngine.QueueEntry[](0);        IQueueStrategyEngine.QueueEntry[] memory _redeemQueue = new IQueueStrategyEngine.QueueEntry[](1);        _redeemQueue[0] = IQueueStrategyEngine.QueueEntry({            vehicle: _childVehicle, target: Target({value: 0, threshold: 0})        });        _set_queues(_depositQueue, _redeemQueue);
        address _alice = makeAddr("alice");        address _bob = makeAddr("bob");
        _quick_deposit(_alice, _unit(100));        _quick_deposit(_bob, _unit(100));
        assertEq($multiVehicle.balanceOf(_alice), _unit(100), "alice shares mismatch");        assertEq($multiVehicle.balanceOf(_bob), _unit(100), "bob shares mismatch");
        // The top-level MV is seeded with 1 burned share. Move that 1 asset plus another 100 assets        // into the child so the top MV keeps exactly 100 liquid assets for the first redeemer.        uint256 _childPositionAssets = _unit(101);        uint256 _expectedBobImmediateAssets = (_childPositionAssets * (10_000 - HIGH_REDEEM_FEE_BPS)) / 10_000;        uint256 _expectedBobQueuedShares = _unit(100) - _expectedBobImmediateAssets;
        $accountingEngine.moveAssets(SectorLib.DEPOSIT, _childVehicle.toSector(), _childPositionAssets);        _dispatch(_childVehicle);
        assertEq(_sectorBalance(SectorLib.DEPOSIT, $asset), _unit(100), "deposit sector should keep 100 liquid assets");        assertEq(            _sectorBalance(SectorLib.ALLOCATION, _childVehicle),            _unit(101),            "child allocation should hold the remaining NAV"        );        assertEq($multiVehicle.totalAssets(), _unit(201), "top NAV mismatch after staging");
        Query memory _aliceRedeem = _quick_redeem(_alice, _unit(100), State.UNLOCKING);        assertEq(uint256($multiVehicle.state(_aliceRedeem)), uint256(State.UNLOCKING), "alice redeem should unlock");        assertEq($asset.balanceOf(_alice), 0, "alice should not receive assets before unlock");
        vm.prank(_alice);        $multiVehicle.unlock(_aliceRedeem);
        assertEq($asset.balanceOf(_alice), _unit(100), "alice should drain the liquid deposit assets");        assertEq(uint256($multiVehicle.state(_aliceRedeem)), uint256(State.SETTLED), "alice redeem should settle");        assertEq(_sectorBalance(SectorLib.DEPOSIT, $asset), 0, "first exit should empty the deposit sector");        assertEq($multiVehicle.totalAssets(), _unit(101), "remaining NAV should sit in the child position");
        Query memory _bobRedeem = _quick_redeem(_bob, _unit(100), State.UNLOCKING);        uint256 _bobDemandId = $multiVehicle.demand(_bobRedeem);
        assertGt(_bobDemandId, 0, "bob should leave queued demand behind");        assertEq(uint256($multiVehicle.state(_bobRedeem)), uint256(State.UNLOCKING), "bob redeem should unlock");        assertEq($asset.balanceOf(_bob), 0, "bob should not receive assets before unlock");
        vm.prank(_bob);        $multiVehicle.unlock(_bobRedeem);
        assertEq(            $asset.balanceOf(_bob),            _expectedBobImmediateAssets,            "bob should only receive the fee-constrained child redeem"        );        assertEq(            uint256($multiVehicle.state(_bobRedeem)),            uint256(State.PROCESSING),            "bob redeem should remain queued after the partial unlock"        );        assertEq(            $redeemQueue.pending(_bobDemandId), _expectedBobQueuedShares, "bob should still have the remaining redeem queued"        );        assertEq($redeemQueue.unredeemable(), _expectedBobQueuedShares, "the queue should retain the remaining half");    }
    function _deployFeeManagerWithRedeemFee(bytes32 salt) internal returns (FeeManager feeManager) {        IFeeManager.FeeRecipient[] memory _recipients = new IFeeManager.FeeRecipient[](1);        _recipients[0] = IFeeManager.FeeRecipient({target: makeAddr("fee_recipient"), shareBps: 10_000});
        (feeManager,) = _deployFeeManager(            $coreFactory,            FeeManagerFactory.SpawnParams({                accessControl: $accessControl,                initialFees: IFeeManager.Fees({                    performanceFeeBps: 0, managementFeeBps: 0, depositFeeBps: 0, redeemFeeBps: HIGH_REDEEM_FEE_BPS                }),                initialMaxFees: IFeeManager.Fees({                    performanceFeeBps: 0, managementFeeBps: 0, depositFeeBps: 0, redeemFeeBps: HIGH_REDEEM_FEE_BPS                }),                initialRecipients: _recipients,                deploymentSalt: salt            })        );    }
    function _deployNestedMultiVehicle(bytes32 salt, FeeManager feeManager) internal returns (NestedMV memory nested) {        MultiVehicleFactory.Salts memory _salts = MultiVehicleFactory.Salts({            multiVehicle: salt,            queryRedeemQueue: keccak256(abi.encodePacked(salt, "QRQ")),            queueStrategyEngine: keccak256(abi.encodePacked(salt, "QSE")),            sectorAccountingEngine: keccak256(abi.encodePacked(salt, "SAE")),            subQueryEngine: keccak256(abi.encodePacked(salt, "SQE")),            vehicleRegistry: keccak256(abi.encodePacked(salt, "VR")),            initialDepositQuery: keccak256(abi.encodePacked(salt, "IDQ"))        });
        (MultiVehicleFactory.Contracts memory _contracts,) = _deployMultiVehicle(            $coreFactory,            MultiVehicleFactory.SpawnParams({                asset: $asset,                accessControl: $accessControl,                feeManager: feeManager,                modulesManager: ModulesManager(address(0)),                initialInterceptions: new Interceptor.Interception[](0),                salts: _salts,                name: "Nested",                symbol: "NESTED",                forbiddenAddresses: new address[](0)            })        );
        nested.mv = MultiVehicle(_contracts.multiVehicle);        nested.ae = SectorAccountingEngine(_contracts.sectorAccountingEngine);        nested.se = QueueStrategyEngine(_contracts.queueStrategyEngine);        nested.vr = VehicleRegistry(_contracts.vehicleRegistry);    }
    function _authorizeVehicle(VehicleRegistry registry, IBaseVehicle vehicle) internal {        registry.authorize(IVehicle(address(vehicle)));    }
    function _setSingleVehicleQueues(QueueStrategyEngine strategyEngine, IBaseVehicle vehicle) internal {        IQueueStrategyEngine.QueueEntry[] memory _depositQueue = new IQueueStrategyEngine.QueueEntry[](1);        IQueueStrategyEngine.QueueEntry[] memory _redeemQueue = new IQueueStrategyEngine.QueueEntry[](1);
        _depositQueue[0] = IQueueStrategyEngine.QueueEntry({            vehicle: vehicle, target: Target({value: type(uint256).max, threshold: 0})        });        _redeemQueue[0] = IQueueStrategyEngine.QueueEntry({vehicle: vehicle, target: Target({value: 0, threshold: 0})});
        strategyEngine.setQueues(_depositQueue, _redeemQueue);    }}

function _createRedeem(Query calldata, Id qid, uint256 sharesToRedeem, uint256 totalSupply_, uint256 totalAssets_)        internal        returns (State, State[] memory)    {        // ...
        // [3] Calculate total assets needed (current query + queued demands + extra buffer)        // If insufficient, request unallocation from sub-vehicles via QueueStrategyEngine        {            (bool _success, uint256 _totalAssetsToRedeem) = Math.tryAdd(                _assetsToWithdraw + _queryRedeemQueueAssetsToRedeem, $.thresholds.extraAssetsForWithdrawalRequests            );            if (!_success) {                _totalAssetsToRedeem = type(uint256).max;            }
            if (_withdrawable < _totalAssetsToRedeem) {                // Request accounting engine to make assets withdrawable                // This triggers unallocate() on QueueStrategyEngine, which returns redeem instructions                // SubQueryEngine then creates redeem queries to sub-vehicles
                $.accountingEngine.requestWithdrawable(_totalAssetsToRedeem); // @audit may update total assets
                // [4] Re-check withdrawable after requestWithdrawable (may have increased if sync redeems)                _withdrawable = $.accountingEngine.withdrawable();            }        }
        // [5] If there are queued demands, fulfill them first (FIFO fairness)        // Use available withdrawable to feed the queue before fulfilling current redemption        if (_queryRedeemQueueAssetsToRedeem > 0) {            (, uint256 _totalSharesFulfilled) = __tryAutoRedemption(                0, // extraAssets                totalSupply_,                totalAssets_, // @audit outdated total assets                true // skipThresholdCheck (explicit call path)            );
            // Burn shares funded by withdrawable assets (helper does not burn)            // Since extraAssets=0, all shares came from withdrawable            if (_totalSharesFulfilled > 0) {                _burn(address(this), _totalSharesFulfilled);                // Re-check withdrawable after fulfilling queue                _withdrawable = $.accountingEngine.withdrawable();            }        }                // ...    }

[PASS] test_PoC_requestWithdrawableUsesStaleTotalAssetsForQueuedRedeems() (gas: 4993555)Logs:  Forking at block number from env: 25071042  AAVE initial deposit amount:  1000000  Morpho initial deposit amount:  1000000  Initial deposit amount:  1000000  Queued redeemer USDC:   9999999999  Trigger redeemer USDC:  8001800000  Aave redeem fee USDC:   2000199999  MV Aave shares:         0

// SPDX-License-Identifier: BUSL-1.1////                        ░██░██                          ░██//                           ░██                          ░██//    ░██░████  ░██████   ░██░██ ░████████   ░███████  ░████████//    ░███           ░██  ░██░██ ░██    ░██ ░██    ░██    ░██//    ░██       ░███████  ░██░██ ░██    ░██ ░█████████    ░██//    ░██      ░██   ░██  ░██░██ ░██    ░██ ░██           ░██//    ░██       ░█████░██ ░██░██ ░██    ░██  ░███████      ░████////    =========🚂🚃🚃🚃=========================================//pragma solidity >=0.8.33;
// solhint-disable kiln-rules/ordering// solhint-disable no-console
import {Test, console} from "@forge-std/Test.sol";import {IERC20} from "@openzeppelin-contracts/token/ERC20/IERC20.sol";import {IERC20Metadata} from "@openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol";import {SafeERC20} from "@openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol";import {Math} from "@openzeppelin-contracts/utils/math/Math.sol";
import {IMorpho, Id as MarketId, MarketParams} from "@morpho/interfaces/IMorpho.sol";
// Railnet - commonimport {Asset, EstimationType, Mode, Query, State} from "src/steam/Query.sol";import {ExternalAccessControl} from "src/common/ExternalAccessControl.sol";import {IExternalAccessControl} from "src/common/interfaces/IExternalAccessControl.sol";import {FreezablePausableBeacon} from "src/common/FreezablePausableBeacon.sol";import {SharesLib} from "src/libs/Shares.sol";import {Roles} from "src/libs/Roles.sol";
// Railnet - factoriesimport {AccessControlFactory} from "src/factories/common/AccessControlFactory.sol";import {AaveV3VehicleFactory} from "src/factories/vehicles/AaveV3VehicleFactory.sol";import {ConduitFactory} from "src/factories/conduit/ConduitFactory.sol";import {CoreFactory} from "src/factories/CoreFactory.sol";import {FeeManagerFactory} from "src/factories/vehicles/FeeManagerFactory.sol";import {MorphoBlueVehicleFactory} from "src/factories/vehicles/MorphoBlueVehicleFactory.sol";import {MultiVehicleFactory} from "src/factories/vehicles/MultiVehicleFactory.sol";
// Railnet - vehiclesimport {AaveV3Vehicle} from "src/vehicles/aave_v3/AaveV3Vehicle.sol";import {IPool} from "src/vehicles/aave_v3/interfaces/IPool.sol";import {IPoolAddressesProvider} from "src/vehicles/aave_v3/interfaces/IPoolAddressesProvider.sol";import {TokenMath} from "@aave-v3-libs/helpers/TokenMath.sol";import {Interceptor} from "src/abstracts/Interceptor.sol";import {FeeManager} from "src/vehicles/base/FeeManager.sol";import {ModulesManager} from "src/vehicles/base/ModulesManager.sol";import {IBaseVehicle} from "src/vehicles/base/interfaces/IBaseVehicle.sol";import {IFeeManager} from "src/vehicles/base/interfaces/IFeeManager.sol";import {IVehicle} from "src/steam/IVehicle.sol";import {MorphoBlueVehicle} from "src/vehicles/morpho_blue/MorphoBlueVehicle.sol";import {MorphoBlueVehicleStructs} from "src/vehicles/morpho_blue/libs/MorphoBlueVehicleStructs.sol";import {MultiVehicle} from "src/vehicles/multi/MultiVehicle.sol";import {QueryRedeemQueue} from "src/vehicles/multi/QueryRedeemQueue.sol";import {QueueStrategyEngine} from "src/vehicles/multi/QueueStrategyEngine.sol";import {SectorAccountingEngine} from "src/vehicles/multi/SectorAccountingEngine.sol";import {SubQueryEngine} from "src/vehicles/multi/SubQueryEngine.sol";import {VehicleRegistry} from "src/vehicles/multi/VehicleRegistry.sol";import {Target} from "src/vehicles/multi/libs/Target.sol";import {IQueueStrategyEngine} from "src/vehicles/multi/interfaces/IQueueStrategyEngine.sol";
// Railnet - conduitimport {Conduit} from "src/conduit/Conduit.sol";import {ConduitStructs} from "src/conduit/libs/ConduitStructs.sol";import {IAccountList} from "src/conduit/interfaces/IAccountList.sol";import {IOwnerRegistry} from "src/conduit/interfaces/IOwnerRegistry.sol";
// Test utilsimport {Deployer} from "test/test_utils/Deployer.sol";import {ForkUtils} from "test/test_utils/ForkUtils.sol";
/// @title Multilevel Railnet Fork Config/// @notice Reusable scaffolding that wires three Railnet layers together against a real network:///         - Level 0: AAVE V3 vehicle (USDC) and Morpho Blue vehicle (USDC market).///         - Level 1: a MultiVehicle (USDC) that allocates between Aave and Morpho.///         - Level 2: a Conduit linked to the MultiVehicle.///         All Level 0 and Level 1 vehicles are configured with 10% performance fee, 1% management fee,///         and 0% deposit / redeem fees.contract MultilevelRailnetForkConfig is Test, Deployer {    using SafeERC20 for IERC20;
    /* ------------------------------------------------------------------------------------------------------------------------ */    /*                                                          NETWORK                                                         */    /* ------------------------------------------------------------------------------------------------------------------------ */
    /// @dev Mainnet USDC.    address internal constant $USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;    /// @dev Aave V3 PoolAddressesProvider (mainnet).    address internal constant $AAVE_POOL_ADDRESSES_PROVIDER = 0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e;    /// @dev Morpho Blue (deployed at the same address on every chain).    address internal constant $MORPHO = 0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb;    /// @dev Morpho Blue USDC / cbBTC market id (mainnet).    MarketId internal constant $MORPHO_USDC_MARKET =        MarketId.wrap(0x64d65c9a2d91c36d56fbc42d69e979335320169b3df63bf92789e2c8883fcc64);
    /* ------------------------------------------------------------------------------------------------------------------------ */    /*                                                       FEE PARAMETERS                                                     */    /* ------------------------------------------------------------------------------------------------------------------------ */
    /// @dev 10% performance fee.    uint32 internal constant $PERFORMANCE_FEE_BPS = 1000;    /// @dev 1% management fee.    uint32 internal constant $MANAGEMENT_FEE_BPS = 100;    /// @dev No deposit fee.    uint32 internal constant $DEPOSIT_FEE_BPS = 0;    uint32 internal constant $MAX_DEPOSIT_FEE_BPS = 1000;    /// @dev No redeem fee.    uint32 internal constant $REDEEM_FEE_BPS = 0;    uint32 internal constant $MAX_REDEEM_FEE_BPS = 1000;
    /* ------------------------------------------------------------------------------------------------------------------------ */    /*                                                       DEPLOYED STATE                                                     */    /* ------------------------------------------------------------------------------------------------------------------------ */
    address public $deployer;    address public $feeRecipient;
    IERC20Metadata public $usdc;
    CoreFactory public $coreFactoryRef;    ExternalAccessControl public $sharedAC;
    // Level 0 - vehicles    AaveV3Vehicle public $aaveVehicle;    MorphoBlueVehicle public $morphoVehicle;    FeeManager public $aaveFeeManager;    FeeManager public $morphoFeeManager;
    // Level 1 - multi vehicle    MultiVehicle public $multiVehicle;    QueueStrategyEngine public $strategyEngine;    SectorAccountingEngine public $accountingEngine;    QueryRedeemQueue public $redeemQueue;    SubQueryEngine public $subQueryEngine;    VehicleRegistry public $vehicleRegistry;    FeeManager public $multiFeeManager;
    // Level 2 - conduit    Conduit public $conduit;    ConduitFactory public $conduitFactory;    FreezablePausableBeacon public $conduitBeacon;
    /* ------------------------------------------------------------------------------------------------------------------------ */    /*                                                          DEPLOY                                                          */    /* ------------------------------------------------------------------------------------------------------------------------ */
    /// @notice Deploys every level. Must be invoked from a `setUp()` after the fork is selected.    function _deployAll() internal {        $deployer = makeAddr("multilevel-deployer");        $feeRecipient = makeAddr("multilevel-fee-recipient");        $usdc = IERC20Metadata($USDC);
        $coreFactoryRef = _deployCoreFactory();        $sharedAC = _deployAccessControlIfNeeded(            $coreFactoryRef,            AccessControlFactory.SpawnParams({                initialDelay: 0,                initialDefaultAdmin: address(this),                initialRoles: new IExternalAccessControl.RoleAttribution[](0),                deploymentSalt: keccak256("multilevel-shared-ac")            })        );
        // Make STEAM deposit/redeem permissionless so the SubQueryEngine can interact with sub-vehicles        // and the Conduit can interact with the MultiVehicle. This mirrors the public role setup used        // by `MultiVehicleTester` and avoids granting the role per address.        $sharedAC.setRolePublic(Roles.VEHICLE_STEAM_DEPOSIT, true);        $sharedAC.setRolePublic(Roles.VEHICLE_STEAM_REDEEM, true);
        // Register USDC in the asset registry with the canonical 1 USDC initial deposit amount.        _registerAsset(_getOrDeployAssetRegistry(), $USDC);
        _deployLevel0();        _deployLevel1();        _deployLevel2();    }
    /* ------------------------------------------------------------------------------------------------------------------------ */    /*                                                         LEVEL 0                                                          */    /* ------------------------------------------------------------------------------------------------------------------------ */
    function _deployLevel0() internal {        // Per-vehicle fee managers - each gets the same 10% perf / 1% mgmt / 0/0 transactional split.        $aaveFeeManager = _spawnFeeManager(keccak256("multilevel-fee-manager-aave"));        $morphoFeeManager = _spawnFeeManager(keccak256("multilevel-fee-manager-morpho"));
        // AAVE V3 vehicle (USDC).        AaveV3VehicleInfra memory _aaveInfra = _deployAaveV3VehicleInfra($deployer, $coreFactoryRef);        uint256 _aaveExpectedSupply = _previewAaveInitialSupply($USDC);        $aaveVehicle = _deployAaveV3VehicleInstance(            $deployer,            AaveV3VehicleFactory.SpawnParams({                asset: $USDC,                poolAddressesProvider: $AAVE_POOL_ADDRESSES_PROVIDER,                accessControl: $sharedAC,                feeManager: $aaveFeeManager,                modulesManager: ModulesManager(address(0)),                querySalt: keccak256("multilevel-aave-query"),                deploymentSalt: keccak256("multilevel-aave-deployment"),                forbiddenAddresses: new address[](0),                initialExpectedSupply: _aaveExpectedSupply            }),            _aaveInfra        );
        // Morpho Blue vehicle (USDC market).        MorphoBlueVehicleInfra memory _morphoInfra = _deployMorphoBlueVehicleInfra(            $deployer, MorphoBlueVehicleStructs.ImmutableParams({morpho: IMorpho($MORPHO)}), $coreFactoryRef        );        uint256 _morphoExpectedSupply = _previewMorphoInitialSupply($MORPHO_USDC_MARKET);        $morphoVehicle = _deployMorphoBlueVehicleInstance(            $deployer,            MorphoBlueVehicleFactory.SpawnParams({                morpho: $MORPHO,                marketId: $MORPHO_USDC_MARKET,                accessControl: $sharedAC,                feeManager: $morphoFeeManager,                modulesManager: ModulesManager(address(0)),                querySalt: keccak256("multilevel-morpho-query"),                deploymentSalt: keccak256("multilevel-morpho-deployment"),                forbiddenAddresses: new address[](0),                initialExpectedSupply: _morphoExpectedSupply            }),            _morphoInfra        );    }
    /* ------------------------------------------------------------------------------------------------------------------------ */    /*                                                         LEVEL 1                                                          */    /* ------------------------------------------------------------------------------------------------------------------------ */
    function _deployLevel1() internal {        $multiFeeManager = _spawnFeeManager(keccak256("multilevel-fee-manager-multi"));
        MultiVehicleInfra memory _multiInfra = _deployMultiVehicleInfra($deployer, $coreFactoryRef);
        MultiVehicleFactory.SpawnParams memory _params = MultiVehicleFactory.SpawnParams({            asset: $usdc,            name: "Multilevel",            symbol: "ML",            initialInterceptions: new Interceptor.Interception[](0),            accessControl: $sharedAC,            feeManager: $multiFeeManager,            modulesManager: ModulesManager(address(0)),            salts: MultiVehicleFactory.Salts({                multiVehicle: keccak256("multilevel-multi-multiVehicle"),                queryRedeemQueue: keccak256("multilevel-multi-queryRedeemQueue"),                queueStrategyEngine: keccak256("multilevel-multi-queueStrategyEngine"),                sectorAccountingEngine: keccak256("multilevel-multi-sectorAccountingEngine"),                subQueryEngine: keccak256("multilevel-multi-subQueryEngine"),                vehicleRegistry: keccak256("multilevel-multi-vehicleRegistry"),                initialDepositQuery: keccak256("multilevel-multi-initialDepositQuery")            }),            forbiddenAddresses: new address[](0)        });
        MultiVehicleFactory.Contracts memory _contracts = _deployMultiVehicleInstance($deployer, _params, _multiInfra);        $multiVehicle = MultiVehicle(_contracts.multiVehicle);        $strategyEngine = QueueStrategyEngine(_contracts.queueStrategyEngine);        $accountingEngine = SectorAccountingEngine(_contracts.sectorAccountingEngine);        $redeemQueue = QueryRedeemQueue(_contracts.queryRedeemQueue);        $subQueryEngine = SubQueryEngine(_contracts.subQueryEngine);        $vehicleRegistry = VehicleRegistry(_contracts.vehicleRegistry);
        // Authorize both sub-vehicles and configure a 50/50 deposit queue.        // The MultiVehicle's own access control is `$sharedAC`; we already hold DEFAULT_ADMIN_ROLE there.        $sharedAC.grantRole(Roles.MULTI_VEHICLE_SET_VEHICLE_AUTHORIZATION, address(this));        $sharedAC.grantRole(Roles.MULTI_VEHICLE_SET_QUEUES, address(this));        $sharedAC.grantRole(Roles.MULTI_VEHICLE_DISPATCH, address(this));        $sharedAC.grantRole(Roles.MULTI_VEHICLE_REBALANCE, address(this));        $sharedAC.grantRole(Roles.MULTI_VEHICLE_FEED_QUERY_REDEEM_QUEUE, address(this));        $sharedAC.grantRole(Roles.MULTI_VEHICLE_RETRIEVE_QUERY_REDEEM_QUEUE_ASSETS, address(this));        $sharedAC.grantRole(Roles.MULTI_VEHICLE_PROGRESS_QUERY, address(this));        $sharedAC.grantRole(Roles.FEE_MANAGER_SET_FEES, address(this));
        $vehicleRegistry.authorize(IVehicle(address($aaveVehicle)));        $vehicleRegistry.authorize(IVehicle(address($morphoVehicle)));
        IQueueStrategyEngine.QueueEntry[] memory _depositQueue = new IQueueStrategyEngine.QueueEntry[](2);        _depositQueue[0] = IQueueStrategyEngine.QueueEntry({            vehicle: IBaseVehicle(address($aaveVehicle)), target: Target({value: type(uint256).max, threshold: 0})        });        _depositQueue[1] = IQueueStrategyEngine.QueueEntry({            vehicle: IBaseVehicle(address($morphoVehicle)), target: Target({value: type(uint256).max, threshold: 0})        });
        IQueueStrategyEngine.QueueEntry[] memory _redeemQueue = new IQueueStrategyEngine.QueueEntry[](2);        _redeemQueue[1] = IQueueStrategyEngine.QueueEntry({            vehicle: IBaseVehicle(address($aaveVehicle)), target: Target({value: 0, threshold: 0})        });        _redeemQueue[0] = IQueueStrategyEngine.QueueEntry({            vehicle: IBaseVehicle(address($morphoVehicle)), target: Target({value: 0, threshold: 0})        });        $strategyEngine.setQueues(_depositQueue, _redeemQueue);    }
    /* ------------------------------------------------------------------------------------------------------------------------ */    /*                                                         LEVEL 2                                                          */    /* ------------------------------------------------------------------------------------------------------------------------ */
    function _deployLevel2() internal {        Conduit _impl = new Conduit();        $conduitBeacon = new FreezablePausableBeacon(address(_impl), $sharedAC);        $conduitFactory = new ConduitFactory($coreFactoryRef, $conduitBeacon, $sharedAC, _getOrDeployAssetRegistry());
        $sharedAC.grantRole(Roles.CONDUIT_SPAWN, address(this));
        // The conduit has no fee manager nor account list - the prompt only requested fees on the lower        // levels. Transfer mode is permissionless so users can move conduit shares freely.        ConduitFactory.SpawnParams memory _params = ConduitFactory.SpawnParams({            name: "Multilevel Conduit",            symbol: "ML-CDT",            vehicle: IVehicle(address($multiVehicle)),            feeManager: IFeeManager(address(0)),            accountList: IAccountList(address(0)),            ownerRegistry: IOwnerRegistry(address(0)),            accessControl: $sharedAC,            transferMode: ConduitStructs.TransferMode.ALLOW_TRANSFER,            initialExpectedSupply: 1,            querySalt: keccak256("multilevel-conduit-query"),            deploymentSalt: keccak256("multilevel-conduit-deployment")        });
        // Pre-fund the initial deposit and approve the factory.        uint256 _initialDeposit = $conduitFactory.ASSET_REGISTRY().getInitialDepositAmount($USDC);        console.log("Initial deposit amount: ", _initialDeposit);        deal($USDC, address(this), _initialDeposit);        IERC20($USDC).forceApprove(address($conduitFactory), _initialDeposit);
        $conduit = Conduit(address($conduitFactory.spawn(_params, _params.deploymentSalt)));    }
    /* ------------------------------------------------------------------------------------------------------------------------ */    /*                                                          HELPERS                                                         */    /* ------------------------------------------------------------------------------------------------------------------------ */
    /// @dev Spawns a FeeManager with the multilevel fee profile (10% perf, 1% mgmt, 0/0 transactional).    function _spawnFeeManager(bytes32 salt) internal returns (FeeManager feeManager) {        FeeManagerInfra memory _infra = _deployFeeManagerInfra($deployer, $coreFactoryRef, false);
        IFeeManager.FeeRecipient[] memory _recipients = new IFeeManager.FeeRecipient[](1);        _recipients[0] = IFeeManager.FeeRecipient({target: $feeRecipient, shareBps: 10_000});
        FeeManagerFactory.SpawnParams memory _params = FeeManagerFactory.SpawnParams({            accessControl: $sharedAC,            initialFees: IFeeManager.Fees({                performanceFeeBps: $PERFORMANCE_FEE_BPS,                managementFeeBps: $MANAGEMENT_FEE_BPS,                depositFeeBps: $DEPOSIT_FEE_BPS,                redeemFeeBps: $REDEEM_FEE_BPS            }),            initialMaxFees: IFeeManager.Fees({                performanceFeeBps: $PERFORMANCE_FEE_BPS,                managementFeeBps: $MANAGEMENT_FEE_BPS,                depositFeeBps: $MAX_DEPOSIT_FEE_BPS,                redeemFeeBps: $MAX_REDEEM_FEE_BPS            }),            initialRecipients: _recipients,            deploymentSalt: salt        });
        feeManager = _deployFeeManagerInstance($deployer, _params, _infra);    }
    /// @dev Replicates `AaveV3VehicleForkConfig._deployVehicle` initial-supply math so the factory's    ///      slippage check `initialExpectedSupply` succeeds.    function _previewAaveInitialSupply(address asset) internal view returns (uint256) {        uint8 _assetDecimals = IERC20Metadata(asset).decimals();        address _pool = IPoolAddressesProvider($AAVE_POOL_ADDRESSES_PROVIDER).getPool();        uint256 _liquidityIndex = IPool(_pool).getReserveNormalizedIncome(asset);        uint256 _initialDepositAmount = 10 ** uint256(_assetDecimals);        uint256 _expectedScaledShares = TokenMath.getATokenMintScaledAmount(_initialDepositAmount, _liquidityIndex);        return SharesLib.scale(_expectedScaledShares, _assetDecimals, 18, Math.Rounding.Floor);    }
    /// @dev Replicates `MorphoBlueVehicleForkConfig._deployVehicle` initial-supply math: simulate a 1-token    ///      supply against the live market, take the resulting supplyShares delta, and scale to 18 decimals.    function _previewMorphoInitialSupply(MarketId marketId) internal returns (uint256) {        MarketParams memory _params = IMorpho($MORPHO).idToMarketParams(marketId);        uint8 _assetDecimals = IERC20Metadata(_params.loanToken).decimals();        uint256 _initialDepositAmount = 10 ** uint256(_assetDecimals);
        uint256 _snap = vm.snapshotState();        deal(_params.loanToken, address(this), _initialDepositAmount);        IERC20(_params.loanToken).forceApprove($MORPHO, _initialDepositAmount);        uint256 _supplySharesBefore = IMorpho($MORPHO).position(marketId, address(this)).supplyShares;        IMorpho($MORPHO).supply(_params, _initialDepositAmount, 0, address(this), hex"");        uint256 _morphoSharesReceived =            IMorpho($MORPHO).position(marketId, address(this)).supplyShares - _supplySharesBefore;        vm.revertToState(_snap);
        return SharesLib.scale(_morphoSharesReceived, _assetDecimals + 6, 18, Math.Rounding.Floor);    }}
/// @title MultilevelRailnet_MainnetFork/// @notice Smoke test that verifies the multilevel Railnet stack (Aave + Morpho vehicles ⊂ MultiVehicle ⊂ Conduit)///         can be deployed against a real mainnet fork and that a user can:///         1. Deposit USDC into the Conduit and receive conduit shares.///         2. See the funds dispatched into both Aave and Morpho through the MultiVehicle's strategy queue.///         3. Observe fee accounting (10% perf / 1% mgmt) reflected on every layer that owns a FeeManager.contract MultilevelRailnet_MainnetFork is MultilevelRailnetForkConfig, ForkUtils {    function setUp() public {        _startFork("MAINNET");        _deployAll();    }
    function test_PoC_requestWithdrawableUsesStaleTotalAssetsForQueuedRedeems() public {        $multiFeeManager.setFees(            IFeeManager.Fees({performanceFeeBps: 0, managementFeeBps: 0, depositFeeBps: 0, redeemFeeBps: 0})        );        $aaveFeeManager.setFees(            IFeeManager.Fees({                performanceFeeBps: 0, managementFeeBps: 0, depositFeeBps: 0, redeemFeeBps: $MAX_REDEEM_FEE_BPS            })        );        _setAaveOnlyQueues(false);
        address _queuedRedeemer = makeAddr("ml-queued-redeemer");        address _triggerRedeemer = makeAddr("ml-trigger-redeemer");        uint256 _amount = 10_000 * 10 ** $usdc.decimals();
        _depositIntoMultiVehicle(_queuedRedeemer, _amount, keccak256("stale-ta-deposit-queued"));        _depositIntoMultiVehicle(_triggerRedeemer, _amount, keccak256("stale-ta-deposit-trigger"));
        uint256 _queuedShares = IERC20(address($multiVehicle)).balanceOf(_queuedRedeemer);        uint256 _triggerShares = IERC20(address($multiVehicle)).balanceOf(_triggerRedeemer);        // approximately equal depending on the underlying asset precision (18 - 6 = 12)        assertApproxEqAbs(            _queuedShares / (10 ** 12), _triggerShares / (10 ** 12), 1, "equal deposits should mint equal shares"        );        assertEq($accountingEngine.withdrawable(), 0, "all deposits should be allocated to Aave");
        Query memory _queuedRedeem =            _buildMultiVehicleRedeemQuery(_queuedRedeemer, _queuedShares, keccak256("stale-ta-redeem-queued"));        vm.prank(_queuedRedeemer);        State _queuedState = $multiVehicle.create(_queuedRedeem);        assertEq(uint8(_queuedState), uint8(State.PROCESSING), "first redeem should be queued");        assertEq($redeemQueue.demandsCount(), 1, "queued redeem demand not created");        assertEq($redeemQueue.unredeemable(), _queuedShares, "queued shares mismatch");
        _setAaveOnlyQueues(true);
        uint256 _totalAssetsBefore = $multiVehicle.totalAssets();        uint256 _aaveRedeemFeesBefore = $usdc.balanceOf(address($aaveFeeManager));
        Query memory _triggerRedeem =            _buildMultiVehicleRedeemQuery(_triggerRedeemer, _triggerShares, keccak256("stale-ta-redeem-trigger"));        vm.startPrank(_triggerRedeemer);        State _triggerState = $multiVehicle.create(_triggerRedeem);        assertEq(uint8(_triggerState), uint8(State.UNLOCKING), "second redeem should unlock immediate liquidity");        $multiVehicle.unlock(_triggerRedeem);        vm.stopPrank();
        vm.prank(_queuedRedeemer);        $multiVehicle.unlock(_queuedRedeem);
        uint256 _aaveRedeemFees = $usdc.balanceOf(address($aaveFeeManager)) - _aaveRedeemFeesBefore;        assertGt(_aaveRedeemFees, 0, "Aave redeem fee must be charged during requestWithdrawable");        assertLt(            $multiVehicle.totalAssets(),            _totalAssetsBefore - _aaveRedeemFees / 2,            "requestWithdrawable must reduce totalAssets when redeem fees are paid"        );
        uint256 _queuedRedeemed = $usdc.balanceOf(_queuedRedeemer);        uint256 _triggerRedeemed = $usdc.balanceOf(_triggerRedeemer);        (uint256 _multiAaveShares,,,,) = $accountingEngine.vehicleHoldings(IBaseVehicle(address($aaveVehicle)));
        console.log("Queued redeemer USDC:  ", _queuedRedeemed);        console.log("Trigger redeemer USDC: ", _triggerRedeemed);        console.log("Aave redeem fee USDC:  ", _aaveRedeemFees);        console.log("MV Aave shares:        ", _multiAaveShares);        assertEq(_multiAaveShares, 0, "all shares should have been redeemed from Aave to fulfill the redeems");
        // @audit these two should be approximately equal! Uncommenting the following assertion reverts        /* assertApproxEqAbs(            _queuedRedeemed,            _triggerRedeemed,            10,            "equal redeemers should receive the same amount after the shared redeem fee"        ); */    }
    /* ------------------------------------------------------------------------------------------------------------------------ */    /*                                                          HELPERS                                                         */    /* ------------------------------------------------------------------------------------------------------------------------ */
    function _assertFees(IFeeManager feeManager, string memory label) internal view {        (, IFeeManager.Fees memory _fees) = feeManager.fees();        assertEq(_fees.performanceFeeBps, $PERFORMANCE_FEE_BPS, string.concat(label, ": performanceFeeBps"));        assertEq(_fees.managementFeeBps, $MANAGEMENT_FEE_BPS, string.concat(label, ": managementFeeBps"));        assertEq(_fees.depositFeeBps, $DEPOSIT_FEE_BPS, string.concat(label, ": depositFeeBps"));        assertEq(_fees.redeemFeeBps, $REDEEM_FEE_BPS, string.concat(label, ": redeemFeeBps"));    }
    /// @dev Initial deposit performed by `MultiVehicleFactory.spawn` (1 USDC). Captured at first call to keep    ///      reuse cheap across multiple assertions in the same test.    function _initialMultiVehicleAssets() internal view returns (uint256) {        return 10 ** $usdc.decimals();    }
    function _setPerformanceOnlyFees(IFeeManager feeManager) internal {        feeManager.setFees(            IFeeManager.Fees({                performanceFeeBps: $PERFORMANCE_FEE_BPS,                managementFeeBps: 0,                depositFeeBps: $DEPOSIT_FEE_BPS,                redeemFeeBps: $REDEEM_FEE_BPS            })        );    }
    function _spawnFeeEnabledConduit(IFeeManager feeManager) internal returns (Conduit conduit) {        ConduitFactory.SpawnParams memory _params = ConduitFactory.SpawnParams({            name: "Performance Fee Conduit",            symbol: "PFC",            vehicle: IVehicle(address($multiVehicle)),            feeManager: feeManager,            accountList: IAccountList(address(0)),            ownerRegistry: IOwnerRegistry(address(0)),            accessControl: $sharedAC,            transferMode: ConduitStructs.TransferMode.ALLOW_TRANSFER,            initialExpectedSupply: 1,            querySalt: keccak256("multilevel-conduit-fee-query"),            deploymentSalt: keccak256("multilevel-conduit-fee-deployment")        });
        uint256 _initialDeposit = $conduitFactory.ASSET_REGISTRY().getInitialDepositAmount(address($usdc));        deal(address($usdc), address(this), _initialDeposit);        IERC20(address($usdc)).approve(address($conduitFactory), 0);        IERC20(address($usdc)).approve(address($conduitFactory), _initialDeposit);
        conduit = Conduit(address($conduitFactory.spawn(_params, _params.deploymentSalt)));    }
    function _estimateConduitRedeem(Conduit conduit, uint256 conduitShares) internal view returns (uint256) {        Asset[] memory _input = new Asset[](1);        _input[0] = Asset({asset: address(conduit), value: conduitShares});        Asset[] memory _output = conduit.estimate(_input, Mode.REDEEM, EstimationType.OUTPUT);        return _output[0].value;    }
    function _setMorphoOnlyQueues() internal {        IQueueStrategyEngine.QueueEntry[] memory _depositQueue = new IQueueStrategyEngine.QueueEntry[](1);        _depositQueue[0] = IQueueStrategyEngine.QueueEntry({            vehicle: IBaseVehicle(address($morphoVehicle)), target: Target({value: type(uint256).max, threshold: 0})        });
        IQueueStrategyEngine.QueueEntry[] memory _redeemQueue = new IQueueStrategyEngine.QueueEntry[](1);        _redeemQueue[0] = IQueueStrategyEngine.QueueEntry({            vehicle: IBaseVehicle(address($morphoVehicle)), target: Target({value: 0, threshold: 0})        });
        $strategyEngine.setQueues(_depositQueue, _redeemQueue);    }
    function _setAaveOnlyQueues(bool redeemEnabled) internal {        IQueueStrategyEngine.QueueEntry[] memory _depositQueue = new IQueueStrategyEngine.QueueEntry[](1);        _depositQueue[0] = IQueueStrategyEngine.QueueEntry({            vehicle: IBaseVehicle(address($aaveVehicle)), target: Target({value: type(uint256).max, threshold: 0})        });
        IQueueStrategyEngine.QueueEntry[] memory _redeemQueue =            new IQueueStrategyEngine.QueueEntry[](redeemEnabled ? 1 : 0);        if (redeemEnabled) {            _redeemQueue[0] = IQueueStrategyEngine.QueueEntry({                vehicle: IBaseVehicle(address($aaveVehicle)), target: Target({value: 0, threshold: 0})            });        }
        $strategyEngine.setQueues(_depositQueue, _redeemQueue);    }
    function _buildMultiVehicleRedeemQuery(address user, uint256 shares, bytes32 salt)        internal        view        returns (Query memory redeemQuery)    {        Asset[] memory _input = new Asset[](1);        _input[0] = Asset({asset: address($multiVehicle), value: shares});        Asset[] memory _output = $multiVehicle.estimate(_input, Mode.REDEEM, EstimationType.OUTPUT);
        redeemQuery = Query({            owner: user, receiver: user, input: _input, output: _output, mode: Mode.REDEEM, salt: salt, data: ""        });    }
    function _depositIntoMultiVehicle(address user, uint256 amount, bytes32 salt) internal {        deal(address($usdc), user, amount);
        Asset[] memory _input = new Asset[](1);        _input[0] = Asset({asset: address($usdc), value: amount});        Asset[] memory _output = $multiVehicle.estimate(_input, Mode.DEPOSIT, EstimationType.OUTPUT);
        Query memory _depositQuery = Query({            owner: user, receiver: user, input: _input, output: _output, mode: Mode.DEPOSIT, salt: salt, data: ""        });
        vm.startPrank(user);        IERC20(address($usdc)).approve(address($multiVehicle), amount);        $multiVehicle.create(_depositQuery);        $multiVehicle.unlock(_depositQuery);        vm.stopPrank();    }
    function _redeemFromMultiVehicle(address user, uint256 shares, bytes32 salt) internal {        Asset[] memory _input = new Asset[](1);        _input[0] = Asset({asset: address($multiVehicle), value: shares});        Asset[] memory _output = $multiVehicle.estimate(_input, Mode.REDEEM, EstimationType.OUTPUT);
        Query memory _redeemQuery = Query({            owner: user, receiver: user, input: _input, output: _output, mode: Mode.REDEEM, salt: salt, data: ""        });
        vm.startPrank(user);        IERC20(address($multiVehicle)).approve(address($multiVehicle), shares);        $multiVehicle.create(_redeemQuery);        $multiVehicle.unlock(_redeemQuery);        vm.stopPrank();    }
    function _estimateMultiVehicleRedeem(uint256 shares) internal view returns (uint256) {        Asset[] memory _input = new Asset[](1);        _input[0] = Asset({asset: address($multiVehicle), value: shares});        Asset[] memory _output = $multiVehicle.estimate(_input, Mode.REDEEM, EstimationType.OUTPUT);        return _output[0].value;    }}