@towns-protocol/contracts 0.0.302

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

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IERC721AQueryable} from "src/diamond/facets/token/ERC721A/extensions/IERC721AQueryable.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+library DeployERC721AQueryable {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](4);
+        res[0] = IERC721AQueryable.explicitOwnershipOf.selector;
+        res[1] = IERC721AQueryable.explicitOwnershipsOf.selector;
+        res[2] = IERC721AQueryable.tokensOfOwnerIn.selector;
+        res[3] = IERC721AQueryable.tokensOfOwner.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("ERC721AQueryable.sol", "");
+    }
+}

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

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+// contracts
+import {EntitlementChecker} from "src/base/registry/facets/checker/EntitlementChecker.sol";
+
+library DeployEntitlementChecker {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(9);
+        arr.p(EntitlementChecker.registerNode.selector);
+        arr.p(EntitlementChecker.unregisterNode.selector);
+        arr.p(EntitlementChecker.isValidNode.selector);
+        arr.p(EntitlementChecker.getNodeCount.selector);
+        arr.p(EntitlementChecker.getNodeAtIndex.selector);
+        arr.p(EntitlementChecker.getRandomNodes.selector);
+        arr.p(EntitlementChecker.requestEntitlementCheck.selector);
+        arr.p(EntitlementChecker.requestEntitlementCheckV2.selector);
+        arr.p(EntitlementChecker.getNodesByOperator.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    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(EntitlementChecker.__EntitlementChecker_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("EntitlementChecker.sol", "");
+    }
+}

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

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IEntitlementDataQueryable} from "src/spaces/facets/entitlements/extensions/IEntitlementDataQueryable.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+library DeployEntitlementDataQueryable {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](3);
+        res[0] = IEntitlementDataQueryable.getEntitlementDataByPermission.selector;
+        res[1] = IEntitlementDataQueryable.getChannelEntitlementDataByPermission.selector;
+        res[2] = IEntitlementDataQueryable.getCrossChainEntitlementData.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("EntitlementDataQueryable.sol", "");
+    }
+}

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

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IEntitlementsManager} from "src/spaces/facets/entitlements/IEntitlementsManager.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+library DeployEntitlementsManager {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](7);
+        res[0] = IEntitlementsManager.addImmutableEntitlements.selector;
+        res[1] = IEntitlementsManager.addEntitlementModule.selector;
+        res[2] = IEntitlementsManager.removeEntitlementModule.selector;
+        res[3] = IEntitlementsManager.getEntitlements.selector;
+        res[4] = IEntitlementsManager.getEntitlement.selector;
+        res[5] = IEntitlementsManager.isEntitledToSpace.selector;
+        res[6] = IEntitlementsManager.isEntitledToChannel.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("EntitlementsManager.sol", "");
+    }
+}

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

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IExecutor} from "src/spaces/facets/executor/IExecutor.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeployExecutorFacet {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(18);
+
+        // Access Management
+        arr.p(IExecutor.grantAccess.selector);
+        arr.p(IExecutor.revokeAccess.selector);
+        arr.p(IExecutor.renounceAccess.selector);
+        arr.p(IExecutor.setGuardian.selector);
+        arr.p(IExecutor.setGroupDelay.selector);
+        arr.p(IExecutor.setGroupExpiration.selector);
+        arr.p(IExecutor.grantAccessWithExpiration.selector);
+
+        // Target Management
+        arr.p(IExecutor.setTargetFunctionGroup.selector);
+        arr.p(IExecutor.setTargetDisabled.selector);
+
+        // Operation Management
+        arr.p(IExecutor.scheduleOperation.selector);
+        arr.p(IExecutor.execute.selector);
+        arr.p(IExecutor.cancel.selector);
+
+        // Getters
+        arr.p(IExecutor.hasAccess.selector);
+        arr.p(IExecutor.getAccess.selector);
+        arr.p(IExecutor.getGroupDelay.selector);
+        arr.p(IExecutor.getScheduleTimepoint.selector);
+        arr.p(IExecutor.onExecution.selector);
+        arr.p(IExecutor.hashOperation.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("ExecutorFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+//libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+//contracts
+import {FeatureManagerFacet} from "src/factory/facets/feature/FeatureManagerFacet.sol";
+
+library DeployFeatureManager {
+    function selectors() internal pure returns (bytes4[] memory _selectors) {
+        _selectors = new bytes4[](6);
+        _selectors[0] = FeatureManagerFacet.setFeatureCondition.selector;
+        _selectors[1] = FeatureManagerFacet.getFeatureCondition.selector;
+        _selectors[2] = FeatureManagerFacet.getFeatureConditions.selector;
+        _selectors[3] = FeatureManagerFacet.getFeatureConditionsForSpace.selector;
+        _selectors[4] = FeatureManagerFacet.checkFeatureCondition.selector;
+        _selectors[5] = FeatureManagerFacet.disableFeatureCondition.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(FeatureManagerFacet.__FeatureManagerFacet_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("FeatureManagerFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IGuardian} from "src/spaces/facets/guardian/IGuardian.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+// contracts
+import {GuardianFacet} from "src/spaces/facets/guardian/GuardianFacet.sol";
+
+library DeployGuardianFacet {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](6);
+        res[0] = IGuardian.enableGuardian.selector;
+        res[1] = IGuardian.guardianCooldown.selector;
+        res[2] = IGuardian.disableGuardian.selector;
+        res[3] = IGuardian.isGuardianEnabled.selector;
+        res[4] = IGuardian.getDefaultCooldown.selector;
+        res[5] = IGuardian.setDefaultCooldown.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData(uint256 cooldown) internal pure returns (bytes memory) {
+        return abi.encodeCall(GuardianFacet.__GuardianFacet_init, cooldown);
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("GuardianFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+// contracts
+import {ImplementationRegistryFacet} from "src/factory/facets/registry/ImplementationRegistry.sol";
+
+library DeployImplementationRegistry {
+    function selectors() internal pure returns (bytes4[] memory _selectors) {
+        _selectors = new bytes4[](4);
+        _selectors[0] = ImplementationRegistryFacet.addImplementation.selector;
+        _selectors[1] = ImplementationRegistryFacet.approveImplementation.selector;
+        _selectors[2] = ImplementationRegistryFacet.getImplementation.selector;
+        _selectors[3] = ImplementationRegistryFacet.getLatestImplementation.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(ImplementationRegistryFacet.__ImplementationRegistry_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("ImplementationRegistryFacet", "");
+    }
+}

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

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+
+//libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+//contracts
+import {MainnetDelegation} from "src/base/registry/facets/mainnet/MainnetDelegation.sol";
+
+library DeployMainnetDelegation {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(11);
+        arr.p(MainnetDelegation.setProxyDelegation.selector);
+        arr.p(MainnetDelegation.setDelegationDigest.selector);
+        arr.p(MainnetDelegation.relayDelegations.selector);
+        arr.p(MainnetDelegation.getMainnetDelegators.selector);
+        arr.p(MainnetDelegation.getDepositIdByDelegator.selector);
+        arr.p(MainnetDelegation.getDelegationByDelegator.selector);
+        arr.p(MainnetDelegation.getMainnetDelegationsByOperator.selector);
+        arr.p(MainnetDelegation.getDelegatedStakeByOperator.selector);
+        arr.p(MainnetDelegation.getAuthorizedClaimer.selector);
+        arr.p(MainnetDelegation.getProxyDelegation.selector);
+        arr.p(MainnetDelegation.getMessenger.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeInitData(address messenger) internal pure returns (bytes memory) {
+        return abi.encodeCall(MainnetDelegation.__MainnetDelegation_init, (messenger));
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("MainnetDelegation.sol", "");
+    }
+}

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

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IMembership} from "src/spaces/facets/membership/IMembership.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeployMembership {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(22);
+
+        // Funds
+        arr.p(IMembership.revenue.selector);
+
+        // Minting
+        arr.p(bytes4(keccak256("joinSpace(uint8,bytes)"))); // Unified joinSpace
+        arr.p(bytes4(keccak256("joinSpace(address)"))); // Legacy joinSpace
+        arr.p(IMembership.joinSpaceWithReferral.selector);
+        arr.p(IMembership.renewMembership.selector);
+
+        arr.p(IMembership.expiresAt.selector);
+
+        // Duration
+        arr.p(IMembership.getMembershipDuration.selector);
+        arr.p(IMembership.setMembershipDuration.selector);
+
+        // Pricing Module
+        arr.p(IMembership.setMembershipPricingModule.selector);
+        arr.p(IMembership.getMembershipPricingModule.selector);
+
+        // Pricing
+        arr.p(IMembership.setMembershipPrice.selector);
+        arr.p(IMembership.getMembershipPrice.selector);
+        arr.p(IMembership.getMembershipRenewalPrice.selector);
+        arr.p(IMembership.getProtocolFee.selector);
+
+        // Allocation
+        arr.p(IMembership.setMembershipFreeAllocation.selector);
+        arr.p(IMembership.getMembershipFreeAllocation.selector);
+
+        // Limits
+        arr.p(IMembership.setMembershipLimit.selector);
+        arr.p(IMembership.getMembershipLimit.selector);
+
+        // Currency
+        arr.p(IMembership.getMembershipCurrency.selector);
+
+        // Image
+        arr.p(IMembership.setMembershipImage.selector);
+        arr.p(IMembership.getMembershipImage.selector);
+
+        // Factory
+        arr.p(IMembership.getSpaceFactory.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("MembershipFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IMembershipMetadata} from "src/spaces/facets/membership/metadata/IMembershipMetadata.sol";
+
+//libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+//contracts
+
+library DeployMembershipMetadata {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](2);
+        res[0] = IMembershipMetadata.refreshMetadata.selector;
+        res[1] = IMembershipMetadata.tokenURI.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("MembershipMetadata.sol", "");
+    }
+}

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

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IERC721A} from "src/diamond/facets/token/ERC721A/IERC721A.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+// contracts
+
+library DeployMembershipToken {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectorsExceptTokenURI() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(12);
+        arr.p(IERC721A.totalSupply.selector);
+        arr.p(IERC721A.balanceOf.selector);
+        arr.p(IERC721A.ownerOf.selector);
+        arr.p(IERC721A.transferFrom.selector);
+        arr.p(IERC721A.approve.selector);
+        arr.p(IERC721A.getApproved.selector);
+        arr.p(IERC721A.setApprovalForAll.selector);
+        arr.p(IERC721A.isApprovedForAll.selector);
+        arr.p(bytes4(keccak256("safeTransferFrom(address,address,uint256)")));
+        arr.p(bytes4(keccak256("safeTransferFrom(address,address,uint256,bytes)")));
+        arr.p(IERC721A.name.selector);
+        arr.p(IERC721A.symbol.selector);
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectorsExceptTokenURI());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("MembershipToken.sol", "");
+    }
+}

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

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+//libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+//contracts
+import {MerkleAirdrop} from "src/utils/airdrop/merkle/MerkleAirdrop.sol";
+
+library DeployMerkleAirdrop {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](4);
+        res[0] = MerkleAirdrop.claim.selector;
+        res[1] = MerkleAirdrop.getMerkleRoot.selector;
+        res[2] = MerkleAirdrop.getToken.selector;
+        res[3] = MerkleAirdrop.getMessageHash.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData(bytes32 merkleRoot, address token) internal pure returns (bytes memory) {
+        return abi.encodeCall(MerkleAirdrop.__MerkleAirdrop_init, (merkleRoot, IERC20(token)));
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("MerkleAirdrop.sol", "");
+    }
+}

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

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+//libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+//contracts
+import {MetadataFacet} from "src/diamond/facets/metadata/MetadataFacet.sol";
+
+library DeployMetadata {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](4);
+        res[0] = MetadataFacet.contractType.selector;
+        res[1] = MetadataFacet.contractVersion.selector;
+        res[2] = MetadataFacet.contractURI.selector;
+        res[3] = MetadataFacet.setContractURI.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData(
+        bytes32 contractType,
+        string memory contractURI
+    ) internal pure returns (bytes memory) {
+        return abi.encodeCall(MetadataFacet.__MetadataFacet_init, (contractType, contractURI));
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("MetadataFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+
+//libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+//contracts
+import {MockLegacyArchitect} from "test/mocks/legacy/MockLegacyArchitect.sol";
+
+library DeployMockLegacyArchitect {
+    function selectors() internal pure returns (bytes4[] memory _selectors) {
+        _selectors = new bytes4[](1);
+        _selectors[0] = MockLegacyArchitect.createSpace.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(MockLegacyArchitect.__Architect_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("MockLegacyArchitect.sol", "");
+    }
+}