@towns-protocol/contracts 0.0.336 → 0.0.338

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.336",
+  "version": "0.0.338",
   "packageManager": "yarn@3.8.0",
   "scripts": {
     "build-types": "bash scripts/build-contract-types.sh",
@@ -25,6 +25,7 @@
     "@towns-protocol/diamond": "^0.6.3",
     "@uniswap/permit2": "https://github.com/towns-protocol/permit2/archive/refs/tags/v1.0.0.tar.gz",
     "crypto-lib": "https://github.com/towns-protocol/crypto-lib/archive/refs/tags/v1.0.0.tar.gz",
+    "modular-account": "https://github.com/towns-protocol/modular-account/archive/refs/tags/v1.0.0.tar.gz",
     "solady": "^0.1.24"
   },
   "devDependencies": {
@@ -33,7 +34,7 @@
     "@layerzerolabs/oapp-evm": "^0.3.2",
     "@openzeppelin/merkle-tree": "^1.0.8",
     "@prb/test": "^0.6.4",
-    "@towns-protocol/prettier-config": "^0.0.336",
+    "@towns-protocol/prettier-config": "^0.0.338",
     "@typechain/ethers-v5": "^10.1.1",
     "@wagmi/cli": "^2.2.0",
     "account-abstraction": "https://github.com/eth-infinitism/account-abstraction/archive/refs/tags/v0.7.0.tar.gz",
@@ -56,5 +57,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "71595d375f76d341ff01c55a0fb3d749c04d710f"
+  "gitHead": "c6e34eeab8c1753ecae0ed36e1953f2a828f08d8"
 }

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

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// 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 {DeploySubscriptionModuleFacet} from "../facets/DeploySubscriptionModuleFacet.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 DeploySubscriptionModule is DiamondHelper, Deployer {
+    using LibString for string;
+
+    DeployFacet private facetHelper = new DeployFacet();
+
+    bytes32 internal constant METADATA_NAME = bytes32("SubscriptionModule");
+
+    function versionName() public pure override returns (string memory) {
+        return "subscriptionModule";
+    }
+
+    function diamondInitParams(address deployer) public returns (Diamond.InitParams memory) {
+        // Queue up feature facets for batch deployment
+        facetHelper.add("MultiInit");
+        facetHelper.add("SubscriptionModuleFacet");
+
+        // Deploy all facets in a batch
+        facetHelper.deployBatch(deployer);
+
+        // Add feature facets
+        address facet = facetHelper.getDeployedAddress("SubscriptionModuleFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeploySubscriptionModuleFacet.selectors()),
+            facet,
+            DeploySubscriptionModuleFacet.makeInitData()
+        );
+
+        address multiInit = facetHelper.getDeployedAddress("MultiInit");
+
+        return
+            Diamond.InitParams({
+                baseFacets: baseFacets(),
+                init: multiInit,
+                initData: abi.encodeCall(MultiInit.multiInit, (_initAddresses, _initDatas))
+            });
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          Internal                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _coreFacets(address deployer) private {
+        // Queue up all core facets for batch deployment
+        facetHelper.add("DiamondCutFacet");
+        facetHelper.add("DiamondLoupeFacet");
+        facetHelper.add("IntrospectionFacet");
+        facetHelper.add("OwnableFacet");
+        facetHelper.add("MetadataFacet");
+
+        // 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)
+        );
+
+        facet = facetHelper.predictAddress("MetadataFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployMetadata.selectors()),
+            facet,
+            DeployMetadata.makeInitData(METADATA_NAME, "")
+        );
+    }
+
+    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/diamonds/IDiamondInitHelper.sol

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

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

@@ -15,11 +15,12 @@ library DeployAppAccount {
     using DynamicArrayLib for DynamicArrayLib.DynamicArray;
 
     function selectors() internal pure returns (bytes4[] memory res) {
-        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(11);
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(12);
         arr.p(AppAccount.execute.selector);
         arr.p(AppAccount.onInstallApp.selector);
         arr.p(AppAccount.onUninstallApp.selector);
         arr.p(AppAccount.onRenewApp.selector);
+        arr.p(AppAccount.isAppExecuting.selector);
         arr.p(AppAccount.isAppEntitled.selector);
         arr.p(AppAccount.disableApp.selector);
         arr.p(AppAccount.getInstalledApps.selector);

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

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.29;
 
-import {SimpleApp} from "src/apps/helpers/SimpleApp.sol";
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
 
 library DeploySimpleApp {
     function deploy() internal returns (address) {
-        return address(new SimpleApp());
+        return LibDeploy.deployCode("SimpleApp.sol", "");
     }
 }

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

@@ -0,0 +1,65 @@
+// 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 {SubscriptionModuleFacet} from "../../../src/apps/modules/subscription/SubscriptionModuleFacet.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeploySubscriptionModuleFacet {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(20);
+        arr.p(SubscriptionModuleFacet.moduleId.selector);
+        arr.p(SubscriptionModuleFacet.onInstall.selector);
+        arr.p(SubscriptionModuleFacet.onUninstall.selector);
+        arr.p(SubscriptionModuleFacet.validateUserOp.selector);
+        arr.p(SubscriptionModuleFacet.validateSignature.selector);
+        arr.p(SubscriptionModuleFacet.validateRuntime.selector);
+        arr.p(SubscriptionModuleFacet.preUserOpValidationHook.selector);
+        arr.p(SubscriptionModuleFacet.preRuntimeValidationHook.selector);
+        arr.p(SubscriptionModuleFacet.preSignatureValidationHook.selector);
+        arr.p(SubscriptionModuleFacet.batchProcessRenewals.selector);
+        arr.p(SubscriptionModuleFacet.processRenewal.selector);
+        arr.p(SubscriptionModuleFacet.getSubscription.selector);
+        arr.p(SubscriptionModuleFacet.pauseSubscription.selector);
+        arr.p(SubscriptionModuleFacet.getEntityIds.selector);
+        arr.p(SubscriptionModuleFacet.isOperator.selector);
+        arr.p(SubscriptionModuleFacet.grantOperator.selector);
+        arr.p(SubscriptionModuleFacet.revokeOperator.selector);
+        arr.p(bytes4(keccak256("MAX_BATCH_SIZE()")));
+        arr.p(bytes4(keccak256("RENEWAL_BUFFER()")));
+        arr.p(bytes4(keccak256("GRACE_PERIOD()")));
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeInitData() internal pure returns (bytes memory) {
+        return abi.encodeCall(SubscriptionModuleFacet.__SubscriptionModule_init, ());
+    }
+
+    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("SubscriptionModuleFacet.sol", "");
+    }
+}

package/scripts/interactions/InteractBaseAlpha.s.sol

@@ -2,10 +2,8 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
 
 // libraries
-import {console} from "forge-std/console.sol";
 
 // contracts
 import {DeployBaseRegistry} from "scripts/deployments/diamonds/DeployBaseRegistry.s.sol";
@@ -34,141 +32,24 @@ contract InteractBaseAlpha is AlphaHelper {
         address riverAirdrop = getDeployment("riverAirdrop");
         address appRegistry = getDeployment("appRegistry");
 
-        deploySpaceCuts(deployer, space);
-        deploySpaceOwnerCuts(deployer, spaceOwner);
-        deploySpaceFactoryCuts(deployer, spaceFactory);
-        deployBaseRegistryCuts(deployer, baseRegistry);
-        deployRiverAirdropCuts(deployer, riverAirdrop);
-        deployAppRegistryCuts(deployer, appRegistry);
-
-        vm.resumeGasMetering();
-    }
-
-    function deploySpaceCuts(address deployer, address space) internal {
-        console.log("[INFO]: === Upgrading Space diamond ===");
-        deploySpace.diamondInitParams(deployer);
-        FacetCut[] memory proposedCuts = deploySpace.getCuts();
-        FacetCut[] memory smartCuts = generateSmartCuts(space, proposedCuts);
-
-        console.log(
-            "[INFO]: Generated %d smart cuts from %d proposed cuts",
-            smartCuts.length,
-            proposedCuts.length
-        );
-
-        if (smartCuts.length > 0) {
-            vm.broadcast(deployer);
-            IDiamondCut(space).diamondCut(smartCuts, address(0), "");
-            console.log("[INFO]: \u2705 Space diamond upgrade completed");
-        } else {
-            console.log("[INFO]: Space diamond already up to date - no cuts needed");
-        }
-    }
-
-    function deploySpaceOwnerCuts(address deployer, address spaceOwner) internal {
-        console.log("[INFO]: === Upgrading SpaceOwner diamond ===");
-        deploySpaceOwner.diamondInitParams(deployer);
-        FacetCut[] memory proposedCuts = deploySpaceOwner.getCuts();
-        FacetCut[] memory smartCuts = generateSmartCuts(spaceOwner, proposedCuts);
-
-        console.log(
-            "[INFO]: Generated %d smart cuts from %d proposed cuts",
-            smartCuts.length,
-            proposedCuts.length
-        );
-
-        if (smartCuts.length > 0) {
-            vm.broadcast(deployer);
-            IDiamondCut(spaceOwner).diamondCut(smartCuts, address(0), "");
-            console.log("[INFO]: \u2705 SpaceOwner diamond upgrade completed");
-        } else {
-            console.log("[INFO]: SpaceOwner diamond already up to date - no cuts needed");
-        }
-    }
-
-    function deploySpaceFactoryCuts(address deployer, address spaceFactory) internal {
-        console.log("[INFO]: === Upgrading SpaceFactory diamond ===");
-        deploySpaceFactory.diamondInitParams(deployer);
-        FacetCut[] memory proposedCuts = deploySpaceFactory.getCuts();
-        FacetCut[] memory smartCuts = generateSmartCuts(spaceFactory, proposedCuts);
-
-        console.log(
-            "[INFO]: Generated %d smart cuts from %d proposed cuts",
-            smartCuts.length,
-            proposedCuts.length
+        executeDiamondCutsWithLogging(deployer, space, "Space", deploySpace);
+        executeDiamondCutsWithLogging(deployer, spaceOwner, "SpaceOwner", deploySpaceOwner);
+
+        address spaceFactoryInit = deploySpaceFactory.spaceFactoryInit();
+        bytes memory initData = deploySpaceFactory.spaceFactoryInitData();
+        executeDiamondCutsWithLogging(
+            deployer,
+            spaceFactory,
+            "SpaceFactory",
+            deploySpaceFactory,
+            spaceFactoryInit,
+            initData
         );
 
-        if (smartCuts.length > 0) {
-            address spaceFactoryInit = deploySpaceFactory.spaceFactoryInit();
-            bytes memory initData = deploySpaceFactory.spaceFactoryInitData();
-            vm.broadcast(deployer);
-            IDiamondCut(spaceFactory).diamondCut(smartCuts, spaceFactoryInit, initData);
-            console.log("[INFO]: \u2705 SpaceFactory diamond upgrade completed");
-        } else {
-            console.log("[INFO]: SpaceFactory diamond already up to date - no cuts needed");
-        }
-    }
-
-    function deployBaseRegistryCuts(address deployer, address baseRegistry) internal {
-        console.log("[INFO]: === Upgrading BaseRegistry diamond ===");
-        deployBaseRegistry.diamondInitParams(deployer);
-        FacetCut[] memory proposedCuts = deployBaseRegistry.getCuts();
-        FacetCut[] memory smartCuts = generateSmartCuts(baseRegistry, proposedCuts);
-
-        console.log(
-            "[INFO]: Generated %d smart cuts from %d proposed cuts",
-            smartCuts.length,
-            proposedCuts.length
-        );
+        executeDiamondCutsWithLogging(deployer, baseRegistry, "BaseRegistry", deployBaseRegistry);
+        executeDiamondCutsWithLogging(deployer, riverAirdrop, "RiverAirdrop", deployRiverAirdrop);
+        executeDiamondCutsWithLogging(deployer, appRegistry, "AppRegistry", deployAppRegistry);
 
-        if (smartCuts.length > 0) {
-            vm.broadcast(deployer);
-            IDiamondCut(baseRegistry).diamondCut(smartCuts, address(0), "");
-            console.log("[INFO]: \u2705 BaseRegistry diamond upgrade completed");
-        } else {
-            console.log("[INFO]: BaseRegistry diamond already up to date - no cuts needed");
-        }
-    }
-
-    function deployRiverAirdropCuts(address deployer, address riverAirdrop) internal {
-        console.log("[INFO]: === Upgrading RiverAirdrop diamond ===");
-        deployRiverAirdrop.diamondInitParams(deployer);
-        FacetCut[] memory proposedCuts = deployRiverAirdrop.getCuts();
-        FacetCut[] memory smartCuts = generateSmartCuts(riverAirdrop, proposedCuts);
-
-        console.log(
-            "[INFO]: Generated %d smart cuts from %d proposed cuts",
-            smartCuts.length,
-            proposedCuts.length
-        );
-
-        if (smartCuts.length > 0) {
-            vm.broadcast(deployer);
-            IDiamondCut(riverAirdrop).diamondCut(smartCuts, address(0), "");
-            console.log("[INFO]: \u2705 RiverAirdrop diamond upgrade completed");
-        } else {
-            console.log("[INFO]: RiverAirdrop diamond already up to date - no cuts needed");
-        }
-    }
-
-    function deployAppRegistryCuts(address deployer, address appRegistry) internal {
-        console.log("[INFO]: === Upgrading AppRegistry diamond ===");
-        deployAppRegistry.diamondInitParams(deployer);
-        FacetCut[] memory proposedCuts = deployAppRegistry.getCuts();
-        FacetCut[] memory smartCuts = generateSmartCuts(appRegistry, proposedCuts);
-
-        console.log(
-            "[INFO]: Generated %d smart cuts from %d proposed cuts",
-            smartCuts.length,
-            proposedCuts.length
-        );
-
-        if (smartCuts.length > 0) {
-            vm.broadcast(deployer);
-            IDiamondCut(appRegistry).diamondCut(smartCuts, address(0), "");
-            console.log("[INFO]: \u2705 AppRegistry diamond upgrade completed");
-        } else {
-            console.log("[INFO]: AppRegistry diamond already up to date - no cuts needed");
-        }
+        vm.resumeGasMetering();
     }
 }

package/scripts/interactions/InteractRiverAlpha.s.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
 
 // libraries
 
@@ -15,16 +14,13 @@ contract InteractRiverAlpha is AlphaHelper {
     DeployRiverRegistry deployRiverRegistry = new DeployRiverRegistry();
 
     function __interact(address deployer) internal override {
-        vm.setEnv("OVERRIDE_DEPLOYMENTS", "1");
         address riverRegistry = getDeployment("riverRegistry");
 
-        removeRemoteFacets(deployer, riverRegistry);
-        FacetCut[] memory newCuts;
-
-        deployRiverRegistry.diamondInitParams(deployer);
-        newCuts = deployRiverRegistry.getCuts();
-
-        vm.broadcast(deployer);
-        IDiamondCut(riverRegistry).diamondCut(newCuts, address(0), "");
+        executeDiamondCutsWithLogging(
+            deployer,
+            riverRegistry,
+            "RiverRegistry",
+            deployRiverRegistry
+        );
     }
 }

package/scripts/interactions/helpers/AlphaHelper.sol

@@ -7,10 +7,12 @@ import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.so
 import {IDiamondLoupe, IDiamondLoupeBase} from "@towns-protocol/diamond/src/facets/loupe/IDiamondLoupe.sol";
 import {IERC173} from "@towns-protocol/diamond/src/facets/ownable/IERC173.sol";
 import {IOwnablePending} from "@towns-protocol/diamond/src/facets/ownable/pending/IOwnablePending.sol";
+import {IDiamondInitHelper} from "scripts/deployments/diamonds/IDiamondInitHelper.sol";
 
 // libraries
 import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+import {LibString} from "solady/utils/LibString.sol";
 
 // contracts
 import {DiamondHelper} from "@towns-protocol/diamond/scripts/common/helpers/DiamondHelper.s.sol";
@@ -37,6 +39,7 @@ abstract contract AlphaHelper is Interaction, DiamondHelper, IDiamondLoupeBase {
     using DynamicArrayLib for DynamicArrayLib.DynamicArray;
     using EnumerableSet for EnumerableSet.AddressSet;
     using EnumerableSet for EnumerableSet.Bytes32Set;
+    using LibString for *;
 
     struct DiamondInfo {
         DiamondCutStorage.Layout layout;
@@ -256,6 +259,68 @@ abstract contract AlphaHelper is Interaction, DiamondHelper, IDiamondLoupeBase {
         }
     }
 
+    /// @notice Execute diamond cuts with smart cut optimization and logging
+    /// @param deployer The address that will execute the diamond cut
+    /// @param diamond The diamond contract address
+    /// @param diamondName Name of the diamond for logging purposes
+    /// @param deployContract The deployment contract that provides cuts and initialization
+    /// @param initAddress Optional initialization contract address
+    /// @param initData Optional initialization data
+    function executeDiamondCutsWithLogging(
+        address deployer,
+        address diamond,
+        string memory diamondName,
+        IDiamondInitHelper deployContract,
+        address initAddress,
+        bytes memory initData
+    ) internal {
+        info(string.concat("=== Upgrading ", diamondName, " diamond ==="), "");
+
+        deployContract.diamondInitParams(deployer);
+        FacetCut[] memory proposedCuts = DiamondHelper(address(deployContract)).getCuts();
+        FacetCut[] memory smartCuts = generateSmartCuts(diamond, proposedCuts);
+
+        info(
+            string.concat(
+                "Generated ",
+                smartCuts.length.toString(),
+                " smart cuts from ",
+                proposedCuts.length.toString(),
+                " proposed cuts"
+            ),
+            ""
+        );
+
+        if (smartCuts.length > 0) {
+            vm.broadcast(deployer);
+            IDiamondCut(diamond).diamondCut(smartCuts, initAddress, initData);
+            info(string.concat(unicode"✅ ", diamondName, " diamond upgrade completed"), "");
+        } else {
+            info(string.concat(diamondName, " diamond already up to date - no cuts needed"), "");
+        }
+    }
+
+    /// @notice Execute diamond cuts with smart cut optimization and logging (no initialization)
+    /// @param deployer The address that will execute the diamond cut
+    /// @param diamond The diamond contract address
+    /// @param diamondName Name of the diamond for logging purposes
+    /// @param deployContract The deployment contract that provides cuts and initialization
+    function executeDiamondCutsWithLogging(
+        address deployer,
+        address diamond,
+        string memory diamondName,
+        IDiamondInitHelper deployContract
+    ) internal {
+        executeDiamondCutsWithLogging(
+            deployer,
+            diamond,
+            diamondName,
+            deployContract,
+            address(0),
+            ""
+        );
+    }
+
     function asBytes4Array(
         DynamicArrayLib.DynamicArray memory input
     ) internal pure returns (bytes4[] memory selectors) {

package/src/apps/BaseApp.sol

@@ -11,7 +11,6 @@ import {ITownsApp} from "./ITownsApp.sol";
 /// @dev Provides base implementation for module installation/uninstallation and interface support
 /// @dev Inheriting contracts should override _onInstall and _onUninstall as needed
 /// @dev Implements IModule, IExecutionModule, and ITownsApp interfaces
-
 abstract contract BaseApp is ITownsApp {
     receive() external payable {
         _onPayment(msg.sender, msg.value);

package/src/apps/modules/subscription/ISubscriptionModule.sol

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+import {Subscription} from "./SubscriptionModuleStorage.sol";
+
+interface ISubscriptionModuleBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Structs                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Parameters for renewing a subscription
+    /// @param account The address of the account to renew the subscription for
+    /// @param entityId The entity ID of the subscription to renew
+    struct RenewalParams {
+        address account;
+        uint32 entityId;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Errors                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    error SubscriptionModule__InactiveSubscription();
+    error SubscriptionModule__InvalidSpace();
+    error SubscriptionModule__RenewalNotDue();
+    error SubscriptionModule__RenewalFailed();
+    error SubscriptionModule__InvalidSender();
+    error SubscriptionModule__NotSupported();
+    error SubscriptionModule__InvalidEntityId();
+    error SubscriptionModule__InvalidCaller();
+    error SubscriptionModule__InvalidAddress();
+    error SubscriptionModule__ExceedsMaxBatchSize();
+    error SubscriptionModule__EmptyBatch();
+    error SubscriptionModule__InvalidTokenOwner();
+    error SubscriptionModule__InsufficientBalance();
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Events                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    event SubscriptionConfigured(
+        address indexed account,
+        uint32 indexed entityId,
+        address indexed space,
+        uint256 tokenId,
+        uint64 nextRenewalTime
+    );
+
+    event SubscriptionDeactivated(address indexed account, uint32 indexed entityId);
+
+    event SubscriptionSpent(
+        address indexed account,
+        uint32 indexed entityId,
+        uint256 amount,
+        uint256 totalSpent
+    );
+
+    event SubscriptionRenewed(
+        address indexed account,
+        uint32 indexed entityId,
+        uint256 nextRenewalTime
+    );
+
+    event SubscriptionPaused(address indexed account, uint32 indexed entityId);
+
+    event BatchRenewalSkipped(address indexed account, uint32 indexed entityId, string reason);
+
+    event OperatorGranted(address indexed operator);
+    event OperatorRevoked(address indexed operator);
+}
+
+interface ISubscriptionModule is ISubscriptionModuleBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Functions                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Processes multiple Towns membership renewals in batch
+    /// @param params The parameters for the renewals
+    function batchProcessRenewals(RenewalParams[] calldata params) external;
+
+    /// @notice Processes a single Towns membership renewal
+    /// @param params The parameters for the renewal
+    function processRenewal(RenewalParams calldata params) external;
+
+    /// @notice Gets the subscription for an account and entity ID
+    /// @param account The address of the account to get the subscription for
+    /// @param entityId The entity ID of the subscription to get
+    /// @return The subscription for the account and entity ID
+    function getSubscription(
+        address account,
+        uint32 entityId
+    ) external view returns (Subscription memory);
+
+    /// @notice Pauses a subscription
+    /// @param entityId The entity ID of the subscription to pause
+    function pauseSubscription(uint32 entityId) external;
+
+    /// @notice Gets the entity IDs for an account
+    /// @param account The address of the account to get the entity IDs for
+    /// @return The entity IDs for the account
+    function getEntityIds(address account) external view returns (uint256[] memory);
+
+    /// @notice Checks if an operator has access to call processRenewal
+    /// @param operator The address of the operator to check
+    function isOperator(address operator) external view returns (bool);
+
+    /// @notice Grants an operator access to call processRenewal
+    /// @param operator The address of the operator to grant
+    function grantOperator(address operator) external;
+
+    /// @notice Revokes an operator access to call processRenewal
+    /// @param operator The address of the operator to revoke
+    function revokeOperator(address operator) external;
+}

package/src/apps/modules/subscription/SubscriptionModuleFacet.sol

@@ -0,0 +1,359 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IModule} from "@erc6900/reference-implementation/interfaces/IModule.sol";
+import {IValidationModule} from "@erc6900/reference-implementation/interfaces/IValidationModule.sol";
+import {IValidationHookModule} from "@erc6900/reference-implementation/interfaces/IValidationHookModule.sol";
+import {ISubscriptionModule} from "./ISubscriptionModule.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IModularAccount} from "@erc6900/reference-implementation/interfaces/IModularAccount.sol";
+
+// libraries
+import {Subscription, SubscriptionModuleStorage} from "./SubscriptionModuleStorage.sol";
+import {PackedUserOperation} from "@eth-infinitism/account-abstraction/interfaces/PackedUserOperation.sol";
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+import {LibCall} from "solady/utils/LibCall.sol";
+import {ValidationLocatorLib} from "modular-account/src/libraries/ValidationLocatorLib.sol";
+import {ReentrancyGuardTransient} from "solady/utils/ReentrancyGuardTransient.sol";
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {Validator} from "../../../utils/libraries/Validator.sol";
+
+// contracts
+import {ModuleBase} from "modular-account/src/modules/ModuleBase.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {MembershipFacet} from "../../../spaces/facets/membership/MembershipFacet.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+
+/// @title Subscription Module
+/// @notice Module for managing subscriptions to spaces
+contract SubscriptionModuleFacet is
+    ISubscriptionModule,
+    IValidationModule,
+    IValidationHookModule,
+    ModuleBase,
+    OwnableBase,
+    ReentrancyGuardTransient,
+    Facet
+{
+    using EnumerableSetLib for EnumerableSetLib.Uint256Set;
+    using EnumerableSetLib for EnumerableSetLib.AddressSet;
+    using CustomRevert for bytes4;
+
+    uint256 internal constant _SIG_VALIDATION_FAILED = 1;
+
+    uint256 public constant MAX_BATCH_SIZE = 50;
+    uint256 public constant RENEWAL_BUFFER = 1 days;
+    uint256 public constant GRACE_PERIOD = 3 days;
+
+    function __SubscriptionModule_init() external onlyInitializing {
+        _addInterface(type(ISubscriptionModule).interfaceId);
+        _addInterface(type(IValidationModule).interfaceId);
+        _addInterface(type(IValidationHookModule).interfaceId);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           External                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IModule
+    function moduleId() external pure returns (string memory) {
+        return "towns.subscription-module.1.0.0";
+    }
+
+    /// @inheritdoc IModule
+    function onInstall(bytes calldata data) external override nonReentrant {
+        (uint32 entityId, address space, uint256 tokenId) = abi.decode(
+            data,
+            (uint32, address, uint256)
+        );
+
+        Validator.checkAddress(space);
+
+        if (IERC721(space).ownerOf(tokenId) != msg.sender)
+            SubscriptionModule__InvalidTokenOwner.selector.revertWith();
+
+        MembershipFacet membershipFacet = MembershipFacet(space);
+        uint256 expiresAt = membershipFacet.expiresAt(tokenId);
+
+        SubscriptionModuleStorage.Layout storage $ = SubscriptionModuleStorage.getLayout();
+        Subscription storage sub = $.subscriptions[msg.sender][entityId];
+        sub.space = space;
+        sub.active = true;
+        sub.tokenId = tokenId;
+        sub.nextRenewalTime = uint40(expiresAt - RENEWAL_BUFFER);
+
+        $.entityIds[msg.sender].add(entityId);
+
+        emit SubscriptionConfigured(msg.sender, entityId, space, tokenId, sub.nextRenewalTime);
+    }
+
+    /// @inheritdoc IModule
+    function onUninstall(bytes calldata data) external override nonReentrant {
+        uint32 entityId = abi.decode(data, (uint32));
+
+        SubscriptionModuleStorage.Layout storage $ = SubscriptionModuleStorage.getLayout();
+
+        if (!$.entityIds[msg.sender].remove(entityId))
+            SubscriptionModule__InvalidEntityId.selector.revertWith();
+        delete $.subscriptions[msg.sender][entityId];
+
+        emit SubscriptionDeactivated(msg.sender, entityId);
+    }
+
+    /// @inheritdoc IValidationModule
+    function validateUserOp(
+        uint32,
+        PackedUserOperation calldata,
+        bytes32
+    ) external pure override returns (uint256) {
+        return _SIG_VALIDATION_FAILED;
+    }
+
+    /// @inheritdoc IValidationModule
+    function validateSignature(
+        address,
+        uint32,
+        address,
+        bytes32,
+        bytes calldata
+    ) external pure override returns (bytes4) {
+        return 0xffffffff;
+    }
+
+    /// @inheritdoc IValidationModule
+    function validateRuntime(
+        address account,
+        uint32 entityId,
+        address sender,
+        uint256,
+        bytes calldata,
+        bytes calldata
+    ) external view override {
+        if (sender != address(this)) SubscriptionModule__InvalidSender.selector.revertWith();
+        bool active = SubscriptionModuleStorage.getLayout().subscriptions[account][entityId].active;
+        if (!active) SubscriptionModule__InactiveSubscription.selector.revertWith();
+        return;
+    }
+
+    /// @inheritdoc IValidationHookModule
+    function preUserOpValidationHook(
+        uint32 /* entityId */,
+        PackedUserOperation calldata /* userOp */,
+        bytes32 /* userOpHash */
+    ) external pure override returns (uint256) {
+        return _SIG_VALIDATION_FAILED;
+    }
+
+    /// @inheritdoc IValidationHookModule
+    function preRuntimeValidationHook(
+        uint32 /* entityId */,
+        address /* sender */,
+        uint256 /* value */,
+        bytes calldata /* data */,
+        bytes calldata /* authorization */
+    ) external pure override {
+        SubscriptionModule__NotSupported.selector.revertWith();
+    }
+
+    /// @inheritdoc IValidationHookModule
+    function preSignatureValidationHook(
+        uint32 /* entityId */,
+        address /* sender */,
+        bytes32 /* hash */,
+        bytes calldata /* signature */
+    ) external pure override {
+        SubscriptionModule__NotSupported.selector.revertWith();
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function batchProcessRenewals(RenewalParams[] calldata params) external nonReentrant {
+        uint256 length = params.length;
+        if (length > MAX_BATCH_SIZE) SubscriptionModule__ExceedsMaxBatchSize.selector.revertWith();
+        if (length == 0) SubscriptionModule__EmptyBatch.selector.revertWith();
+
+        SubscriptionModuleStorage.Layout storage $ = SubscriptionModuleStorage.getLayout();
+
+        for (uint256 i; i < length; ++i) {
+            if (!_isAllowed($.operators, params[i].account))
+                SubscriptionModule__InvalidCaller.selector.revertWith();
+
+            Subscription storage sub = $.subscriptions[params[i].account][params[i].entityId];
+
+            // Skip inactive subscriptions
+            if (!sub.active) {
+                emit BatchRenewalSkipped(params[i].account, params[i].entityId, "INACTIVE");
+                continue;
+            }
+
+            // Skip if renewal not due
+            if (block.timestamp < sub.nextRenewalTime) {
+                emit BatchRenewalSkipped(params[i].account, params[i].entityId, "NOT_DUE");
+                continue;
+            }
+
+            // Skip if past grace period (will be handled by individual call)
+            if (block.timestamp > sub.nextRenewalTime + GRACE_PERIOD) {
+                emit BatchRenewalSkipped(params[i].account, params[i].entityId, "PAST_GRACE");
+                continue;
+            }
+
+            _processRenewal(sub, params[i]);
+        }
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function processRenewal(RenewalParams calldata renewalParams) external nonReentrant {
+        SubscriptionModuleStorage.Layout storage $ = SubscriptionModuleStorage.getLayout();
+        if (!_isAllowed($.operators, renewalParams.account))
+            SubscriptionModule__InvalidCaller.selector.revertWith();
+        _processRenewal(
+            $.subscriptions[renewalParams.account][renewalParams.entityId],
+            renewalParams
+        );
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function getSubscription(
+        address account,
+        uint32 entityId
+    ) external view returns (Subscription memory) {
+        return SubscriptionModuleStorage.getLayout().subscriptions[account][entityId];
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function pauseSubscription(uint32 entityId) external {
+        Subscription storage sub = SubscriptionModuleStorage.getLayout().subscriptions[msg.sender][
+            entityId
+        ];
+
+        if (!sub.active) SubscriptionModule__InactiveSubscription.selector.revertWith();
+
+        sub.active = false;
+        emit SubscriptionPaused(msg.sender, entityId);
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function getEntityIds(address account) external view returns (uint256[] memory) {
+        return SubscriptionModuleStorage.getLayout().entityIds[account].values();
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function grantOperator(address operator) external onlyOwner {
+        Validator.checkAddress(operator);
+        SubscriptionModuleStorage.getLayout().operators.add(operator);
+        emit OperatorGranted(operator);
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function isOperator(address operator) external view returns (bool) {
+        return SubscriptionModuleStorage.getLayout().operators.contains(operator);
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function revokeOperator(address operator) external onlyOwner {
+        Validator.checkAddress(operator);
+        SubscriptionModuleStorage.getLayout().operators.remove(operator);
+        emit OperatorRevoked(operator);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Internal                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Processes a single subscription renewal
+    /// @param sub The subscription to renew
+    /// @param params The parameters for the renewal
+    function _processRenewal(Subscription storage sub, RenewalParams calldata params) internal {
+        if (!sub.active) SubscriptionModule__InactiveSubscription.selector.revertWith();
+
+        if (block.timestamp < sub.nextRenewalTime)
+            SubscriptionModule__RenewalNotDue.selector.revertWith();
+
+        // Check if we're past the grace period
+        if (block.timestamp > sub.nextRenewalTime + GRACE_PERIOD) {
+            sub.active = false;
+            emit SubscriptionPaused(params.account, params.entityId);
+            return;
+        }
+
+        MembershipFacet membershipFacet = MembershipFacet(sub.space);
+
+        // Get current renewal price from Towns contract
+        uint256 actualRenewalPrice = membershipFacet.getMembershipRenewalPrice(sub.tokenId);
+
+        // Check if the account has enough balance
+        if (params.account.balance < actualRenewalPrice)
+            SubscriptionModule__InsufficientBalance.selector.revertWith();
+
+        // Construct the renewal call to space contract
+        bytes memory renewalCall = abi.encodeCall(MembershipFacet.renewMembership, (sub.tokenId));
+
+        // Create the data parameter for executeWithRuntimeValidation
+        // This should be an execute() call to the space contract
+        bytes memory executeData = abi.encodeCall(
+            IModularAccount.execute,
+            (
+                sub.space, // target
+                actualRenewalPrice, // value
+                renewalCall // data
+            )
+        );
+
+        // Use the proper pack function from ValidationLocatorLib
+        bytes memory authorization = _runtimeFinal(
+            params.entityId,
+            abi.encode(sub.space, sub.tokenId)
+        );
+
+        // Call executeWithRuntimeValidation with the correct parameters
+        bytes memory runtimeValidationCall = abi.encodeCall(
+            IModularAccount.executeWithRuntimeValidation,
+            (
+                executeData, // The execute() call data
+                authorization // Authorization for validation
+            )
+        );
+
+        // External call happens here
+        LibCall.callContract(params.account, 0, runtimeValidationCall);
+
+        // Get the actual new expiration time after successful renewal
+        uint256 newExpiresAt = membershipFacet.expiresAt(sub.tokenId);
+
+        // Update subscription state after successful renewal
+        sub.nextRenewalTime = uint40(newExpiresAt - RENEWAL_BUFFER);
+        sub.lastRenewalTime = uint40(block.timestamp);
+        sub.spent += actualRenewalPrice;
+
+        emit SubscriptionRenewed(params.account, params.entityId, sub.nextRenewalTime);
+    }
+
+    /// @dev Creates the runtime final data for the renewal
+    /// @param entityId The entity ID of the subscription
+    /// @param finalData The final data for the renewal
+    /// @return The runtime final data
+    function _runtimeFinal(
+        uint32 entityId,
+        bytes memory finalData
+    ) internal pure returns (bytes memory) {
+        return
+            ValidationLocatorLib.packSignature(
+                entityId,
+                false, // selector-based
+                bytes.concat(hex"ff", finalData)
+            );
+    }
+
+    /// @dev Checks if the caller is allowed to call the function
+    /// @param operators The set of operators
+    /// @param account The account to check
+    /// @return True if the caller is allowed to call the function
+    function _isAllowed(
+        EnumerableSetLib.AddressSet storage operators,
+        address account
+    ) internal view returns (bool) {
+        if (account == msg.sender) return true;
+        return operators.contains(msg.sender);
+    }
+}

package/src/apps/modules/subscription/SubscriptionModuleStorage.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+
+struct Subscription {
+    uint256 tokenId; // 32 bytes
+    uint256 spent; // 32 bytes
+    address space; // 20 bytes
+    uint40 lastRenewalTime; // 5 bytes
+    uint40 nextRenewalTime; // 5 bytes
+    bool active; // 1 byte
+}
+
+library SubscriptionModuleStorage {
+    using EnumerableSetLib for EnumerableSetLib.Uint256Set;
+    using EnumerableSetLib for EnumerableSetLib.AddressSet;
+
+    /// @custom:storage-location erc7201:towns.subscription.validation.module.storage
+    struct Layout {
+        EnumerableSetLib.AddressSet operators;
+        mapping(address account => mapping(uint32 entityId => Subscription)) subscriptions;
+        mapping(address account => EnumerableSetLib.Uint256Set entityIds) entityIds;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("towns.subscription.validation.module.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant STORAGE_SLOT =
+        0xd241b3ceee256b40f80fe7a66fe789234ac389ed1408c472c4ee1cbb1deb8600;
+
+    function getLayout() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/spaces/facets/account/AppAccount.sol

@@ -22,6 +22,7 @@ contract AppAccount is IAppAccount, AppAccountBase, ReentrancyGuard, Facet {
     /*                      Execution                             */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
+    /// @inheritdoc IAppAccount
     function execute(
         address target,
         uint256 value,
@@ -90,4 +91,9 @@ contract AppAccount is IAppAccount, AppAccountBase, ReentrancyGuard, Facet {
     ) external view returns (bool) {
         return _isAppEntitled(app, publicKey, permission);
     }
+
+    /// @inheritdoc IAppAccount
+    function isAppExecuting(address app) external view returns (bool) {
+        return _isAppExecuting(app);
+    }
 }

package/src/spaces/facets/account/AppAccountBase.sol

@@ -18,6 +18,7 @@ import {DependencyLib} from "../DependencyLib.sol";
 import {LibCall} from "solady/utils/LibCall.sol";
 import {AppAccountStorage} from "./AppAccountStorage.sol";
 import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+import {ExecutorStorage} from "../executor/ExecutorStorage.sol";
 
 // contracts
 import {ExecutorBase} from "../executor/ExecutorBase.sol";
@@ -207,6 +208,20 @@ abstract contract AppAccountBase is
         return AppAccountStorage.getLayout().installedApps.values();
     }
 
+    function _isAppExecuting(address app) internal view returns (bool) {
+        bytes32 currentExecutionId = ExecutorStorage.getExecutionId();
+        if (currentExecutionId == bytes32(0)) return false;
+
+        bytes32 targetId = ExecutorStorage.getTargetExecutionId(app);
+        if (targetId == bytes32(0)) return false;
+        if (currentExecutionId != targetId) return false;
+
+        bytes32 appId = _getInstalledAppId(app);
+        if (appId == EMPTY_UID) return false;
+
+        return true;
+    }
+
     function _isAppInstalled(address module) internal view returns (bool) {
         return AppAccountStorage.getLayout().installedApps.contains(module);
     }

package/src/spaces/facets/account/IAppAccount.sol

@@ -72,4 +72,20 @@ interface IAppAccount is IAppAccountBase {
         address publicKey,
         bytes32 permission
     ) external view returns (bool);
+
+    /// @notice Checks if an app is executing
+    /// @param app The address of the app to check
+    /// @return True if the app is executing, false otherwise
+    function isAppExecuting(address app) external view returns (bool);
+
+    /// @notice Executes a function on the app
+    /// @param target The address of the app to execute the function on
+    /// @param value The value to send with the function
+    /// @param data The data to send with the function
+    /// @return The result of the function
+    function execute(
+        address target,
+        uint256 value,
+        bytes calldata data
+    ) external payable returns (bytes memory);
 }

package/src/spaces/facets/executor/ExecutorBase.sol

@@ -395,8 +395,9 @@ abstract contract ExecutorBase is IExecutorBase {
         _executePreHooks($, target, selector, value, data);
 
         // Set the executionId for the target and selector using transient storage
+        bytes32 executionIdBefore = ExecutorStorage.getExecutionId();
         bytes32 executionId = _hashExecutionId(target, selector);
-        ExecutorStorage.setTransientExecutionId(executionId);
+        ExecutorStorage.setExecutionId(executionId);
         ExecutorStorage.setTargetExecutionId(target, executionId);
 
         // Call the target
@@ -406,7 +407,8 @@ abstract contract ExecutorBase is IExecutorBase {
         _executePostHooks($, target, selector);
 
         // Clear transient storage to prevent composability issues
-        ExecutorStorage.clearTransientStorage(target);
+        ExecutorStorage.setExecutionId(executionIdBefore);
+        ExecutorStorage.clearTargetExecutionId(target);
     }
 
     /// @notice Gets the scheduled timepoint for an operation.
@@ -421,7 +423,7 @@ abstract contract ExecutorBase is IExecutorBase {
     /// @param target The target contract.
     /// @return True if currently executing.
     function _isTargetExecuting(address target) internal view returns (bool) {
-        bytes32 globalId = ExecutorStorage.getTransientExecutionId();
+        bytes32 globalId = ExecutorStorage.getExecutionId();
         bytes32 targetId = ExecutorStorage.getTargetExecutionId(target);
         return globalId != 0 && targetId == globalId;
     }
@@ -524,7 +526,7 @@ abstract contract ExecutorBase is IExecutorBase {
     /// @param selector The function selector.
     /// @return True if currently executing.
     function _isExecuting(address target, bytes4 selector) private view returns (bool) {
-        return ExecutorStorage.getTransientExecutionId() == _hashExecutionId(target, selector);
+        return ExecutorStorage.getExecutionId() == _hashExecutionId(target, selector);
     }
 
     /// @dev Computes a unique hash for the execution context.

package/src/spaces/facets/executor/ExecutorStorage.sol

@@ -66,13 +66,13 @@ library ExecutorStorage {
     /*                   Transient Execution Id                   */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-    function getTransientExecutionId() internal view returns (bytes32 id) {
+    function getExecutionId() internal view returns (bytes32 id) {
         assembly {
             id := tload(TRANSIENT_STORAGE_SLOT)
         }
     }
 
-    function setTransientExecutionId(bytes32 id) internal {
+    function setExecutionId(bytes32 id) internal {
         assembly {
             tstore(TRANSIENT_STORAGE_SLOT, id)
         }
@@ -90,10 +90,16 @@ library ExecutorStorage {
         }
     }
 
-    function clearTransientStorage(address target) internal {
+    function clearExecutionId(address target) internal {
         assembly {
             tstore(TRANSIENT_STORAGE_SLOT, 0)
             tstore(target, 0)
         }
     }
+
+    function clearTargetExecutionId(address target) internal {
+        assembly {
+            tstore(target, 0)
+        }
+    }
 }