@towns-protocol/contracts 0.0.439 → 0.0.441

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.439",
+  "version": "0.0.441",
   "scripts": {
     "clean": "forge clean",
     "compile": "forge build",
@@ -33,7 +33,7 @@
     "@layerzerolabs/oapp-evm": "^0.3.2",
     "@openzeppelin/merkle-tree": "^1.0.8",
     "@prb/test": "^0.6.4",
-    "@towns-protocol/prettier-config": "^0.0.439",
+    "@towns-protocol/prettier-config": "^0.0.441",
     "@wagmi/cli": "^2.2.0",
     "forge-std": "github:foundry-rs/forge-std#v1.10.0",
     "prettier": "^3.5.3",
@@ -50,5 +50,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "8e9e84d7be1d6fb6eadbd24b67db8bc7d495cc4c"
+  "gitHead": "7b6cdd45d3c3c2e94efdb26a68f4c8ff11e3699f"
 }

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

@@ -0,0 +1,188 @@
+// 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 {DeployMetadata} from "../facets/DeployMetadata.s.sol";
+import {DeployAccountHubFacet} from "../facets/DeployAccountHubFacet.s.sol";
+import {DeployAppManagerFacet} from "../facets/DeployAppManagerFacet.s.sol";
+import {DeployAccountTippingFacet} from "../facets/DeployAccountTippingFacet.s.sol";
+import {DeploySpaceFactory} from "./DeploySpaceFactory.s.sol";
+import {DeployAppRegistry} from "./DeployAppRegistry.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 DeployAccountModules is IDiamondInitHelper, DiamondHelper, Deployer {
+    using LibString for string;
+
+    DeployFacet private facetHelper = new DeployFacet();
+    DeploySpaceFactory private deploySpaceFactory = new DeploySpaceFactory();
+    DeployAppRegistry private deployAppRegistry = new DeployAppRegistry();
+
+    address public spaceFactory;
+    address public appRegistry;
+
+    bytes32 internal constant METADATA_NAME = bytes32("AccountModules");
+
+    function versionName() public pure override returns (string memory) {
+        return "accountModules";
+    }
+
+    function setDependencies(address spaceFactory_, address appRegistry_) external {
+        spaceFactory = spaceFactory_;
+        appRegistry = appRegistry_;
+    }
+
+    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("AccountHubFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployAccountHubFacet.selectors()));
+            }
+            if (facetName.eq("AppManagerFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployAppManagerFacet.selectors()));
+            }
+            if (facetName.eq("AccountTippingFacet")) {
+                addCut(makeCut(facet, FacetCutAction.Add, DeployAccountTippingFacet.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("AccountHubFacet");
+        facetHelper.add("AppManagerFacet");
+        facetHelper.add("AccountTippingFacet");
+
+        facetHelper.deployBatch(deployer);
+
+        // Add feature facets
+        address facet = facetHelper.getDeployedAddress("MetadataFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployMetadata.selectors()),
+            facet,
+            DeployMetadata.makeInitData(METADATA_NAME, "")
+        );
+
+        facet = facetHelper.getDeployedAddress("AccountHubFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployAccountHubFacet.selectors()),
+            facet,
+            DeployAccountHubFacet.makeInitData(spaceFactory, appRegistry)
+        );
+
+        facet = facetHelper.getDeployedAddress("AppManagerFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployAppManagerFacet.selectors()),
+            facet,
+            DeployAppManagerFacet.makeInitData()
+        );
+
+        facet = facetHelper.getDeployedAddress("AccountTippingFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployAccountTippingFacet.selectors()),
+            facet,
+            DeployAccountTippingFacet.makeInitData()
+        );
+
+        address multiInit = facetHelper.getDeployedAddress("MultiInit");
+
+        return
+            Diamond.InitParams({
+                baseFacets: baseFacets(),
+                init: multiInit,
+                initData: abi.encodeCall(MultiInit.multiInit, (_initAddresses, _initDatas))
+            });
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          Internal                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _resolveDependencies(address deployer) internal {
+        spaceFactory = spaceFactory == address(0)
+            ? deploySpaceFactory.deploy(deployer)
+            : spaceFactory;
+        appRegistry = appRegistry == address(0) ? deployAppRegistry.deploy(deployer) : appRegistry;
+    }
+
+    function _coreFacets(address deployer) internal {
+        // Deploy dependencies
+        _resolveDependencies(deployer);
+
+        // 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 __deploy(address deployer) internal override returns (address) {
+        _coreFacets(deployer);
+
+        Diamond.InitParams memory initDiamondCut = diamondInitParams(deployer);
+
+        vm.broadcast(deployer);
+        Diamond diamond = new Diamond(initDiamondCut);
+
+        return address(diamond);
+    }
+}

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

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+
+// contracts
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {AccountHubFacet} from "src/account/facets/hub/AccountHubFacet.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeployAccountHubFacet {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(11);
+
+        // ERC-6900 functions
+        arr.p(AccountHubFacet.moduleId.selector);
+        arr.p(AccountHubFacet.onInstall.selector);
+        arr.p(AccountHubFacet.onUninstall.selector);
+        arr.p(AccountHubFacet.preExecutionHook.selector);
+        arr.p(AccountHubFacet.postExecutionHook.selector);
+        arr.p(AccountHubFacet.executionManifest.selector);
+
+        // External functions
+        arr.p(AccountHubFacet.setSpaceFactory.selector);
+        arr.p(AccountHubFacet.setAppRegistry.selector);
+        arr.p(AccountHubFacet.getSpaceFactory.selector);
+        arr.p(AccountHubFacet.getAppRegistry.selector);
+        arr.p(AccountHubFacet.isInstalled.selector);
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeInitData(
+        address spaceFactory,
+        address appRegistry
+    ) internal pure returns (bytes memory) {
+        return abi.encodeCall(AccountHubFacet.__AccountHubFacet_init, (spaceFactory, appRegistry));
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("AccountHubFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// contracts
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {AccountTippingFacet} from "src/account/facets/tipping/AccountTippingFacet.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeployAccountTippingFacet {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(8);
+
+        arr.p(AccountTippingFacet.sendTip.selector);
+        arr.p(AccountTippingFacet.tip.selector);
+        arr.p(AccountTippingFacet.tipsByWalletAndCurrency.selector);
+        arr.p(AccountTippingFacet.tipCountByWalletAndCurrency.selector);
+        arr.p(AccountTippingFacet.tipsByCurrencyAndTokenId.selector);
+        arr.p(AccountTippingFacet.tippingCurrencies.selector);
+        arr.p(AccountTippingFacet.totalTipsByCurrency.selector);
+        arr.p(AccountTippingFacet.tipAmountByCurrency.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeInitData() internal pure returns (bytes memory) {
+        return abi.encodeCall(AccountTippingFacet.__AccountTippingFacet_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("AccountTippingFacet.sol", "");
+    }
+}

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

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// contracts
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {AppManagerFacet} from "src/account/facets/app/AppManagerFacet.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeployAppManagerFacet {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(11);
+
+        arr.p(AppManagerFacet.onInstallApp.selector);
+        arr.p(AppManagerFacet.onUninstallApp.selector);
+        arr.p(AppManagerFacet.onRenewApp.selector);
+        arr.p(AppManagerFacet.onUpdateApp.selector);
+        arr.p(AppManagerFacet.enableApp.selector);
+        arr.p(AppManagerFacet.disableApp.selector);
+        arr.p(AppManagerFacet.isAppInstalled.selector);
+        arr.p(AppManagerFacet.getAppId.selector);
+        arr.p(AppManagerFacet.getAppExpiration.selector);
+        arr.p(AppManagerFacet.getInstalledApps.selector);
+        arr.p(AppManagerFacet.isAppEntitled.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeInitData() internal pure returns (bytes memory) {
+        return abi.encodeCall(AppManagerFacet.__AppManagerFacet_init, ());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("AppManagerFacet.sol", "");
+    }
+}

package/src/account/facets/app/AppManagerFacet.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IAppAccount} from "src/spaces/facets/account/IAppAccount.sol";
+
+// libraries
+import "./AppManagerMod.sol" as AppManager;
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {ReentrancyGuardTransient} from "solady/utils/ReentrancyGuardTransient.sol";
+
+contract AppManagerFacet is IAppAccount, ReentrancyGuardTransient, Facet {
+    function __AppManagerFacet_init() external onlyInitializing {
+        _addInterface(type(IAppAccount).interfaceId);
+    }
+
+    function __AppManagerFacet_init_unchained() internal {}
+
+    function onInstallApp(bytes32 appId, bytes calldata data) external nonReentrant {
+        AppManager.installApp(msg.sender, appId, data);
+    }
+
+    function onUninstallApp(bytes32 appId, bytes calldata data) external nonReentrant {
+        AppManager.uninstallApp(msg.sender, appId, data);
+    }
+
+    function onRenewApp(bytes32 appId, bytes calldata data) external nonReentrant {
+        AppManager.renewApp(msg.sender, appId, data);
+    }
+
+    function onUpdateApp(bytes32 appId, bytes calldata data) external nonReentrant {
+        AppManager.updateApp(msg.sender, appId, data);
+    }
+
+    function enableApp(address app) external nonReentrant {
+        AppManager.enableApp(msg.sender, app);
+    }
+
+    function disableApp(address app) external nonReentrant {
+        AppManager.disableApp(msg.sender, app);
+    }
+
+    function isAppInstalled(address app) external view returns (bool) {
+        return AppManager.isAppInstalled(msg.sender, app);
+    }
+
+    function getAppId(address app) external view returns (bytes32) {
+        return AppManager.getAppId(msg.sender, app);
+    }
+
+    function getAppExpiration(address app) external view returns (uint48) {
+        return AppManager.getAppExpiration(msg.sender, app);
+    }
+
+    function getInstalledApps() external view returns (address[] memory) {
+        return AppManager.getInstalledApps(msg.sender);
+    }
+
+    function isAppEntitled(
+        address app,
+        address publicKey,
+        bytes32 permission
+    ) external view returns (bool) {
+        return AppManager.isAppEntitled(msg.sender, app, publicKey, permission);
+    }
+}