@towns-protocol/contracts 0.0.455 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.455",
+  "version": "1.0.2",
   "scripts": {
     "clean": "forge clean",
     "compile": "forge build",
@@ -25,7 +25,8 @@
     "account-abstraction": "github:eth-infinitism/account-abstraction#v0.7.0",
     "crypto-lib": "github:towns-protocol/crypto-lib#v1.0.1",
     "modular-account": "github:towns-protocol/modular-account#v1.0.0",
-    "solady": "^0.1.26"
+    "solady": "^0.1.26",
+    "ens-contracts": "github:ensdomains/ens-contracts#v1.6.0"
   },
   "devDependencies": {
     "@layerzerolabs/lz-evm-messagelib-v2": "^3.0.112",
@@ -49,6 +50,5 @@
   ],
   "publishConfig": {
     "access": "public"
-  },
-  "gitHead": "9a5d511378b12fca4eb316895e0bbfe137de137b"
+  }
 }

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

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IDiamondInitHelper} from "./IDiamondInitHelper.sol";
+
+// libraries
+import {DeployDiamondCut} from "@towns-protocol/diamond/scripts/deployments/facets/DeployDiamondCut.sol";
+import {DeployDiamondLoupe} from "@towns-protocol/diamond/scripts/deployments/facets/DeployDiamondLoupe.sol";
+import {DeployIntrospection} from "@towns-protocol/diamond/scripts/deployments/facets/DeployIntrospection.sol";
+import {DeployOwnable} from "@towns-protocol/diamond/scripts/deployments/facets/DeployOwnable.sol";
+import {DeployMetadata} from "../facets/DeployMetadata.s.sol";
+import {DeployL1ResolverFacet} from "../facets/DeployL1ResolverFacet.s.sol";
+import {LibString} from "solady/utils/LibString.sol";
+
+// contracts
+import {Diamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {MultiInit} from "@towns-protocol/diamond/src/initializers/MultiInit.sol";
+import {DiamondHelper} from "@towns-protocol/diamond/scripts/common/helpers/DiamondHelper.s.sol";
+
+// deployers
+import {DeployFacet} from "../../common/DeployFacet.s.sol";
+import {Deployer} from "../../common/Deployer.s.sol";
+
+contract DeployL1Resolver is IDiamondInitHelper, DiamondHelper, Deployer {
+    using LibString for string;
+
+    DeployFacet private facetHelper = new DeployFacet();
+
+    // Placeholder gateway URL - should be configured for production
+    string private GATEWAY_URL = "https://ccip.towns.app/v1/ccip-read/{sender}/{data}";
+    address private GATEWAY_SIGNER;
+
+    bytes32 internal constant METADATA_NAME = bytes32("L1Resolver");
+
+    function versionName() public pure override returns (string memory) {
+        return "l1Resolver";
+    }
+
+    function setGatewayURL(string memory gatewayUrl) external {
+        GATEWAY_URL = gatewayUrl;
+    }
+
+    function setGatewaySigner(address gatewaySigner) external {
+        GATEWAY_SIGNER = gatewaySigner;
+    }
+
+    function addImmutableCuts(address deployer) internal {
+        // Queue up all core facets for batch deployment
+        facetHelper.add("DiamondCutFacet");
+        facetHelper.add("DiamondLoupeFacet");
+        facetHelper.add("IntrospectionFacet");
+        facetHelper.add("OwnableFacet");
+
+        // Get predicted addresses and add facets
+        address facet = facetHelper.predictAddress("DiamondCutFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployDiamondCut.selectors()),
+            facet,
+            DeployDiamondCut.makeInitData()
+        );
+
+        facet = facetHelper.predictAddress("DiamondLoupeFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployDiamondLoupe.selectors()),
+            facet,
+            DeployDiamondLoupe.makeInitData()
+        );
+
+        facet = facetHelper.predictAddress("IntrospectionFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployIntrospection.selectors()),
+            facet,
+            DeployIntrospection.makeInitData()
+        );
+
+        facet = facetHelper.predictAddress("OwnableFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployOwnable.selectors()),
+            facet,
+            DeployOwnable.makeInitData(deployer)
+        );
+    }
+
+    function diamondInitParams(address deployer) public returns (Diamond.InitParams memory) {
+        // Use deployer as gateway signer if not set
+        address gatewaySigner = GATEWAY_SIGNER == address(0) ? deployer : GATEWAY_SIGNER;
+
+        // Queue up feature facets for batch deployment
+        facetHelper.add("MultiInit");
+        facetHelper.add("MetadataFacet");
+        facetHelper.add("L1ResolverFacet");
+
+        // Deploy the batch of facets
+        facetHelper.deployBatch(deployer);
+
+        // Add MetadataFacet
+        address facet = facetHelper.getDeployedAddress("MetadataFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployMetadata.selectors()),
+            facet,
+            DeployMetadata.makeInitData(METADATA_NAME, "")
+        );
+
+        // Add L1ResolverFacet
+        facet = facetHelper.getDeployedAddress("L1ResolverFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployL1ResolverFacet.selectors()),
+            facet,
+            DeployL1ResolverFacet.makeInitData(GATEWAY_URL, gatewaySigner)
+        );
+
+        address multiInit = facetHelper.getDeployedAddress("MultiInit");
+
+        return
+            Diamond.InitParams({
+                baseFacets: baseFacets(),
+                init: multiInit,
+                initData: abi.encodeCall(MultiInit.multiInit, (_initAddresses, _initDatas))
+            });
+    }
+
+    function diamondInitHelper(
+        address deployer,
+        string[] memory facetNames
+    ) external override returns (FacetCut[] memory) {
+        for (uint256 i; i < facetNames.length; ++i) {
+            facetHelper.add(facetNames[i]);
+        }
+
+        facetHelper.deployBatch(deployer);
+
+        for (uint256 i; i < facetNames.length; ++i) {
+            string memory facetName = facetNames[i];
+            address facet = facetHelper.getDeployedAddress(facetName);
+
+            if (facetName.eq("L1ResolverFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployL1ResolverFacet.selectors()));
+            }
+        }
+
+        return baseFacets();
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        addImmutableCuts(deployer);
+
+        Diamond.InitParams memory initDiamondCut = diamondInitParams(deployer);
+
+        vm.broadcast(deployer);
+        Diamond diamond = new Diamond(initDiamondCut);
+
+        return address(diamond);
+    }
+}

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

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IDiamondInitHelper} from "./IDiamondInitHelper.sol";
+
+// libraries
+import {DeployDiamondCut} from "@towns-protocol/diamond/scripts/deployments/facets/DeployDiamondCut.sol";
+import {DeployDiamondLoupe} from "@towns-protocol/diamond/scripts/deployments/facets/DeployDiamondLoupe.sol";
+import {DeployIntrospection} from "@towns-protocol/diamond/scripts/deployments/facets/DeployIntrospection.sol";
+import {DeployOwnable} from "@towns-protocol/diamond/scripts/deployments/facets/DeployOwnable.sol";
+import {DeployMetadata} from "../facets/DeployMetadata.s.sol";
+import {DeployL2RegistrarFacet} from "../facets/DeployL2RegistrarFacet.s.sol";
+import {LibString} from "solady/utils/LibString.sol";
+
+// contracts
+import {Diamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {MultiInit} from "@towns-protocol/diamond/src/initializers/MultiInit.sol";
+import {DiamondHelper} from "@towns-protocol/diamond/scripts/common/helpers/DiamondHelper.s.sol";
+
+// deployers
+import {DeployFacet} from "../../common/DeployFacet.s.sol";
+import {Deployer} from "../../common/Deployer.s.sol";
+
+contract DeployL2Registrar is IDiamondInitHelper, DiamondHelper, Deployer {
+    using LibString for string;
+
+    bytes32 internal constant METADATA_NAME = bytes32("L2Registrar");
+
+    DeployFacet private facetHelper = new DeployFacet();
+
+    address private REGISTRY;
+    address private SPACE_FACTORY;
+    address private USDC;
+
+    function setRegistry(address registry) external {
+        REGISTRY = registry;
+    }
+
+    function setSpaceFactory(address spaceFactory) external {
+        SPACE_FACTORY = spaceFactory;
+    }
+
+    function setUSDC(address usdc) external {
+        USDC = usdc;
+    }
+
+    function diamondInitHelper(
+        address deployer,
+        string[] memory facetNames
+    ) external override returns (FacetCut[] memory) {
+        for (uint256 i; i < facetNames.length; ++i) {
+            facetHelper.add(facetNames[i]);
+        }
+
+        facetHelper.deployBatch(deployer);
+
+        for (uint256 i; i < facetNames.length; ++i) {
+            string memory facetName = facetNames[i];
+            address facet = facetHelper.getDeployedAddress(facetName);
+
+            if (facetName.eq("L2RegistrarFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployL2RegistrarFacet.selectors()));
+            }
+        }
+
+        return baseFacets();
+    }
+
+    function diamondInitParams(address deployer) public returns (Diamond.InitParams memory) {
+        // Queue up feature facets for batch deployment
+        facetHelper.add("MultiInit");
+        facetHelper.add("MetadataFacet");
+        facetHelper.add("L2RegistrarFacet");
+
+        // Deploy the batch of facets
+        facetHelper.deployBatch(deployer);
+
+        // Add MetadataFacet
+        address facet = facetHelper.getDeployedAddress("MetadataFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployMetadata.selectors()),
+            facet,
+            DeployMetadata.makeInitData(METADATA_NAME, "")
+        );
+
+        // Add L2RegistrarFacet
+        facet = facetHelper.getDeployedAddress("L2RegistrarFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployL2RegistrarFacet.selectors()),
+            facet,
+            DeployL2RegistrarFacet.makeInitData(getRegistry(), getSpaceFactory(), getUSDC())
+        );
+
+        address multiInit = facetHelper.getDeployedAddress("MultiInit");
+
+        return
+            Diamond.InitParams({
+                baseFacets: baseFacets(),
+                init: multiInit,
+                initData: abi.encodeCall(MultiInit.multiInit, (_initAddresses, _initDatas))
+            });
+    }
+
+    function versionName() public pure override returns (string memory) {
+        return "l2Registrar";
+    }
+
+    function getRegistry() internal returns (address) {
+        if (REGISTRY == address(0)) return getDeployment("l2Resolver");
+        else return REGISTRY;
+    }
+
+    function getSpaceFactory() internal returns (address) {
+        if (SPACE_FACTORY == address(0)) return getDeployment("spaceFactory");
+        else return SPACE_FACTORY;
+    }
+
+    function getUSDC() internal returns (address) {
+        if (USDC == address(0)) return getDeployment("usdc");
+        else return USDC;
+    }
+
+    function addImmutableCuts(address deployer) internal {
+        // Queue up all core facets for batch deployment
+        facetHelper.add("DiamondCutFacet");
+        facetHelper.add("DiamondLoupeFacet");
+        facetHelper.add("IntrospectionFacet");
+        facetHelper.add("OwnableFacet");
+
+        // Get predicted addresses and add facets
+        address facet = facetHelper.predictAddress("DiamondCutFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployDiamondCut.selectors()),
+            facet,
+            DeployDiamondCut.makeInitData()
+        );
+
+        facet = facetHelper.predictAddress("DiamondLoupeFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployDiamondLoupe.selectors()),
+            facet,
+            DeployDiamondLoupe.makeInitData()
+        );
+
+        facet = facetHelper.predictAddress("IntrospectionFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployIntrospection.selectors()),
+            facet,
+            DeployIntrospection.makeInitData()
+        );
+
+        facet = facetHelper.predictAddress("OwnableFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployOwnable.selectors()),
+            facet,
+            DeployOwnable.makeInitData(deployer)
+        );
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        addImmutableCuts(deployer);
+
+        Diamond.InitParams memory initDiamondCut = diamondInitParams(deployer);
+
+        vm.broadcast(deployer);
+        Diamond diamond = new Diamond(initDiamondCut);
+
+        return address(diamond);
+    }
+}

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

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IDiamondInitHelper} from "./IDiamondInitHelper.sol";
+
+// libraries
+import {DeployDiamondCut} from "@towns-protocol/diamond/scripts/deployments/facets/DeployDiamondCut.sol";
+import {DeployDiamondLoupe} from "@towns-protocol/diamond/scripts/deployments/facets/DeployDiamondLoupe.sol";
+import {DeployIntrospection} from "@towns-protocol/diamond/scripts/deployments/facets/DeployIntrospection.sol";
+import {DeployOwnable} from "@towns-protocol/diamond/scripts/deployments/facets/DeployOwnable.sol";
+import {DeployMetadata} from "../facets/DeployMetadata.s.sol";
+import {DeployL2RegistryFacet} from "../facets/DeployL2RegistryFacet.s.sol";
+import {DeployAddrResolverFacet} from "../facets/DeployAddrResolverFacet.s.sol";
+import {DeployTextResolverFacet} from "../facets/DeployTextResolverFacet.s.sol";
+import {DeployExtendedResolverFacet} from "../facets/DeployExtendedResolverFacet.s.sol";
+import {DeployContentHashResolverFacet} from "../facets/DeployContentHashResolverFacet.s.sol";
+import {LibString} from "solady/utils/LibString.sol";
+
+// contracts
+import {Diamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {MultiInit} from "@towns-protocol/diamond/src/initializers/MultiInit.sol";
+import {DiamondHelper} from "@towns-protocol/diamond/scripts/common/helpers/DiamondHelper.s.sol";
+
+// deployers
+import {DeployFacet} from "../../common/DeployFacet.s.sol";
+import {Deployer} from "../../common/Deployer.s.sol";
+
+contract DeployL2Resolver is IDiamondInitHelper, DiamondHelper, Deployer {
+    using LibString for string;
+
+    DeployFacet private facetHelper = new DeployFacet();
+
+    string private DOMAIN = "towns.eth";
+
+    bytes32 internal constant METADATA_NAME = bytes32("L2Resolver");
+
+    function versionName() public pure override returns (string memory) {
+        return "l2Resolver";
+    }
+
+    function setDomain(string memory domain) external {
+        DOMAIN = domain;
+    }
+
+    function addImmutableCuts(address deployer) internal {
+        // Queue up all core facets for batch deployment
+        facetHelper.add("DiamondCutFacet");
+        facetHelper.add("DiamondLoupeFacet");
+        facetHelper.add("IntrospectionFacet");
+        facetHelper.add("OwnableFacet");
+
+        // Get predicted addresses and add facets
+        address facet = facetHelper.predictAddress("DiamondCutFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployDiamondCut.selectors()),
+            facet,
+            DeployDiamondCut.makeInitData()
+        );
+
+        facet = facetHelper.predictAddress("DiamondLoupeFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployDiamondLoupe.selectors()),
+            facet,
+            DeployDiamondLoupe.makeInitData()
+        );
+
+        facet = facetHelper.predictAddress("IntrospectionFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployIntrospection.selectors()),
+            facet,
+            DeployIntrospection.makeInitData()
+        );
+
+        facet = facetHelper.predictAddress("OwnableFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployOwnable.selectors()),
+            facet,
+            DeployOwnable.makeInitData(deployer)
+        );
+    }
+
+    function diamondInitParams(address deployer) public returns (Diamond.InitParams memory) {
+        // Queue up feature facets for batch deployment
+        facetHelper.add("MultiInit");
+        facetHelper.add("MetadataFacet");
+        facetHelper.add("L2RegistryFacet");
+        facetHelper.add("AddrResolverFacet");
+        facetHelper.add("TextResolverFacet");
+        facetHelper.add("ExtendedResolverFacet");
+        facetHelper.add("ContentHashResolverFacet");
+
+        // Deploy the batch of facets
+        facetHelper.deployBatch(deployer);
+
+        // Add MetadataFacet
+        address facet = facetHelper.getDeployedAddress("MetadataFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployMetadata.selectors()),
+            facet,
+            DeployMetadata.makeInitData(METADATA_NAME, "")
+        );
+
+        // Add L2RegistryFacet
+        facet = facetHelper.getDeployedAddress("L2RegistryFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployL2RegistryFacet.selectors()),
+            facet,
+            DeployL2RegistryFacet.makeInitData(DOMAIN, deployer)
+        );
+
+        // Add AddrResolverFacet
+        facet = facetHelper.getDeployedAddress("AddrResolverFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployAddrResolverFacet.selectors()),
+            facet,
+            DeployAddrResolverFacet.makeInitData()
+        );
+
+        // Add TextResolverFacet
+        facet = facetHelper.getDeployedAddress("TextResolverFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployTextResolverFacet.selectors()),
+            facet,
+            DeployTextResolverFacet.makeInitData()
+        );
+
+        // Add ExtendedResolverFacet
+        facet = facetHelper.getDeployedAddress("ExtendedResolverFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployExtendedResolverFacet.selectors()),
+            facet,
+            DeployExtendedResolverFacet.makeInitData()
+        );
+
+        // Add ContentHashResolverFacet
+        facet = facetHelper.getDeployedAddress("ContentHashResolverFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployContentHashResolverFacet.selectors()),
+            facet,
+            DeployContentHashResolverFacet.makeInitData()
+        );
+
+        address multiInit = facetHelper.getDeployedAddress("MultiInit");
+
+        return
+            Diamond.InitParams({
+                baseFacets: baseFacets(),
+                init: multiInit,
+                initData: abi.encodeCall(MultiInit.multiInit, (_initAddresses, _initDatas))
+            });
+    }
+
+    function diamondInitHelper(
+        address deployer,
+        string[] memory facetNames
+    ) external override returns (FacetCut[] memory) {
+        for (uint256 i; i < facetNames.length; ++i) {
+            facetHelper.add(facetNames[i]);
+        }
+
+        facetHelper.deployBatch(deployer);
+
+        for (uint256 i; i < facetNames.length; ++i) {
+            string memory facetName = facetNames[i];
+            address facet = facetHelper.getDeployedAddress(facetName);
+
+            if (facetName.eq("L2RegistryFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployL2RegistryFacet.selectors()));
+            } else if (facetName.eq("AddrResolverFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployAddrResolverFacet.selectors()));
+            } else if (facetName.eq("TextResolverFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployTextResolverFacet.selectors()));
+            } else if (facetName.eq("ExtendedResolverFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployExtendedResolverFacet.selectors()));
+            } else if (facetName.eq("ContentHashResolverFacet")) {
+                addCut(
+                    makeCut(facet, FacetCutAction.Add, DeployContentHashResolverFacet.selectors())
+                );
+            }
+        }
+
+        return baseFacets();
+    }
+
+    function __deploy(address deployer) internal override returns (address) {
+        addImmutableCuts(deployer);
+
+        Diamond.InitParams memory initDiamondCut = diamondInitParams(deployer);
+
+        vm.broadcast(deployer);
+        Diamond diamond = new Diamond(initDiamondCut);
+
+        return address(diamond);
+    }
+}

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/DeployAddrResolverFacet.s.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+// contracts
+import {AddrResolverFacet} from "src/domains/facets/l2/AddrResolverFacet.sol";
+
+library DeployAddrResolverFacet {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](4);
+        res[0] = bytes4(keccak256("setAddr(bytes32,uint256,bytes)"));
+        res[1] = bytes4(keccak256("setAddr(bytes32,address)"));
+        res[2] = bytes4(keccak256("addr(bytes32,uint256)"));
+        res[3] = bytes4(keccak256("addr(bytes32)"));
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData() internal pure returns (bytes memory) {
+        return abi.encodeCall(AddrResolverFacet.__AddrResolverFacet_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("AddrResolverFacet.sol", "");
+    }
+}

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/DeployContentHashResolverFacet.s.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+// contracts
+import {ContentHashResolverFacet} from "src/domains/facets/l2/ContentHashResolverFacet.sol";
+
+library DeployContentHashResolverFacet {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](2);
+        res[0] = ContentHashResolverFacet.setContenthash.selector;
+        res[1] = ContentHashResolverFacet.contenthash.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData() internal pure returns (bytes memory) {
+        return abi.encodeCall(ContentHashResolverFacet.__ContentHashResolverFacet_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("ContentHashResolverFacet.sol", "");
+    }
+}