@towns-protocol/contracts 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "scripts": {
     "clean": "forge clean",
     "compile": "forge build",
@@ -34,7 +34,7 @@
     "@layerzerolabs/oapp-evm": "^0.3.2",
     "@openzeppelin/merkle-tree": "^1.0.8",
     "@prb/test": "^0.6.4",
-    "@towns-protocol/prettier-config": "workspace:^",
+    "@towns-protocol/prettier-config": "^0.0.455",
     "@wagmi/cli": "^2.2.0",
     "forge-std": "github:foundry-rs/forge-std#v1.12.0",
     "prettier": "^3.5.3",

package/scripts/deployments/diamonds/DeployL2Registrar.s.sol

@@ -159,8 +159,6 @@ contract DeployL2Registrar is IDiamondInitHelper, DiamondHelper, Deployer {
     }
 
     function __deploy(address deployer) internal override returns (address) {
-        require(REGISTRY != address(0), "DeployL2Registrar: registry not set");
-
         addImmutableCuts(deployer);
 
         Diamond.InitParams memory initDiamondCut = diamondInitParams(deployer);

package/scripts/deployments/diamonds/DeploySpaceFactory.s.sol

@@ -15,7 +15,6 @@ import {DeployProxyManager} from "@towns-protocol/diamond/scripts/deployments/ut
 import {DeployFeatureManager} from "../facets/DeployFeatureManager.s.sol";
 import {DeployMetadata} from "../facets/DeployMetadata.s.sol";
 import {DeployPricingModules} from "../facets/DeployPricingModules.s.sol";
-import {DeploySpaceFactoryInit} from "../facets/DeploySpaceFactoryInit.s.sol";
 import {DeployArchitect} from "../facets/DeployArchitect.s.sol";
 import {DeployCreateSpace} from "../facets/DeployCreateSpace.s.sol";
 import {DeployImplementationRegistry} from "../facets/DeployImplementationRegistry.s.sol";
@@ -64,10 +63,6 @@ contract DeploySpaceFactory is IDiamondInitHelper, DiamondHelper, Deployer {
     address public fixedPricing;
     address public mockDelegationRegistry;
 
-    // init
-    address public spaceFactoryInit;
-    bytes public spaceFactoryInitData;
-
     function versionName() public pure override returns (string memory) {
         return "spaceFactory";
     }
@@ -150,8 +145,6 @@ contract DeploySpaceFactory is IDiamondInitHelper, DiamondHelper, Deployer {
         facetHelper.add("PartnerRegistry");
         facetHelper.add("FeatureManagerFacet");
         facetHelper.add("FeeManagerFacet");
-        facetHelper.add("SpaceProxyInitializer");
-        facetHelper.add("SpaceFactoryInit");
 
         if (isAnvil()) {
             facetHelper.add("MockDelegationRegistry");
@@ -277,11 +270,6 @@ contract DeploySpaceFactory is IDiamondInitHelper, DiamondHelper, Deployer {
             DeployFeeManager.makeInitData(deployer)
         );
 
-        address spaceProxyInitializer = facetHelper.getDeployedAddress("SpaceProxyInitializer");
-        spaceFactoryInit = facetHelper.getDeployedAddress("SpaceFactoryInit");
-        spaceFactoryInitData = DeploySpaceFactoryInit.makeInitData(spaceProxyInitializer);
-        addInit(spaceFactoryInit, spaceFactoryInitData);
-
         address multiInit = facetHelper.getDeployedAddress("MultiInit");
 
         return

package/scripts/deployments/facets/DeployArchitect.s.sol

@@ -13,13 +13,11 @@ import {Architect} from "src/factory/facets/architect/Architect.sol";
 
 library DeployArchitect {
     function selectors() internal pure returns (bytes4[] memory _selectors) {
-        _selectors = new bytes4[](6);
+        _selectors = new bytes4[](4);
         _selectors[0] = IArchitect.getSpaceByTokenId.selector;
         _selectors[1] = IArchitect.getTokenIdBySpace.selector;
         _selectors[2] = IArchitect.setSpaceArchitectImplementations.selector;
         _selectors[3] = IArchitect.getSpaceArchitectImplementations.selector;
-        _selectors[4] = IArchitect.setProxyInitializer.selector;
-        _selectors[5] = IArchitect.getProxyInitializer.selector;
     }
 
     function makeCut(

package/scripts/deployments/facets/DeployCreateSpace.s.sol

@@ -12,7 +12,7 @@ import {CreateSpaceFacet} from "src/factory/facets/create/CreateSpace.sol";
 
 library DeployCreateSpace {
     function selectors() internal pure returns (bytes4[] memory _selectors) {
-        _selectors = new bytes4[](5);
+        _selectors = new bytes4[](6);
         // createSpace(SpaceInfo) - Basic space creation with SpaceInfo struct
         _selectors[0] = 0xf822028d;
         // createSpaceWithPrepay(CreateSpace) - Space creation with prepay (new format)
@@ -23,6 +23,7 @@ library DeployCreateSpace {
         _selectors[3] = CreateSpaceFacet.createSpaceV2.selector;
         // createSpace(Action, bytes) - Unified entry point with action dispatch
         _selectors[4] = bytes4(keccak256("createSpace(uint8,bytes)"));
+        _selectors[5] = CreateSpaceFacet.getProxyInitializer.selector;
     }
 
     function makeCut(

package/scripts/deployments/facets/DeployNodeRegistry.s.sol

@@ -12,7 +12,7 @@ import {NodeRegistry} from "src/river/registry/facets/node/NodeRegistry.sol";
 
 library DeployNodeRegistry {
     function selectors() internal pure returns (bytes4[] memory res) {
-        res = new bytes4[](9);
+        res = new bytes4[](12);
         res[0] = NodeRegistry.isNode.selector;
         res[1] = NodeRegistry.registerNode.selector;
         res[2] = NodeRegistry.removeNode.selector;
@@ -22,6 +22,9 @@ library DeployNodeRegistry {
         res[6] = NodeRegistry.getNodeCount.selector;
         res[7] = NodeRegistry.getAllNodeAddresses.selector;
         res[8] = NodeRegistry.getAllNodes.selector;
+        res[9] = NodeRegistry.backfillPermanentIndices.selector;
+        res[10] = NodeRegistry.setNodeCometBftPubKey.selector;
+        res[11] = NodeRegistry.getLastNodeIndex.selector;
     }
 
     function makeCut(

package/scripts/deployments/utils/DeployDomainFeeHook.s.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {Deployer} from "../../common/Deployer.s.sol";
+import {DomainFeeHook} from "src/domains/hooks/DomainFeeHook.sol";
+
+contract DeployDomainFeeHook is Deployer {
+    /// @dev Default price for domain registration (5 USDC with 6 decimals)
+    uint256 internal constant DEFAULT_PRICE = 5e6;
+
+    address internal owner;
+    address internal feeManager;
+    uint256 internal defaultPrice;
+
+    function versionName() public pure override returns (string memory) {
+        return "utils/domainFeeHook";
+    }
+
+    /// @notice Set the owner address
+    /// @param owner_ The owner address for the DomainFeeHook
+    function setOwner(address owner_) external {
+        owner = owner_;
+    }
+
+    /// @notice Set the fee manager address
+    /// @param feeManager_ The fee manager address authorized to call onChargeFee
+    function setFeeManager(address feeManager_) external {
+        feeManager = feeManager_;
+    }
+
+    /// @notice Set the default price for registrations
+    /// @param defaultPrice_ The default price in USDC (6 decimals)
+    function setDefaultPrice(uint256 defaultPrice_) external {
+        defaultPrice = defaultPrice_;
+    }
+
+    /// @notice Set all deployment parameters at once
+    /// @param owner_ The owner address
+    /// @param feeManager_ The fee manager address
+    /// @param defaultPrice_ The default price for registrations
+    function setParams(address owner_, address feeManager_, uint256 defaultPrice_) external {
+        owner = owner_;
+        feeManager = feeManager_;
+        defaultPrice = defaultPrice_;
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        address ownerAddr = _getOwner(deployer);
+        address feeManagerAddr = _getFeeManager();
+        uint256 price = _getDefaultPrice();
+
+        require(ownerAddr != address(0), "DeployDomainFeeHook: owner not set");
+        require(feeManagerAddr != address(0), "DeployDomainFeeHook: feeManager not set");
+
+        vm.broadcast(deployer);
+        return address(new DomainFeeHook(ownerAddr, feeManagerAddr, price));
+    }
+
+    function _getOwner(address deployer) internal view returns (address) {
+        return owner == address(0) ? deployer : owner;
+    }
+
+    function _getFeeManager() internal returns (address) {
+        if (feeManager != address(0)) return feeManager;
+
+        // Try to get from existing deployments (spaceFactory acts as fee manager)
+        return getDeployment("spaceFactory");
+    }
+
+    function _getDefaultPrice() internal view returns (uint256) {
+        return defaultPrice == 0 ? DEFAULT_PRICE : defaultPrice;
+    }
+}

package/scripts/interactions/InteractAlphaPost.s.sol

@@ -2,10 +2,7 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-import {IArchitect} from "src/factory/facets/architect/IArchitect.sol";
-
 import {IPricingModules} from "src/factory/facets/architect/pricing/IPricingModules.sol";
-import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
 
 // deployment
 import {DeployTieredLogPricingV3} from "scripts/deployments/utils/DeployTieredLogPricingV3.s.sol";
@@ -19,13 +16,9 @@ contract InteractAlphaPost is Interaction {
     function __interact(address deployer) internal override {
         address spaceFactory = getDeployment("spaceFactory");
 
-        vm.setEnv("OVERRIDE_DEPLOYMENTS", "1");
-        vm.broadcast(deployer);
-        address spaceProxyInitializer = deployCode("SpaceProxyInitializer.sol", "");
         address tieredLogPricing = deployTieredLogPricingV3.deploy(deployer);
 
         vm.startBroadcast(deployer);
-        IArchitect(spaceFactory).setProxyInitializer(ISpaceProxyInitializer(spaceProxyInitializer));
         IPricingModules(spaceFactory).addPricingModule(tieredLogPricing);
         vm.stopBroadcast();
     }

package/scripts/interactions/InteractBaseAlpha.s.sol

@@ -37,20 +37,7 @@ contract InteractBaseAlpha is AlphaHelper {
 
         executeDiamondCutsWithLogging(deployer, space, "Space", deploySpace);
         executeDiamondCutsWithLogging(deployer, spaceOwner, "SpaceOwner", deploySpaceOwner);
-
-        deploySpaceFactory.diamondInitParams(deployer);
-        address spaceFactoryInit = deploySpaceFactory.spaceFactoryInit();
-        bytes memory initData = deploySpaceFactory.spaceFactoryInitData();
-        deploySpaceFactory.clearCuts();
-
-        executeDiamondCutsWithLogging(
-            deployer,
-            spaceFactory,
-            "SpaceFactory",
-            deploySpaceFactory,
-            spaceFactoryInit,
-            initData
-        );
+        executeDiamondCutsWithLogging(deployer, spaceFactory, "SpaceFactory", deploySpaceFactory);
 
         executeDiamondCutsWithLogging(deployer, baseRegistry, "BaseRegistry", deployBaseRegistry);
         executeDiamondCutsWithLogging(deployer, riverAirdrop, "RiverAirdrop", deployRiverAirdrop);

package/scripts/interactions/InteractDomainFee.s.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IFeeManager} from "src/factory/facets/fee/IFeeManager.sol";
+import {IPlatformRequirements} from "src/factory/facets/platform/requirements/IPlatformRequirements.sol";
+
+// libraries
+import {FeeTypesLib} from "src/factory/facets/fee/FeeTypesLib.sol";
+import {FeeCalculationMethod} from "src/factory/facets/fee/FeeManagerStorage.sol";
+import {console} from "forge-std/console.sol";
+
+// contracts
+import {Interaction} from "../common/Interaction.s.sol";
+
+/// @title InteractDomainFee
+/// @notice Interaction script to configure domain registration fee and hook
+contract InteractDomainFee is Interaction {
+    function __interact(address deployer) internal override {
+        address spaceFactory = getDeployment("spaceFactory");
+        address domainFeeHook = getDeployment("utils/domainFeeHook");
+
+        console.log("SpaceFactory Diamond:", spaceFactory);
+        console.log("Domain Fee Hook:", domainFeeHook);
+
+        // Get fee recipient from PlatformRequirementsFacet
+        address feeRecipient = IPlatformRequirements(spaceFactory).getFeeRecipient();
+        console.log("Fee Recipient:", feeRecipient);
+
+        // Set fee configuration for domain registration
+        // The hook will override the fee calculation, so we use FIXED with 0 values
+        console.log("\n=== Setting Fee Config for Domain Registration ===");
+        vm.broadcast(deployer);
+        IFeeManager(spaceFactory).setFeeConfig(
+            FeeTypesLib.DOMAIN_REGISTRATION,
+            feeRecipient, // recipient from PlatformRequirements
+            FeeCalculationMethod.FIXED, // method (hook overrides the calculation)
+            0, // bps (not used for FIXED)
+            0, // fixedFee (hook overrides)
+            true // enabled
+        );
+        console.log("Fee config set for DOMAIN_REGISTRATION");
+        console.log("  Recipient:", feeRecipient);
+        console.log("  Method: FIXED (hook overrides)");
+        console.log("  Enabled: true");
+
+        // Set the domain fee hook
+        console.log("\n=== Setting Domain Fee Hook ===");
+        vm.broadcast(deployer);
+        IFeeManager(spaceFactory).setFeeHook(FeeTypesLib.DOMAIN_REGISTRATION, domainFeeHook);
+        console.log("Fee hook set for DOMAIN_REGISTRATION:", domainFeeHook);
+
+        // Verify configuration
+        console.log("\n=== Verifying Configuration ===");
+        address configuredHook = IFeeManager(spaceFactory).getFeeHook(
+            FeeTypesLib.DOMAIN_REGISTRATION
+        );
+        console.log("Configured hook:", configuredHook);
+
+        console.log("\n=== Domain Fee Configuration Complete ===");
+    }
+}

package/scripts/interactions/InteractSetStreamDistributionBalancingAdvantage.s.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IRiverConfig} from "src/river/registry/facets/config/IRiverConfig.sol";
+
+// libraries
+import {RiverConfigValues} from "scripts/interactions/helpers/RiverConfigValues.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+/// @notice Sets the min and max balancing advantage for required operator node selection.
+/// @dev Values are in basis points (e.g., 500 = 5%, 750 = 7.5%).
+/// These settings control load balancing when selecting among required operator nodes:
+/// - MinBalancingAdvantage: Minimum advantage for less-loaded nodes (default: 500 = 5%)
+/// - MaxBalancingAdvantage: Maximum advantage for less-loaded nodes (default: 750 = 7.5%)
+contract InteractSetStreamDistributionBalancingAdvantage is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        // Values in basis points (100 = 1%, 500 = 5%, 750 = 7.5%)
+        uint64 minBalancingAdvantage = 500; // 5%
+        uint64 maxBalancingAdvantage = 750; // 7.5%
+
+        vm.startBroadcast(deployer);
+
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.STREAM_DISTRIBUTION_MIN_BALANCING_ADVANTAGE,
+            0, // blockNumber: 0 means effective immediately
+            abi.encode(minBalancingAdvantage)
+        );
+
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.STREAM_DISTRIBUTION_MAX_BALANCING_ADVANTAGE,
+            0, // blockNumber: 0 means effective immediately
+            abi.encode(maxBalancingAdvantage)
+        );
+
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/InteractSetStreamDistributionRequiredOperators.s.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IRiverConfig} from "src/river/registry/facets/config/IRiverConfig.sol";
+
+// libraries
+import {RiverConfigValues} from "scripts/interactions/helpers/RiverConfigValues.sol";
+
+// contracts
+import {Interaction} from "scripts/common/Interaction.s.sol";
+
+/// @notice Sets the required operators for stream placement.
+/// @dev When placing a stream, at least one node from a required operator must be selected
+/// if any required operator has operational nodes available.
+contract InteractSetStreamDistributionRequiredOperators is Interaction {
+    function __interact(address deployer) internal override {
+        address riverRegistry = getDeployment("riverRegistry");
+
+        // Configure the required operator addresses here
+        address[] memory requiredOperators = new address[](1);
+        requiredOperators[0] = address(0); // Replace with actual operator address
+
+        vm.startBroadcast(deployer);
+        IRiverConfig(riverRegistry).setConfiguration(
+            RiverConfigValues.STREAM_DISTRIBUTION_REQUIRED_OPERATORS,
+            0, // blockNumber: 0 means effective immediately
+            abi.encode(requiredOperators)
+        );
+        vm.stopBroadcast();
+    }
+}

package/scripts/interactions/helpers/RiverConfigValues.sol

@@ -24,4 +24,10 @@ library RiverConfigValues {
     bytes32 public constant STREAM_TRIM_ACTIVATION_FACTOR =
         keccak256("stream.trimactivationfactor");
     bytes32 public constant STREAM_TRIM_BY_STREAM_ID = keccak256("stream.trimbystreamid");
+    bytes32 public constant STREAM_DISTRIBUTION_REQUIRED_OPERATORS =
+        keccak256("stream.distribution.requiredoperators");
+    bytes32 public constant STREAM_DISTRIBUTION_MIN_BALANCING_ADVANTAGE =
+        keccak256("stream.distribution.minbalancingadvantage");
+    bytes32 public constant STREAM_DISTRIBUTION_MAX_BALANCING_ADVANTAGE =
+        keccak256("stream.distribution.maxbalancingadvantage");
 }

package/src/factory/facets/architect/Architect.sol

@@ -2,25 +2,30 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-import {IArchitect} from "src/factory/facets/architect/IArchitect.sol";
-import {IRuleEntitlement} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
-import {IRuleEntitlementV2} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
-
-import {IUserEntitlement} from "src/spaces/entitlements/user/IUserEntitlement.sol";
-import {ISpaceOwner} from "src/spaces/facets/owner/ISpaceOwner.sol";
-import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
+import {IRuleEntitlement} from "../../../spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IRuleEntitlementV2} from "../../../spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IUserEntitlement} from "../../../spaces/entitlements/user/IUserEntitlement.sol";
+import {ISpaceOwner} from "../../../spaces/facets/owner/ISpaceOwner.sol";
+import {IArchitect, IArchitectBase} from "./IArchitect.sol";
 
 // libraries
+import {ArchitectStorage} from "./ArchitectStorage.sol";
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {ImplementationStorage} from "./ImplementationStorage.sol";
 
 // contracts
-import {ArchitectBase} from "./ArchitectBase.sol";
-
 import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
 import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
 import {PausableBase} from "@towns-protocol/diamond/src/facets/pausable/PausableBase.sol";
 import {ReentrancyGuard} from "solady/utils/ReentrancyGuard.sol";
 
-contract Architect is IArchitect, ArchitectBase, OwnableBase, PausableBase, ReentrancyGuard, Facet {
+contract Architect is IArchitect, OwnableBase, PausableBase, ReentrancyGuard, Facet {
+    using CustomRevert for bytes4;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       INITIALIZATION                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
     function __Architect_init(
         ISpaceOwner ownerImplementation,
         IUserEntitlement userEntitlementImplementation,
@@ -35,23 +40,23 @@ contract Architect is IArchitect, ArchitectBase, OwnableBase, PausableBase, Reen
         );
     }
 
-    // =============================================================
-    //                            Space
-    // =============================================================
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           REGISTRY                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
     /// @inheritdoc IArchitect
     function getSpaceByTokenId(uint256 tokenId) external view returns (address) {
-        return _getSpaceByTokenId(tokenId);
+        return ArchitectStorage.layout().spaceByTokenId[tokenId];
     }
 
     /// @inheritdoc IArchitect
     function getTokenIdBySpace(address space) external view returns (uint256) {
-        return _getTokenIdBySpace(space);
+        return ArchitectStorage.layout().tokenIdBySpace[space];
     }
 
-    // =============================================================
-    //                         Implementations
-    // =============================================================
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      IMPLEMENTATIONS                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
     /// @inheritdoc IArchitect
     function setSpaceArchitectImplementations(
@@ -79,20 +84,34 @@ contract Architect is IArchitect, ArchitectBase, OwnableBase, PausableBase, Reen
             IRuleEntitlement legacyRuleEntitlement
         )
     {
-        return _getImplementations();
+        ImplementationStorage.Layout storage $ = ImplementationStorage.getStorage();
+        return ($.spaceOwnerToken, $.userEntitlement, $.ruleEntitlement, $.legacyRuleEntitlement);
     }
 
-    // =============================================================
-    //                         Proxy Initializer
-    // =============================================================
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          INTERNAL                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-    /// @inheritdoc IArchitect
-    function getProxyInitializer() external view returns (ISpaceProxyInitializer) {
-        return _getProxyInitializer();
-    }
+    function _setImplementations(
+        ISpaceOwner spaceOwnerToken,
+        IUserEntitlement userEntitlement,
+        IRuleEntitlementV2 ruleEntitlement,
+        IRuleEntitlement legacyRuleEntitlement
+    ) private {
+        if (address(spaceOwnerToken).code.length == 0) {
+            Architect__NotContract.selector.revertWith();
+        }
+        if (address(userEntitlement).code.length == 0) {
+            Architect__NotContract.selector.revertWith();
+        }
+        if (address(ruleEntitlement).code.length == 0) {
+            Architect__NotContract.selector.revertWith();
+        }
 
-    /// @inheritdoc IArchitect
-    function setProxyInitializer(ISpaceProxyInitializer proxyInitializer) external onlyOwner {
-        _setProxyInitializer(proxyInitializer);
+        ImplementationStorage.Layout storage $ = ImplementationStorage.getStorage();
+        $.spaceOwnerToken = spaceOwnerToken;
+        $.userEntitlement = userEntitlement;
+        $.ruleEntitlement = ruleEntitlement;
+        $.legacyRuleEntitlement = legacyRuleEntitlement;
     }
 }

package/src/factory/facets/architect/IArchitect.sol

@@ -6,7 +6,6 @@ import {IRuleEntitlement, IRuleEntitlementV2} from "../../../spaces/entitlements
 import {IUserEntitlement} from "../../../spaces/entitlements/user/IUserEntitlement.sol";
 import {IMembershipBase} from "../../../spaces/facets/membership/IMembership.sol";
 import {ISpaceOwner} from "../../../spaces/facets/owner/ISpaceOwner.sol";
-import {ISpaceProxyInitializer} from "../../../spaces/facets/proxy/ISpaceProxyInitializer.sol";
 
 interface IArchitectBase {
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
@@ -92,19 +91,14 @@ interface IArchitectBase {
     /*                           ERRORS                           */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-    error Architect__InvalidStringLength();
-    error Architect__InvalidNetworkId();
-    error Architect__InvalidAddress();
     error Architect__NotContract();
     error Architect__InvalidPricingModule();
     error Architect__UnexpectedETH();
-
-    event Architect__ProxyInitializerSet(address indexed proxyInitializer);
 }
 
 interface IArchitect is IArchitectBase {
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
-    /*                           Registry                         */
+    /*                           REGISTRY                         */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
     function getSpaceByTokenId(uint256 tokenId) external view returns (address space);
@@ -112,7 +106,7 @@ interface IArchitect is IArchitectBase {
     function getTokenIdBySpace(address space) external view returns (uint256);
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
-    /*                           Implementations                  */
+    /*                      IMPLEMENTATIONS                       */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
     function setSpaceArchitectImplementations(
@@ -131,17 +125,4 @@ interface IArchitect is IArchitectBase {
             IRuleEntitlementV2 ruleEntitlementImplementation,
             IRuleEntitlement legacyRuleEntitlement
         );
-
-    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
-    /*                           Proxy Initializer                */
-    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
-
-    /// @notice Retrieves the current proxy initializer
-    /// @return The address of the current ISpaceProxyInitializer contract
-    function getProxyInitializer() external view returns (ISpaceProxyInitializer);
-
-    /// @notice Sets a new proxy initializer
-    /// @param proxyInitializer The address of the new ISpaceProxyInitializer contract to be set
-    /// @dev This function should only be callable by the contract owner or authorized roles
-    function setProxyInitializer(ISpaceProxyInitializer proxyInitializer) external;
 }

package/src/factory/facets/architect/ImplementationStorage.sol

@@ -2,23 +2,16 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-
-import {IEntitlementChecker} from "src/base/registry/facets/checker/IEntitlementChecker.sol";
-import {IWalletLink} from "src/factory/facets/wallet-link/IWalletLink.sol";
-import {IRuleEntitlement} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
-import {IRuleEntitlementV2} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
-import {IUserEntitlement} from "src/spaces/entitlements/user/IUserEntitlement.sol";
-import {ISpaceOwner} from "src/spaces/facets/owner/ISpaceOwner.sol";
-import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
-// libraries
-
-// contracts
+import {IEntitlementChecker} from "../../../base/registry/facets/checker/IEntitlementChecker.sol";
+import {IRuleEntitlement, IRuleEntitlementV2} from "../../../spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IUserEntitlement} from "../../../spaces/entitlements/user/IUserEntitlement.sol";
+import {ISpaceOwner} from "../../../spaces/facets/owner/ISpaceOwner.sol";
+import {IWalletLink} from "../wallet-link/IWalletLink.sol";
 
 library ImplementationStorage {
     // keccak256(abi.encode(uint256(keccak256("spaces.facets.architect.implementation.storage")) -
-    // 1))
-    // & ~bytes32(uint256(0xff))
-    bytes32 internal constant SLOT_POSITION =
+    // 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
         0x9e34afa7b4d27d347d25d9d9dab4f1a106fa081382e6c4243e834d093e787d00;
 
     struct Layout {
@@ -28,15 +21,14 @@ library ImplementationStorage {
         IWalletLink walletLink;
         IEntitlementChecker entitlementChecker;
         IRuleEntitlement legacyRuleEntitlement;
-        ISpaceProxyInitializer proxyInitializer;
+        /// @dev Deprecated: SpaceProxyInitializer is now deployed via CREATE2 in CreateSpaceBase.
+        /// Slot preserved for storage layout compatibility.
+        address _proxyInitializer;
     }
 
-    function layout() internal pure returns (Layout storage ds) {
-        bytes32 position = SLOT_POSITION;
-
-        // solhint-disable-next-line no-inline-assembly
+    function getStorage() internal pure returns (Layout storage $) {
         assembly {
-            ds.slot := position
+            $.slot := STORAGE_SLOT
         }
     }
 }

package/src/factory/facets/create/CreateSpace.sol

@@ -99,4 +99,9 @@ contract CreateSpaceFacet is ICreateSpace, PausableBase, ReentrancyGuard, Create
         SpaceOptions memory spaceOptions = SpaceOptions({to: msg.sender});
         return _createSpaceWithPrepayFromLegacy(spaceInfo, spaceOptions);
     }
+
+    /// @inheritdoc ICreateSpace
+    function getProxyInitializer() external view returns (address) {
+        return _getProxyInitializer();
+    }
 }