Idea: BatchSimplePriceManager

docs/architecture/deployers.puml

@@ -12,9 +12,10 @@ class SpokeDeployer
 class AdaptersDeployer
 
 class ValuationsDeployer
+class HubManagersDeployer
 class ExtendedHubDeployer
 
-class ManagersDeployer
+class SpokeManagersDeployer
 class VaultsDeployer
 class HooksDeployer
 class ExtendedSpokeDeployer
@@ -32,14 +33,17 @@ HubDeployer -up-|> CommonDeployer
 SpokeDeployer -up-|> CommonDeployer
 AdaptersDeployer -up-|> CommonDeployer
 
+HubManagersDeployer -up-|> HubDeployer
 ValuationsDeployer -up-|> HubDeployer
+
+ExtendedHubDeployer -up-|> HubManagersDeployer
 ExtendedHubDeployer -up-|> ValuationsDeployer
 
-ManagersDeployer -up-|> SpokeDeployer
+SpokeManagersDeployer -up-|> SpokeDeployer
 VaultsDeployer -up-|> SpokeDeployer
 HooksDeployer -up-|> SpokeDeployer
 
-ExtendedSpokeDeployer -up-|> ManagersDeployer
+ExtendedSpokeDeployer -up-|> SpokeManagersDeployer
 ExtendedSpokeDeployer -up-|> VaultsDeployer
 ExtendedSpokeDeployer -up-|> HooksDeployer
 

docs/architecture/hub.puml

@@ -12,6 +12,12 @@ package common {
     class Gateway
 }
 
+package managers {
+    class NAVManager
+    class SimplePriceManager
+    interface INAVHook
+}
+
 class Holdings
 class HubRegistry
 class ShareClassManager
@@ -34,7 +40,11 @@ Hub --> Accounting
 Hub -up-> MessageDispatcher
 Hub -up-> Gateway
 Holdings --> IValuation
-Holdings --> ISnapshotHook
+Holdings -|> ISnapshotHook
+
+NAVManager -|> ISnapshotHook
+NAVManager -down-|> INAVHook
+SimplePriceManager -up-|> INAVHook
 
 Holdings --> HubRegistry
 ShareClassManager --> HubRegistry

script/ExtendedHubDeployer.s.sol

@@ -3,26 +3,30 @@ pragma solidity 0.8.28;
 
 import {CommonInput} from "./CommonDeployer.s.sol";
 import {ValuationsDeployer, ValuationsActionBatcher} from "./ValuationsDeployer.s.sol";
+import {HubManagersDeployer, HubManagersActionBatcher} from "./HubManagersDeployer.s.sol";
 
 import "forge-std/Script.sol";
 
-contract ExtendedHubActionBatcher is ValuationsActionBatcher {}
+contract ExtendedHubActionBatcher is ValuationsActionBatcher, HubManagersActionBatcher {}
 
-contract ExtendedHubDeployer is ValuationsDeployer {
+contract ExtendedHubDeployer is ValuationsDeployer, HubManagersDeployer {
     function deployExtendedHub(CommonInput memory input, ExtendedHubActionBatcher batcher) public {
         _preDeployExtendedHub(input, batcher);
         _postDeployExtendedHub(batcher);
     }
 
     function _preDeployExtendedHub(CommonInput memory input, ExtendedHubActionBatcher batcher) internal {
         _preDeployValuations(input, batcher);
+        _preDeployHubManagers(input, batcher);
     }
 
     function _postDeployExtendedHub(ExtendedHubActionBatcher batcher) internal {
         _postDeployValuations(batcher);
+        _postDeployHubManagers(batcher);
     }
 
     function removeExtendedHubDeployerAccess(ExtendedHubActionBatcher batcher) public {
         removeValuationsDeployerAccess(batcher);
+        removeHubManagersDeployerAccess(batcher);
     }
 }

script/ExtendedSpokeDeployer.s.sol

@@ -4,13 +4,13 @@ pragma solidity 0.8.28;
 import {CommonInput} from "./CommonDeployer.s.sol";
 import {HooksDeployer, HooksActionBatcher} from "./HooksDeployer.s.sol";
 import {VaultsDeployer, VaultsActionBatcher} from "./VaultsDeployer.s.sol";
-import {ManagersDeployer, ManagersActionBatcher} from "./ManagersDeployer.s.sol";
+import {SpokeManagersDeployer, SpokeManagersActionBatcher} from "./SpokeManagersDeployer.s.sol";
 
 import "forge-std/Script.sol";
 
-contract ExtendedSpokeActionBatcher is VaultsActionBatcher, HooksActionBatcher, ManagersActionBatcher {}
+contract ExtendedSpokeActionBatcher is VaultsActionBatcher, HooksActionBatcher, SpokeManagersActionBatcher {}
 
-contract ExtendedSpokeDeployer is VaultsDeployer, HooksDeployer, ManagersDeployer {
+contract ExtendedSpokeDeployer is VaultsDeployer, HooksDeployer, SpokeManagersDeployer {
     function deployExtendedSpoke(CommonInput memory input, ExtendedSpokeActionBatcher batcher) public {
         _preDeployExtendedSpoke(input, batcher);
         _postDeployExtendedSpoke(batcher);
@@ -19,18 +19,18 @@ contract ExtendedSpokeDeployer is VaultsDeployer, HooksDeployer, ManagersDeploye
     function _preDeployExtendedSpoke(CommonInput memory input, ExtendedSpokeActionBatcher batcher) internal {
         _preDeployVaults(input, batcher);
         _preDeployHooks(input, batcher);
-        _preDeployManagers(input, batcher);
+        _preDeploySpokeManagers(input, batcher);
     }
 
     function _postDeployExtendedSpoke(ExtendedSpokeActionBatcher batcher) internal {
         _postDeployVaults(batcher);
         _postDeployHooks(batcher);
-        _postDeployManagers(batcher);
+        _postDeploySpokeManagers(batcher);
     }
 
     function removeExtendedSpokeDeployerAccess(ExtendedSpokeActionBatcher batcher) public {
         removeVaultsDeployerAccess(batcher);
         removeHooksDeployerAccess(batcher);
-        removeManagersDeployerAccess(batcher);
+        removeSpokeManagersDeployerAccess(batcher);
     }
 }

script/HubDeployer.s.sol

@@ -104,6 +104,10 @@ contract HubDeployer is CommonDeployer, HubConstants {
     }
 
     function _preDeployHub(CommonInput memory input, HubActionBatcher batcher) internal {
+        if (address(hub) != address(0)) {
+            return; // Already deployed. Make this method idempotent.
+        }
+
         _preDeployCommon(input, batcher);
 
         hubRegistry = HubRegistry(
@@ -173,6 +177,10 @@ contract HubDeployer is CommonDeployer, HubConstants {
     }
 
     function removeHubDeployerAccess(HubActionBatcher batcher) public {
+        if (hub.wards(address(batcher)) == 0) {
+            return; // Already removed. Make this method idempotent.
+        }
+
         removeCommonDeployerAccess(batcher);
         batcher.revokeHub(_hubReport());
     }

script/HubManagersDeployer.s.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.28;
+
+import {CommonInput} from "./CommonDeployer.s.sol";
+import {HubDeployer, HubReport, HubActionBatcher} from "./HubDeployer.s.sol";
+
+import {NAVManager} from "../src/managers/hub/NAVManager.sol";
+import {SimplePriceManager} from "../src/managers/hub/SimplePriceManager.sol";
+
+import "forge-std/Script.sol";
+
+struct HubManagersReport {
+    HubReport hub;
+    NAVManager navManager;
+    SimplePriceManager simplePriceManager;
+}
+
+contract HubManagersActionBatcher is HubActionBatcher {
+    function engageManagers(HubManagersReport memory report) public onlyDeployer {
+        // Rely root
+        report.navManager.rely(address(report.hub.common.root));
+        report.simplePriceManager.rely(address(report.hub.common.root));
+
+        // Rely other
+        report.navManager.rely(address(report.hub.hub));
+        report.navManager.rely(address(report.hub.hubHandler));
+        report.navManager.rely(address(report.hub.holdings));
+        report.simplePriceManager.rely(address(report.navManager));
+    }
+
+    function revokeManagers(HubManagersReport memory report) public onlyDeployer {
+        report.navManager.deny(address(this));
+        report.simplePriceManager.deny(address(this));
+    }
+}
+
+contract HubManagersDeployer is HubDeployer {
+    NAVManager public navManager;
+    SimplePriceManager public simplePriceManager;
+
+    function deployHubManagers(CommonInput memory input, HubManagersActionBatcher batcher) public {
+        _preDeployHubManagers(input, batcher);
+        _postDeployHubManagers(batcher);
+    }
+
+    function _preDeployHubManagers(CommonInput memory input, HubManagersActionBatcher batcher) internal {
+        _preDeployHub(input, batcher);
+
+        navManager = NAVManager(
+            create3(
+                generateSalt("navManager"),
+                abi.encodePacked(type(NAVManager).creationCode, abi.encode(hub, address(batcher)))
+            )
+        );
+
+        simplePriceManager = SimplePriceManager(
+            create3(
+                generateSalt("simplePriceManager"),
+                abi.encodePacked(type(SimplePriceManager).creationCode, abi.encode(hub, address(batcher)))
+            )
+        );
+
+        batcher.engageManagers(_managersReport());
+
+        register("navManager", address(navManager));
+        register("simplePriceManager", address(simplePriceManager));
+    }
+
+    function _postDeployHubManagers(HubManagersActionBatcher batcher) internal {
+        _postDeployHub(batcher);
+    }
+
+    function removeHubManagersDeployerAccess(HubManagersActionBatcher batcher) public {
+        removeHubDeployerAccess(batcher);
+
+        batcher.revokeManagers(_managersReport());
+    }
+
+    function _managersReport() internal view returns (HubManagersReport memory) {
+        return HubManagersReport(_hubReport(), navManager, simplePriceManager);
+    }
+}

script/ManagersDeployer.s.sol → script/SpokeManagersDeployer.s.sol

@@ -4,13 +4,13 @@ pragma solidity 0.8.28;
 import {CommonInput} from "./CommonDeployer.s.sol";
 import {SpokeDeployer, SpokeReport, SpokeActionBatcher} from "./SpokeDeployer.s.sol";
 
-import {QueueManager} from "../src/managers/QueueManager.sol";
-import {VaultDecoder} from "../src/managers/decoders/VaultDecoder.sol";
-import {CircleDecoder} from "../src/managers/decoders/CircleDecoder.sol";
-import {OnOfframpManagerFactory} from "../src/managers/OnOfframpManager.sol";
-import {MerkleProofManagerFactory} from "../src/managers/MerkleProofManager.sol";
+import {QueueManager} from "../src/managers/spoke/QueueManager.sol";
+import {VaultDecoder} from "../src/managers/spoke/decoders/VaultDecoder.sol";
+import {CircleDecoder} from "../src/managers/spoke/decoders/CircleDecoder.sol";
+import {OnOfframpManagerFactory} from "../src/managers/spoke/OnOfframpManager.sol";
+import {MerkleProofManagerFactory} from "../src/managers/spoke/MerkleProofManager.sol";
 
-struct ManagersReport {
+struct SpokeManagersReport {
     SpokeReport spoke;
     QueueManager queueManager;
     OnOfframpManagerFactory onOfframpManagerFactory;
@@ -19,33 +19,33 @@ struct ManagersReport {
     CircleDecoder circleDecoder;
 }
 
-contract ManagersActionBatcher is SpokeActionBatcher {
-    function engageManagers(ManagersReport memory report) public onlyDeployer {
+contract SpokeManagersActionBatcher is SpokeActionBatcher {
+    function engageManagers(SpokeManagersReport memory report) public onlyDeployer {
         // rely QueueManager on Gateway
         report.spoke.common.gateway.rely(address(report.queueManager));
 
         // rely Root
         report.queueManager.rely(address(report.spoke.common.root));
     }
 
-    function revokeManagers(ManagersReport memory report) public onlyDeployer {
+    function revokeManagers(SpokeManagersReport memory report) public onlyDeployer {
         report.queueManager.deny(address(this));
     }
 }
 
-contract ManagersDeployer is SpokeDeployer {
+contract SpokeManagersDeployer is SpokeDeployer {
     QueueManager public queueManager;
     OnOfframpManagerFactory public onOfframpManagerFactory;
     MerkleProofManagerFactory public merkleProofManagerFactory;
     VaultDecoder public vaultDecoder;
     CircleDecoder public circleDecoder;
 
-    function deployManagers(CommonInput memory input, ManagersActionBatcher batcher) public {
-        _preDeployManagers(input, batcher);
-        _postDeployManagers(batcher);
+    function deploySpokeManagers(CommonInput memory input, SpokeManagersActionBatcher batcher) public {
+        _preDeploySpokeManagers(input, batcher);
+        _postDeploySpokeManagers(batcher);
     }
 
-    function _preDeployManagers(CommonInput memory input, ManagersActionBatcher batcher) internal {
+    function _preDeploySpokeManagers(CommonInput memory input, SpokeManagersActionBatcher batcher) internal {
         _preDeploySpoke(input, batcher);
 
         queueManager = QueueManager(
@@ -79,7 +79,7 @@ contract ManagersDeployer is SpokeDeployer {
         circleDecoder =
             CircleDecoder(create3(generateSalt("circleDecoder"), abi.encodePacked(type(CircleDecoder).creationCode)));
 
-        batcher.engageManagers(_managersReport());
+        batcher.engageManagers(_spokeManagersReport());
 
         register("queueManager", address(queueManager));
         register("onOfframpManagerFactory", address(onOfframpManagerFactory));
@@ -88,18 +88,18 @@ contract ManagersDeployer is SpokeDeployer {
         register("circleDecoder", address(circleDecoder));
     }
 
-    function _postDeployManagers(ManagersActionBatcher batcher) internal {
+    function _postDeploySpokeManagers(SpokeManagersActionBatcher batcher) internal {
         _postDeploySpoke(batcher);
     }
 
-    function removeManagersDeployerAccess(ManagersActionBatcher batcher) public {
+    function removeSpokeManagersDeployerAccess(SpokeManagersActionBatcher batcher) public {
         removeSpokeDeployerAccess(batcher);
 
-        batcher.revokeManagers(_managersReport());
+        batcher.revokeManagers(_spokeManagersReport());
     }
 
-    function _managersReport() internal view returns (ManagersReport memory) {
-        return ManagersReport(
+    function _spokeManagersReport() internal view returns (SpokeManagersReport memory) {
+        return SpokeManagersReport(
             _spokeReport(),
             queueManager,
             onOfframpManagerFactory,

script/utils/README.md

@@ -175,7 +175,7 @@ import {Auth} from "../misc/Auth.sol";
 // Before
 import {CommonInput} from "script/CommonDeployer.s.sol";
 
-// After (from script/ManagersDeployer.s.sol)
+// After (from script/SpokeManagersDeployer.s.sol)
 import {CommonInput} from "./CommonDeployer.s.sol";
 ```
 

src/common/types/AccountId.sol

@@ -1,14 +1,28 @@
 // SPDX-License-Identifier: BUSL-1.1
 pragma solidity 0.8.28;
 
-type AccountId is uint32;
+import {AssetId} from "./AssetId.sol";
 
-function raw(AccountId accountId_) pure returns (uint32) {
+type AccountId is uint256;
+
+function raw(AccountId accountId_) pure returns (uint256) {
     return AccountId.unwrap(accountId_);
 }
 
 function neq(AccountId a, AccountId b) pure returns (bool) {
     return AccountId.unwrap(a) != AccountId.unwrap(b);
 }
 
-using {raw, neq as !=} for AccountId global;
+function isNull(AccountId accountId) pure returns (bool) {
+    return AccountId.unwrap(accountId) == 0;
+}
+
+function withCentrifugeId(uint16 centrifugeId, uint16 index) pure returns (AccountId) {
+    return AccountId.wrap((uint256(centrifugeId) << 16) | uint256(index));
+}
+
+function withAssetId(AssetId assetId, uint16 index) pure returns (AccountId) {
+    return AccountId.wrap((uint256(assetId.raw()) << 16) | uint256(index));
+}
+
+using {raw, neq as !=, isNull} for AccountId global;

src/common/types/ShareClassId.sol

@@ -9,6 +9,10 @@ function isNull(ShareClassId scId) pure returns (bool) {
     return ShareClassId.unwrap(scId) == 0;
 }
 
+function index(ShareClassId scId) pure returns (uint32) {
+    return uint32(uint128(ShareClassId.unwrap(scId)));
+}
+
 function equals(ShareClassId left, ShareClassId right) pure returns (bool) {
     return ShareClassId.unwrap(left) == ShareClassId.unwrap(right);
 }
@@ -17,8 +21,8 @@ function raw(ShareClassId scId) pure returns (bytes16) {
     return ShareClassId.unwrap(scId);
 }
 
-function newShareClassId(PoolId poolId, uint32 index) pure returns (ShareClassId scId) {
-    return ShareClassId.wrap(bytes16((uint128(PoolId.unwrap(poolId)) << 64) + index));
+function newShareClassId(PoolId poolId, uint32 index_) pure returns (ShareClassId scId) {
+    return ShareClassId.wrap(bytes16((uint128(PoolId.unwrap(poolId)) << 64) + index_));
 }
 
-using {isNull, raw, equals as ==} for ShareClassId global;
+using {isNull, index, raw, equals as ==} for ShareClassId global;