@towns-protocol/contracts 0.0.302

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

@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// 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 {DeployPausable} from "@towns-protocol/diamond/scripts/deployments/facets/DeployPausable.sol";
+import {DeployMetadata} from "../facets/DeployMetadata.s.sol";
+import {DeploySwapRouterFacet} from "../facets/DeploySwapRouterFacet.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 DeploySwapRouter is IDiamondInitHelper, DiamondHelper, Deployer {
+    using LibString for string;
+
+    DeployFacet private facetHelper = new DeployFacet();
+    address private spaceFactory;
+
+    function versionName() public pure override returns (string memory) {
+        return "swapRouter";
+    }
+
+    function setDependencies(address spaceFactory_) external {
+        spaceFactory = spaceFactory_;
+    }
+
+    function getSpaceFactory() internal returns (address) {
+        if (spaceFactory != address(0)) return spaceFactory;
+        return getDeployment("spaceFactory");
+    }
+
+    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
+        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 additional facets for batch deployment
+        facetHelper.add("MultiInit");
+        facetHelper.add("SwapRouter");
+        facetHelper.add("MetadataFacet");
+        facetHelper.add("PausableFacet");
+
+        // Deploy all queued facets in a single batch transaction
+        facetHelper.deployBatch(deployer);
+
+        // Add each facet to the diamond cut using its deployment library
+        address facet = facetHelper.getDeployedAddress("SwapRouter");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeploySwapRouterFacet.selectors()),
+            facet,
+            DeploySwapRouterFacet.makeInitData(getSpaceFactory())
+        );
+
+        facet = facetHelper.getDeployedAddress("MetadataFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployMetadata.selectors()),
+            facet,
+            DeployMetadata.makeInitData(bytes32("SwapRouter"), "")
+        );
+
+        facet = facetHelper.getDeployedAddress("PausableFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployPausable.selectors()),
+            facet,
+            DeployPausable.makeInitData()
+        );
+
+        address multiInit = facetHelper.getDeployedAddress("MultiInit");
+
+        return
+            Diamond.InitParams({
+                baseFacets: baseFacets(),
+                init: multiInit,
+                initData: abi.encodeCall(MultiInit.multiInit, (_initAddresses, _initDatas))
+            });
+    }
+
+    function diamondInitParamsFromFacets(address deployer, string[] memory facetNames) public {
+        // Queue requested facets for batch deployment
+        for (uint256 i; i < facetNames.length; ++i) {
+            facetHelper.add(facetNames[i]);
+        }
+
+        // Deploy all requested facets in a single batch transaction
+        facetHelper.deployBatch(deployer);
+
+        for (uint256 i; i < facetNames.length; ++i) {
+            string memory facetName = facetNames[i];
+            address facet = facetHelper.getDeployedAddress(facetName);
+
+            if (facetName.eq("SwapRouter")) {
+                addFacet(
+                    makeCut(facet, FacetCutAction.Add, DeploySwapRouterFacet.selectors()),
+                    facet,
+                    DeploySwapRouterFacet.makeInitData(getSpaceFactory())
+                );
+            } else if (facetName.eq("MetadataFacet")) {
+                addFacet(
+                    makeCut(facet, FacetCutAction.Add, DeployMetadata.selectors()),
+                    facet,
+                    DeployMetadata.makeInitData(bytes32("SwapRouter"), "")
+                );
+            } else if (facetName.eq("PausableFacet")) {
+                addFacet(
+                    makeCut(facet, FacetCutAction.Add, DeployPausable.selectors()),
+                    facet,
+                    DeployPausable.makeInitData()
+                );
+            }
+        }
+    }
+
+    function diamondInitHelper(
+        address deployer,
+        string[] memory facetNames
+    ) external override returns (FacetCut[] memory) {
+        diamondInitParamsFromFacets(deployer, facetNames);
+        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/IDiamondInitHelper.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+
+interface IDiamondInitHelper is IDiamond {
+    function diamondInitHelper(
+        address deployer,
+        string[] memory facetNames
+    ) external returns (FacetCut[] memory);
+}

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

@@ -0,0 +1,51 @@
+// 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 {AppAccount} from "src/spaces/facets/account/AppAccount.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeployAppAccount {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(11);
+        arr.p(AppAccount.execute.selector);
+        arr.p(AppAccount.onInstallApp.selector);
+        arr.p(AppAccount.onUninstallApp.selector);
+        arr.p(AppAccount.onRenewApp.selector);
+        arr.p(AppAccount.isAppEntitled.selector);
+        arr.p(AppAccount.disableApp.selector);
+        arr.p(AppAccount.getInstalledApps.selector);
+        arr.p(AppAccount.getAppId.selector);
+        arr.p(AppAccount.enableApp.selector);
+        arr.p(AppAccount.getAppExpiration.selector);
+        arr.p(AppAccount.isAppInstalled.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({
+                action: action,
+                facetAddress: facetAddress,
+                functionSelectors: selectors()
+            });
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("AppAccount.sol", "");
+    }
+}

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

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+import {ISchemaResolver} from "@ethereum-attestation-service/eas-contracts/resolver/ISchemaResolver.sol";
+
+//libraries
+
+//contracts
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {AppRegistryFacet} from "src/apps/facets/registry/AppRegistryFacet.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeployAppRegistryFacet {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(16);
+        arr.p(AppRegistryFacet.getAppSchema.selector);
+        arr.p(AppRegistryFacet.getAppSchemaId.selector);
+        arr.p(AppRegistryFacet.getAppById.selector);
+        arr.p(AppRegistryFacet.getLatestAppId.selector);
+        arr.p(AppRegistryFacet.registerApp.selector);
+        arr.p(AppRegistryFacet.removeApp.selector);
+        arr.p(AppRegistryFacet.createApp.selector);
+        arr.p(AppRegistryFacet.installApp.selector);
+        arr.p(AppRegistryFacet.uninstallApp.selector);
+        arr.p(AppRegistryFacet.getAppPrice.selector);
+        arr.p(AppRegistryFacet.getAppDuration.selector);
+        arr.p(AppRegistryFacet.adminRegisterAppSchema.selector);
+        arr.p(AppRegistryFacet.adminBanApp.selector);
+        arr.p(AppRegistryFacet.isAppBanned.selector);
+        arr.p(AppRegistryFacet.getAppByClient.selector);
+        arr.p(AppRegistryFacet.renewApp.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({
+                action: action,
+                facetAddress: facetAddress,
+                functionSelectors: selectors()
+            });
+    }
+
+    function makeInitData(
+        address spaceFactory,
+        string memory schema,
+        address resolver
+    ) internal pure returns (bytes memory) {
+        return
+            abi.encodeCall(
+                AppRegistryFacet.__AppRegistry_init,
+                (spaceFactory, schema, ISchemaResolver(resolver))
+            );
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("AppRegistryFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+import {IArchitect} from "src/factory/facets/architect/IArchitect.sol";
+
+//libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+//contracts
+import {Architect} from "src/factory/facets/architect/Architect.sol";
+
+library DeployArchitect {
+    function selectors() internal pure returns (bytes4[] memory _selectors) {
+        _selectors = new bytes4[](6);
+        _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(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData(
+        address _spaceOwnerToken,
+        address _userEntitlement,
+        address _ruleEntitlement,
+        address _legacyRuleEntitlement
+    ) internal pure returns (bytes memory) {
+        return
+            abi.encodeWithSelector(
+                Architect.__Architect_init.selector,
+                _spaceOwnerToken,
+                _userEntitlement,
+                _ruleEntitlement,
+                _legacyRuleEntitlement
+            );
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("Architect.sol", "");
+    }
+}

package/scripts/deployments/facets/DeployAttestationRegistry.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
+
+//contracts
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {AttestationRegistry} from "src/apps/facets/attest/AttestationRegistry.sol";
+
+library DeployAttestationRegistry {
+    function selectors() internal pure returns (bytes4[] memory _selectors) {
+        _selectors = new bytes4[](3);
+        _selectors[0] = AttestationRegistry.attest.selector;
+        _selectors[1] = AttestationRegistry.revoke.selector;
+        _selectors[2] = AttestationRegistry.getAttestation.selector;
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return
+            IDiamond.FacetCut({
+                action: action,
+                facetAddress: facetAddress,
+                functionSelectors: selectors()
+            });
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("AttestationRegistry.sol", "");
+    }
+}

package/scripts/deployments/facets/DeployBanning.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 {IBanning} from "src/spaces/facets/banning/IBanning.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+library DeployBanning {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](4);
+        res[0] = IBanning.ban.selector;
+        res[1] = IBanning.unban.selector;
+        res[2] = IBanning.isBanned.selector;
+        res[3] = IBanning.banned.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("Banning.sol", "");
+    }
+}

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

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IChannel} from "src/spaces/facets/channels/IChannel.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+library DeployChannels {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](9);
+        res[0] = IChannel.createChannel.selector;
+        res[1] = IChannel.getChannel.selector;
+        res[2] = IChannel.getChannels.selector;
+        res[3] = IChannel.updateChannel.selector;
+        res[4] = IChannel.removeChannel.selector;
+        res[5] = IChannel.addRoleToChannel.selector;
+        res[6] = IChannel.getRolesByChannel.selector;
+        res[7] = IChannel.removeRoleFromChannel.selector;
+        res[8] = IChannel.createChannelWithOverridePermissions.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("Channels.sol", "");
+    }
+}

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

@@ -0,0 +1,42 @@
+// 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 {CreateSpaceFacet} from "src/factory/facets/create/CreateSpace.sol";
+
+library DeployCreateSpace {
+    function selectors() internal pure returns (bytes4[] memory _selectors) {
+        _selectors = new bytes4[](5);
+        // createSpace(SpaceInfo) - Basic space creation with SpaceInfo struct
+        _selectors[0] = 0xf822028d;
+        // createSpaceWithPrepay(CreateSpace) - Space creation with prepay (new format)
+        _selectors[1] = 0xcd55d94c;
+        // createSpaceWithPrepay(CreateSpaceOld) - Space creation with prepay (legacy format)
+        _selectors[2] = 0xc07ed896;
+        // createSpaceV2(CreateSpace, SpaceOptions) - Space creation with options
+        _selectors[3] = CreateSpaceFacet.createSpaceV2.selector;
+        // createSpace(Action, bytes) - Unified entry point with action dispatch
+        _selectors[4] = bytes4(keccak256("createSpace(uint8,bytes)"));
+    }
+
+    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(CreateSpaceFacet.__CreateSpace_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("CreateSpaceFacet", "");
+    }
+}

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

@@ -0,0 +1,49 @@
+// 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";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+// contracts
+import {DropFacet} from "src/airdrop/drop/DropFacet.sol";
+
+library DeployDropFacet {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(9);
+        arr.p(DropFacet.claimWithPenalty.selector);
+        arr.p(DropFacet.claimAndStake.selector);
+        arr.p(DropFacet.setClaimConditions.selector);
+        arr.p(DropFacet.addClaimCondition.selector);
+        arr.p(DropFacet.getActiveClaimConditionId.selector);
+        arr.p(DropFacet.getClaimConditionById.selector);
+        arr.p(DropFacet.getSupplyClaimedByWallet.selector);
+        arr.p(DropFacet.getDepositIdByWallet.selector);
+        arr.p(DropFacet.getClaimConditions.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(address stakingContract) internal pure returns (bytes memory) {
+        return abi.encodeCall(DropFacet.__DropFacet_init, (stakingContract));
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("DropFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,48 @@
+// 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 DeployERC721A {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(13);
+        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);
+        arr.p(IERC721A.tokenURI.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("ERC721A.sol", "");
+    }
+}

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

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+//interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/IDiamond.sol";
+import {IERC721A} from "src/diamond/facets/token/ERC721A/IERC721A.sol";
+
+//libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+
+//contracts
+import {ERC721A} from "src/diamond/facets/token/ERC721A/ERC721A.sol";
+
+library DeployERC721ANonTransferable {
+    function selectors() internal pure returns (bytes4[] memory res) {
+        res = new bytes4[](13);
+        res[0] = IERC721A.totalSupply.selector;
+        res[1] = IERC721A.balanceOf.selector;
+        res[2] = IERC721A.ownerOf.selector;
+        res[3] = IERC721A.transferFrom.selector;
+        res[4] = IERC721A.approve.selector;
+        res[5] = IERC721A.getApproved.selector;
+        res[6] = IERC721A.setApprovalForAll.selector;
+        res[7] = IERC721A.isApprovedForAll.selector;
+        res[8] = IERC721A.name.selector;
+        res[9] = IERC721A.symbol.selector;
+        res[10] = IERC721A.tokenURI.selector;
+        res[11] = bytes4(keccak256("safeTransferFrom(address,address,uint256)"));
+        res[12] = bytes4(keccak256("safeTransferFrom(address,address,uint256,bytes)"));
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function makeInitData(
+        string memory name,
+        string memory symbol
+    ) internal pure returns (bytes memory) {
+        return abi.encodeCall(ERC721A.__ERC721A_init, (name, symbol));
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("ERC721ANonTransferable.sol", "");
+    }
+}