@towns-protocol/contracts 0.0.336 → 0.0.337

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.336",
+  "version": "0.0.337",
   "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.337",
     "@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": "a8dae6ecef2c3bc7713acf56e6738fd47d608482"
 }

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

@@ -0,0 +1,64 @@
+// 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(19);
+        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.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/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,111 @@
+// 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();
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           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);
+}
+
+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 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,342 @@
+// 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);
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function revokeOperator(address operator) external onlyOwner {
+        Validator.checkAddress(operator);
+        SubscriptionModuleStorage.getLayout().operators.remove(operator);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Internal                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _processRenewal(Subscription storage sub, RenewalParams calldata params) internal {
+        // Validate subscription state
+        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);
+
+        // Update state BEFORE external calls to prevent reentrancy
+        // Set to a far future time to prevent re-entry while processing
+        // This ensures the "renewal not due" check will fail if re-entered
+        sub.nextRenewalTime = uint40(block.timestamp + 365 days);
+
+        // 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);
+    }
+
+    function _runtimeFinal(
+        uint32 entityId,
+        bytes memory finalData
+    ) internal pure returns (bytes memory) {
+        return
+            ValidationLocatorLib.packSignature(
+                entityId,
+                false, // selector-based
+                bytes.concat(hex"ff", finalData)
+            );
+    }
+
+    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 {
+    address space;
+    bool active;
+    uint40 lastRenewalTime;
+    uint40 nextRenewalTime;
+    uint256 spent;
+    uint256 tokenId;
+}
+
+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
+        }
+    }
+}