@towns-protocol/contracts 0.0.369 → 0.0.371

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.369",
+  "version": "0.0.371",
   "packageManager": "yarn@3.8.0",
   "scripts": {
     "build-types": "bash scripts/build-contract-types.sh",
@@ -35,7 +35,7 @@
     "@layerzerolabs/oapp-evm": "^0.3.2",
     "@openzeppelin/merkle-tree": "^1.0.8",
     "@prb/test": "^0.6.4",
-    "@towns-protocol/prettier-config": "^0.0.369",
+    "@towns-protocol/prettier-config": "^0.0.371",
     "@typechain/ethers-v5": "^11.1.2",
     "@wagmi/cli": "^2.2.0",
     "forge-std": "github:foundry-rs/forge-std#v1.10.0",
@@ -57,5 +57,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5a4adeead17c71980426b92b98c23952536e08fa"
+  "gitHead": "1b8084e16a1892d0cc2eee713b926c259dc4a93b"
 }

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

@@ -54,7 +54,6 @@ contract DeployAppRegistry is IDiamondInitHelper, DiamondHelper, Deployer {
         facetHelper.add("DiamondLoupeFacet");
         facetHelper.add("IntrospectionFacet");
         facetHelper.add("OwnableFacet");
-        facetHelper.add("MetadataFacet");
 
         // Deploy the first batch of facets
         facetHelper.deployBatch(deployer);
@@ -87,26 +86,27 @@ contract DeployAppRegistry is IDiamondInitHelper, DiamondHelper, Deployer {
             facet,
             DeployOwnable.makeInitData(deployer)
         );
-
-        facet = facetHelper.predictAddress("MetadataFacet");
-        addFacet(
-            makeCut(facet, FacetCutAction.Add, DeployMetadata.selectors()),
-            facet,
-            DeployMetadata.makeInitData(bytes32("AppRegistry"), "")
-        );
     }
 
     function diamondInitParams(address deployer) public returns (Diamond.InitParams memory) {
         // Queue up feature facets for batch deployment
         facetHelper.add("MultiInit");
+        facetHelper.add("MetadataFacet");
         facetHelper.add("UpgradeableBeaconFacet");
         facetHelper.add("AppRegistryFacet");
         facetHelper.add("SimpleApp");
 
         facetHelper.deployBatch(deployer);
 
+        address facet = facetHelper.getDeployedAddress("MetadataFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployMetadata.selectors()),
+            facet,
+            DeployMetadata.makeInitData(bytes32("AppRegistry"), "")
+        );
+
         address simpleApp = facetHelper.getDeployedAddress("SimpleApp");
-        address facet = facetHelper.getDeployedAddress("UpgradeableBeaconFacet");
+        facet = facetHelper.getDeployedAddress("UpgradeableBeaconFacet");
 
         addFacet(
             makeCut(facet, FacetCutAction.Add, DeployUpgradeableBeacon.selectors()),

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

@@ -62,13 +62,21 @@ contract DeploySubscriptionModule is DiamondHelper, Deployer, IDiamondInitHelper
     function diamondInitParams(address deployer) public returns (Diamond.InitParams memory) {
         // Queue up feature facets for batch deployment
         facetHelper.add("MultiInit");
+        facetHelper.add("MetadataFacet");
         facetHelper.add("SubscriptionModuleFacet");
 
         // Deploy all facets in a batch
         facetHelper.deployBatch(deployer);
 
         // Add feature facets
-        address facet = facetHelper.getDeployedAddress("SubscriptionModuleFacet");
+        address facet = facetHelper.getDeployedAddress("MetadataFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployMetadata.selectors()),
+            facet,
+            DeployMetadata.makeInitData(METADATA_NAME, "")
+        );
+
+        facet = facetHelper.getDeployedAddress("SubscriptionModuleFacet");
         addFacet(
             makeCut(facet, FacetCutAction.Add, DeploySubscriptionModuleFacet.selectors()),
             facet,
@@ -95,7 +103,6 @@ contract DeploySubscriptionModule is DiamondHelper, Deployer, IDiamondInitHelper
         facetHelper.add("DiamondLoupeFacet");
         facetHelper.add("IntrospectionFacet");
         facetHelper.add("OwnableFacet");
-        facetHelper.add("MetadataFacet");
 
         // Get predicted addresses
         address facet = facetHelper.predictAddress("DiamondCutFacet");
@@ -125,13 +132,6 @@ contract DeploySubscriptionModule is DiamondHelper, Deployer, IDiamondInitHelper
             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) {

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

@@ -34,6 +34,8 @@ library DeploySubscriptionModuleFacet {
         arr.p(SubscriptionModuleFacet.isOperator.selector);
         arr.p(SubscriptionModuleFacet.grantOperator.selector);
         arr.p(SubscriptionModuleFacet.revokeOperator.selector);
+        arr.p(SubscriptionModuleFacet.setSpaceFactory.selector);
+        arr.p(SubscriptionModuleFacet.getSpaceFactory.selector);
         arr.p(bytes4(keccak256("MAX_BATCH_SIZE()")));
         arr.p(bytes4(keccak256("GRACE_PERIOD()")));
 

package/scripts/interactions/InteractDiamondCut.s.sol

@@ -13,6 +13,7 @@ import {AlphaHelper} from "./helpers/AlphaHelper.sol";
 
 // fetch facet deployer contract
 import {DeploySubscriptionModuleFacet} from "scripts/deployments/facets/DeploySubscriptionModuleFacet.s.sol";
+import {SubscriptionModuleFacet} from "src/apps/modules/subscription/SubscriptionModuleFacet.sol";
 
 contract InteractDiamondCut is Interaction, AlphaHelper {
     function __interact(address deployer) internal override {
@@ -41,5 +42,8 @@ contract InteractDiamondCut is Interaction, AlphaHelper {
         // execute the diamond cut
         vm.broadcast(deployer);
         IDiamondCut(diamond).diamondCut(baseFacets(), address(0), "");
+
+        vm.broadcast(deployer);
+        SubscriptionModuleFacet(diamond).setSpaceFactory(getDeployment("spaceFactory"));
     }
 }

package/scripts/interactions/helpers/AlphaHelper.sol

@@ -8,6 +8,7 @@ import {IDiamondLoupe, IDiamondLoupeBase} from "@towns-protocol/diamond/src/face
 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";
+import {IMetadata} from "src/diamond/facets/metadata/IMetadata.sol";
 
 // libraries
 import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
@@ -55,13 +56,14 @@ abstract contract AlphaHelper is Interaction, DiamondHelper, IDiamondLoupeBase {
     function getCoreFacetAddresses(
         address diamond
     ) internal view returns (address[] memory coreFacets) {
-        coreFacets = new address[](5);
+        coreFacets = new address[](6);
 
         coreFacets[0] = IDiamondLoupe(diamond).facetAddress(IDiamondCut.diamondCut.selector);
         coreFacets[1] = IDiamondLoupe(diamond).facetAddress(IDiamondLoupe.facets.selector);
         coreFacets[2] = IDiamondLoupe(diamond).facetAddress(IERC165.supportsInterface.selector);
         coreFacets[3] = IDiamondLoupe(diamond).facetAddress(IERC173.owner.selector);
         coreFacets[4] = IDiamondLoupe(diamond).facetAddress(IOwnablePending.currentOwner.selector);
+        coreFacets[5] = IDiamondLoupe(diamond).facetAddress(IMetadata.contractType.selector);
     }
 
     /// @notice Check if an address is a core facet that should not be removed
@@ -254,7 +256,7 @@ abstract contract AlphaHelper is Interaction, DiamondHelper, IDiamondLoupeBase {
             }
 
             if (removeSelectors.length() > 0) {
-                addCut(FacetCut(address(0), FacetCutAction.Remove, asBytes4Array(removeSelectors)));
+                addCut(FacetCut(facetAddr, FacetCutAction.Remove, asBytes4Array(removeSelectors)));
             }
         }
     }

package/scripts/interactions/helpers/RiverConfigValues.sol

@@ -8,8 +8,6 @@ pragma solidity ^0.8.23;
 // contracts
 
 library RiverConfigValues {
-    bytes32 public constant ENABLE_NEW_SNAPSHOT_FORMAT =
-        keccak256("stream.enablenewsnapshotformat");
     bytes32 public constant XCHAIN_BLOCKCHAINS = keccak256("xchain.blockchains");
     bytes32 public constant NODE_BLOCKLIST = keccak256("node.blocklist");
     bytes32 public constant STREAM_MINIBLOCK_REGISTRATION_FREQUENCY =

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

@@ -41,6 +41,10 @@ interface ISubscriptionModuleBase {
     error SubscriptionModule__InsufficientBalance();
     error SubscriptionModule__ActiveSubscription();
     error SubscriptionModule__MembershipBanned();
+    error SubscriptionModule__MembershipExpired();
+    error SubscriptionModule__SubscriptionAlreadyInstalled();
+    error SubscriptionModule__SubscriptionNotInstalled();
+
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                           Events                           */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
@@ -88,6 +92,7 @@ interface ISubscriptionModuleBase {
 
     event OperatorGranted(address indexed operator);
     event OperatorRevoked(address indexed operator);
+    event SpaceFactoryChanged(address indexed spaceFactory);
 }
 
 interface ISubscriptionModule is ISubscriptionModuleBase {
@@ -137,4 +142,12 @@ interface ISubscriptionModule is ISubscriptionModuleBase {
     /// @notice Revokes an operator access to call processRenewal
     /// @param operator The address of the operator to revoke
     function revokeOperator(address operator) external;
+
+    /// @notice Sets the space factory
+    /// @param spaceFactory The address of the space factory
+    function setSpaceFactory(address spaceFactory) external;
+
+    /// @notice Gets the space factory
+    /// @return The address of the space factory
+    function getSpaceFactory() external view returns (address);
 }

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

@@ -0,0 +1,267 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IModularAccount} from "@erc6900/reference-implementation/interfaces/IModularAccount.sol";
+import {IMembership} from "../../../spaces/facets/membership/IMembership.sol";
+import {IBanning} from "../../../spaces/facets/banning/IBanning.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {ISubscriptionModule, ISubscriptionModuleBase} from "./ISubscriptionModule.sol";
+
+// libraries
+import {LibCall} from "solady/utils/LibCall.sol";
+import {ValidationLocatorLib} from "modular-account/src/libraries/ValidationLocatorLib.sol";
+import {SafeCastLib} from "solady/utils/SafeCastLib.sol";
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {Validator} from "../../../utils/libraries/Validator.sol";
+import {Subscription, SubscriptionModuleStorage} from "./SubscriptionModuleStorage.sol";
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+
+/// @title Subscription Module Base
+/// @notice Base contract with internal logic for subscription management
+abstract contract SubscriptionModuleBase is ISubscriptionModuleBase {
+    using SafeCastLib for uint256;
+    using CustomRevert for bytes4;
+    using EnumerableSetLib for EnumerableSetLib.Uint256Set;
+
+    /// @dev Reasons why a renewal might be skipped
+    enum SkipReason {
+        NONE,
+        NOT_DUE,
+        INACTIVE,
+        PAST_GRACE,
+        MEMBERSHIP_BANNED,
+        NOT_OWNER,
+        RENEWAL_PRICE_CHANGED,
+        INSUFFICIENT_BALANCE,
+        DURATION_CHANGED
+    }
+
+    uint256 public constant GRACE_PERIOD = 3 days;
+
+    // Dynamic buffer times based on expiration proximity
+    uint256 public constant BUFFER_IMMEDIATE = 2 minutes; // For expirations within 1 hour
+    uint256 public constant BUFFER_SHORT = 1 hours; // For expirations within 6 hours
+    uint256 public constant BUFFER_MEDIUM = 6 hours; // For expirations within 24 hours
+    uint256 public constant BUFFER_LONG = 12 hours; // For expirations more than 24 hours away
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Internal                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _hasEntityId(
+        SubscriptionModuleStorage.Layout storage $,
+        address account,
+        uint32 entityId
+    ) internal view returns (bool) {
+        return $.entityIds[account].contains(entityId);
+    }
+
+    /// @dev Syncs subscription state with current membership data
+    /// @param sub The subscription storage to update
+    /// @param membershipFacet The membership facet to query
+    /// @param expiresAt The current expiration timestamp
+    /// @param duration The membership duration
+    function _syncSubscriptionState(
+        Subscription storage sub,
+        IMembership membershipFacet,
+        uint256 expiresAt,
+        uint64 duration
+    ) internal {
+        sub.active = true;
+        sub.lastKnownRenewalPrice = membershipFacet.getMembershipRenewalPrice(sub.tokenId);
+        sub.lastKnownExpiresAt = expiresAt;
+        sub.duration = duration;
+        sub.nextRenewalTime = _calculateBaseRenewalTime(expiresAt, duration);
+    }
+
+    /// @dev Processes a single subscription renewal
+    /// @param sub The subscription to renew
+    /// @param params The parameters for the renewal
+    function _processRenewal(
+        Subscription storage sub,
+        ISubscriptionModule.RenewalParams calldata params,
+        IMembership membershipFacet,
+        uint256 actualRenewalPrice
+    ) internal {
+        // Construct the renewal call to space contract
+        bytes memory renewalCall = abi.encodeCall(IMembership.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 = ValidationLocatorLib.packSignature(
+            params.entityId,
+            false, // selector-based
+            bytes.concat(hex"ff", 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);
+
+        // Calculate next renewal time ensuring it's strictly in the future
+        uint256 duration = membershipFacet.getMembershipDuration();
+        sub.nextRenewalTime = _calculateBaseRenewalTime(newExpiresAt, duration);
+        sub.lastRenewalTime = block.timestamp.toUint40();
+        sub.lastKnownExpiresAt = newExpiresAt;
+        sub.spent += actualRenewalPrice;
+
+        emit SubscriptionRenewed(
+            params.account,
+            params.entityId,
+            sub.space,
+            sub.tokenId,
+            sub.nextRenewalTime,
+            newExpiresAt
+        );
+        emit SubscriptionSpent(params.account, params.entityId, actualRenewalPrice, sub.spent);
+    }
+
+    /// @dev Determines the appropriate renewal buffer time based on membership duration
+    /// @param duration The membership duration in seconds
+    /// @return The appropriate buffer time in seconds before expiration
+    function _getRenewalBuffer(uint256 duration) internal pure returns (uint256) {
+        // For memberships shorter than 1 hour, use immediate buffer (2 minutes)
+        if (duration <= 1 hours) return BUFFER_IMMEDIATE;
+
+        // For memberships shorter than 6 hours, use short buffer (1 hour)
+        if (duration <= 6 hours) return BUFFER_SHORT;
+
+        // For memberships shorter than 24 hours, use medium buffer (6 hours)
+        if (duration <= 24 hours) return BUFFER_MEDIUM;
+
+        // For memberships longer than 24 hours, use long buffer (12 hours)
+        return BUFFER_LONG;
+    }
+
+    /// @dev Calculates the base renewal time without minimum buffer enforcement
+    /// @param expirationTime The expiration timestamp of the membership
+    /// @param duration The membership duration in seconds
+    /// @return The base renewal time as uint40
+    function _calculateBaseRenewalTime(
+        uint256 expirationTime,
+        uint256 duration
+    ) internal view returns (uint40) {
+        if (expirationTime <= block.timestamp) return block.timestamp.toUint40();
+
+        uint256 buffer = _getRenewalBuffer(duration);
+        uint256 timeUntilExpiration = expirationTime - block.timestamp;
+
+        if (buffer >= timeUntilExpiration) {
+            // If buffer is larger than time until expiration,
+            // schedule for after the expiration by the same amount
+            return (expirationTime + (buffer - timeUntilExpiration)).toUint40();
+        }
+
+        return (expirationTime - buffer).toUint40();
+    }
+
+    /// @dev Requires that msg.sender is the owner of the membership token
+    /// @param sub The subscription storage reference
+    function _requireOwnership(Subscription storage sub) internal view {
+        address owner = IERC721(sub.space).ownerOf(sub.tokenId);
+        if (msg.sender != owner) SubscriptionModule__InvalidCaller.selector.revertWith();
+    }
+
+    /// @dev Validates renewal eligibility and returns skip reason if any
+    /// @param sub The subscription to validate
+    /// @param account The account address
+    /// @param actualRenewalPrice The current renewal price
+    /// @param actualDuration The current membership duration
+    /// @return shouldSkip Whether to skip this renewal
+    /// @return shouldPause Whether to pause the subscription (only relevant if shouldSkip is true)
+    /// @return reason The skip reason if shouldSkip is true
+    function _validateRenewalEligibility(
+        Subscription storage sub,
+        address account,
+        uint256 actualRenewalPrice,
+        uint256 actualDuration
+    ) internal view returns (bool shouldSkip, bool shouldPause, SkipReason reason) {
+        // Check if renewal is due
+        if (sub.nextRenewalTime > block.timestamp) {
+            return (true, false, SkipReason.NOT_DUE);
+        }
+
+        // Check if subscription is active
+        if (!sub.active) {
+            return (true, false, SkipReason.INACTIVE);
+        }
+
+        // Check if past grace period
+        if (sub.nextRenewalTime + GRACE_PERIOD < block.timestamp) {
+            return (true, true, SkipReason.PAST_GRACE);
+        }
+
+        // Check if membership is banned
+        if (IBanning(sub.space).isBanned(sub.tokenId)) {
+            return (true, true, SkipReason.MEMBERSHIP_BANNED);
+        }
+
+        // Check if account is still the owner
+        if (IERC721(sub.space).ownerOf(sub.tokenId) != account) {
+            return (true, true, SkipReason.NOT_OWNER);
+        }
+
+        // Check if renewal price changed
+        if (sub.lastKnownRenewalPrice != actualRenewalPrice) {
+            return (true, true, SkipReason.RENEWAL_PRICE_CHANGED);
+        }
+
+        // Check if account has sufficient balance
+        if (account.balance < actualRenewalPrice) {
+            return (true, true, SkipReason.INSUFFICIENT_BALANCE);
+        }
+
+        // Check if duration changed
+        if (sub.duration != actualDuration) {
+            return (true, true, SkipReason.DURATION_CHANGED);
+        }
+
+        return (false, false, SkipReason.NONE);
+    }
+
+    /// @dev Converts a SkipReason enum to its string representation
+    /// @param reason The skip reason to convert
+    /// @return The string representation of the reason
+    function _skipReasonToString(SkipReason reason) internal pure returns (string memory) {
+        if (reason == SkipReason.NOT_DUE) return "NOT_DUE";
+        if (reason == SkipReason.INACTIVE) return "INACTIVE";
+        if (reason == SkipReason.PAST_GRACE) return "PAST_GRACE";
+        if (reason == SkipReason.MEMBERSHIP_BANNED) return "MEMBERSHIP_BANNED";
+        if (reason == SkipReason.NOT_OWNER) return "NOT_OWNER";
+        if (reason == SkipReason.RENEWAL_PRICE_CHANGED) return "RENEWAL_PRICE_CHANGED";
+        if (reason == SkipReason.INSUFFICIENT_BALANCE) return "INSUFFICIENT_BALANCE";
+        if (reason == SkipReason.DURATION_CHANGED) return "DURATION_CHANGED";
+        return "";
+    }
+
+    function _pauseSubscription(
+        Subscription storage sub,
+        address account,
+        uint32 entityId
+    ) internal {
+        sub.active = false;
+        emit SubscriptionPaused(account, entityId);
+    }
+}

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

@@ -3,7 +3,6 @@ pragma solidity ^0.8.29;
 
 // interfaces
 import {IModule} from "@erc6900/reference-implementation/interfaces/IModule.sol";
-import {IModularAccount} from "@erc6900/reference-implementation/interfaces/IModularAccount.sol";
 import {IValidationHookModule} from "@erc6900/reference-implementation/interfaces/IValidationHookModule.sol";
 import {IValidationModule} from "@erc6900/reference-implementation/interfaces/IValidationModule.sol";
 import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
@@ -14,11 +13,10 @@ import {IBanning} from "../../../spaces/facets/banning/IBanning.sol";
 // libraries
 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";
+import {IArchitect} from "../../../factory/facets/architect/IArchitect.sol";
 import {Subscription, SubscriptionModuleStorage} from "./SubscriptionModuleStorage.sol";
 import {SafeCastLib} from "solady/utils/SafeCastLib.sol";
 
@@ -26,6 +24,7 @@ import {SafeCastLib} from "solady/utils/SafeCastLib.sol";
 import {ModuleBase} from "modular-account/src/modules/ModuleBase.sol";
 import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
 import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {SubscriptionModuleBase} from "./SubscriptionModuleBase.sol";
 
 /// @title Subscription Module
 /// @notice Module for managing subscriptions to spaces
@@ -36,6 +35,7 @@ contract SubscriptionModuleFacet is
     ModuleBase,
     OwnableBase,
     ReentrancyGuardTransient,
+    SubscriptionModuleBase,
     Facet
 {
     using EnumerableSetLib for EnumerableSetLib.Uint256Set;
@@ -46,13 +46,6 @@ contract SubscriptionModuleFacet is
     uint256 internal constant _SIG_VALIDATION_FAILED = 1;
 
     uint256 public constant MAX_BATCH_SIZE = 50;
-    uint256 public constant GRACE_PERIOD = 3 days;
-
-    // Dynamic buffer times based on expiration proximity
-    uint256 public constant BUFFER_IMMEDIATE = 2 minutes; // For expirations within 1 hour
-    uint256 public constant BUFFER_SHORT = 1 hours; // For expirations within 6 hours
-    uint256 public constant BUFFER_MEDIUM = 6 hours; // For expirations within 24 hours
-    uint256 public constant BUFFER_LONG = 12 hours; // For expirations more than 24 hours away
 
     function __SubscriptionModule_init() external onlyInitializing {
         _addInterface(type(ISubscriptionModule).interfaceId);
@@ -88,19 +81,32 @@ contract SubscriptionModuleFacet is
 
         SubscriptionModuleStorage.Layout storage $ = SubscriptionModuleStorage.getLayout();
 
+        if (IArchitect($.spaceFactory).getTokenIdBySpace(space) == 0)
+            SubscriptionModule__InvalidSpace.selector.revertWith();
+
         if (!$.entityIds[msg.sender].add(entityId))
             SubscriptionModule__InvalidEntityId.selector.revertWith();
 
+        if ($.tokenIdByAccountBySpace[msg.sender][space] != 0)
+            SubscriptionModule__SubscriptionAlreadyInstalled.selector.revertWith();
+
+        $.tokenIdByAccountBySpace[msg.sender][space] = tokenId;
+
         IMembership membershipFacet = IMembership(space);
+
         uint256 expiresAt = membershipFacet.expiresAt(tokenId);
-        uint256 duration = membershipFacet.getMembershipDuration();
+
+        // Prevent installation with expired membership
+        if (expiresAt <= block.timestamp)
+            SubscriptionModule__MembershipExpired.selector.revertWith();
+
+        uint64 duration = membershipFacet.getMembershipDuration();
 
         Subscription storage sub = $.subscriptions[msg.sender][entityId];
         sub.space = space;
-        sub.active = true;
         sub.tokenId = tokenId;
         sub.installTime = block.timestamp.toUint40();
-        sub.nextRenewalTime = _calculateBaseRenewalTime(expiresAt, duration);
+        _syncSubscriptionState(sub, membershipFacet, expiresAt, duration);
 
         emit SubscriptionConfigured(
             msg.sender,
@@ -121,6 +127,9 @@ contract SubscriptionModuleFacet is
         if (!$.entityIds[msg.sender].remove(entityId))
             SubscriptionModule__InvalidEntityId.selector.revertWith();
 
+        Subscription storage sub = $.subscriptions[msg.sender][entityId];
+
+        delete $.tokenIdByAccountBySpace[msg.sender][sub.space];
         delete $.subscriptions[msg.sender][entityId];
 
         emit SubscriptionDeactivated(msg.sender, entityId);
@@ -158,7 +167,6 @@ contract SubscriptionModuleFacet is
         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
@@ -203,68 +211,46 @@ contract SubscriptionModuleFacet is
         if (!$.operators.contains(msg.sender))
             SubscriptionModule__InvalidCaller.selector.revertWith();
 
-        IMembership membershipFacet;
-
         for (uint256 i; i < paramsLen; ++i) {
             Subscription storage sub = $.subscriptions[params[i].account][params[i].entityId];
 
-            // Skip if renewal not due (check original nextRenewalTime first)
-            if (sub.nextRenewalTime > block.timestamp) {
-                emit SubscriptionNotDue(params[i].account, params[i].entityId);
-                continue;
-            }
-
-            // Skip inactive subscriptions
-            if (!sub.active) {
-                emit BatchRenewalSkipped(params[i].account, params[i].entityId, "INACTIVE");
-                continue;
-            }
-
-            // Skip if past grace period
-            if (sub.nextRenewalTime + GRACE_PERIOD < block.timestamp) {
-                _pauseSubscription(sub, params[i].account, params[i].entityId);
-                emit BatchRenewalSkipped(params[i].account, params[i].entityId, "PAST_GRACE");
-                continue;
-            }
-
-            if (IBanning(sub.space).isBanned(sub.tokenId)) {
-                _pauseSubscription(sub, params[i].account, params[i].entityId);
-                emit BatchRenewalSkipped(
-                    params[i].account,
-                    params[i].entityId,
-                    "MEMBERSHIP_BANNED"
-                );
-                continue;
-            }
-
-            // Skip if account isn't owner anymore (for safety)
-            if (IERC721(sub.space).ownerOf(sub.tokenId) != params[i].account) {
-                _pauseSubscription(sub, params[i].account, params[i].entityId);
-                emit BatchRenewalSkipped(params[i].account, params[i].entityId, "NOT_OWNER");
-                continue;
-            }
-
-            membershipFacet = IMembership(sub.space);
-
+            IMembership membershipFacet = IMembership(sub.space);
             uint256 actualRenewalPrice = membershipFacet.getMembershipRenewalPrice(sub.tokenId);
+            uint256 actualDuration = membershipFacet.getMembershipDuration();
+
+            // Validate renewal eligibility
+            (bool shouldSkip, bool shouldPause, SkipReason reason) = _validateRenewalEligibility(
+                sub,
+                params[i].account,
+                actualRenewalPrice,
+                actualDuration
+            );
 
-            if (params[i].account.balance < actualRenewalPrice) {
-                _pauseSubscription(sub, params[i].account, params[i].entityId);
-                emit BatchRenewalSkipped(
-                    params[i].account,
-                    params[i].entityId,
-                    "INSUFFICIENT_BALANCE"
-                );
+            if (shouldSkip) {
+                // Handle special case for "NOT_DUE" - different event
+                if (reason == SkipReason.NOT_DUE) {
+                    emit SubscriptionNotDue(params[i].account, params[i].entityId);
+                } else {
+                    // Pause subscription if needed
+                    if (shouldPause) {
+                        _pauseSubscription(sub, params[i].account, params[i].entityId);
+                    }
+                    emit BatchRenewalSkipped(
+                        params[i].account,
+                        params[i].entityId,
+                        _skipReasonToString(reason)
+                    );
+                }
                 continue;
             }
 
-            uint256 expiresAt = membershipFacet.expiresAt(sub.tokenId);
-            uint256 duration = membershipFacet.getMembershipDuration();
-            uint40 nextRenewalTime = _calculateBaseRenewalTime(expiresAt, duration);
-
-            if (sub.nextRenewalTime != nextRenewalTime) {
-                sub.nextRenewalTime = nextRenewalTime;
+            // Check for manual renewal (expiresAt changed)
+            uint256 actualExpiresAt = membershipFacet.expiresAt(sub.tokenId);
+            if (sub.lastKnownExpiresAt != actualExpiresAt) {
+                sub.nextRenewalTime = _calculateBaseRenewalTime(actualExpiresAt, sub.duration);
+                sub.lastKnownExpiresAt = actualExpiresAt;
                 emit SubscriptionSynced(params[i].account, params[i].entityId, sub.nextRenewalTime);
+                continue;
             }
 
             _processRenewal(sub, params[i], membershipFacet, actualRenewalPrice);
@@ -295,34 +281,25 @@ contract SubscriptionModuleFacet is
 
         if (sub.active) SubscriptionModule__ActiveSubscription.selector.revertWith();
 
-        address owner = IERC721(sub.space).ownerOf(sub.tokenId);
-        if (msg.sender != owner) SubscriptionModule__InvalidCaller.selector.revertWith();
+        _requireOwnership(sub);
 
         IMembership membershipFacet = IMembership(sub.space);
         uint256 expiresAt = membershipFacet.expiresAt(sub.tokenId);
-        uint256 duration = membershipFacet.getMembershipDuration();
+        uint64 duration = membershipFacet.getMembershipDuration();
 
-        // 6. Always sync renewal time to current membership state
-        uint40 correctNextRenewalTime = _calculateBaseRenewalTime(expiresAt, duration);
-        if (sub.nextRenewalTime != correctNextRenewalTime) {
-            sub.nextRenewalTime = correctNextRenewalTime;
-            emit SubscriptionSynced(msg.sender, entityId, sub.nextRenewalTime);
-        }
+        _syncSubscriptionState(sub, membershipFacet, expiresAt, duration);
 
-        sub.active = true;
         emit SubscriptionActivated(msg.sender, entityId);
     }
 
     /// @inheritdoc ISubscriptionModule
     function pauseSubscription(uint32 entityId) external nonReentrant {
-        Subscription storage sub = SubscriptionModuleStorage.getLayout().subscriptions[msg.sender][
-            entityId
-        ];
+        SubscriptionModuleStorage.Layout storage $ = SubscriptionModuleStorage.getLayout();
+        Subscription storage sub = $.subscriptions[msg.sender][entityId];
 
         if (!sub.active) SubscriptionModule__InactiveSubscription.selector.revertWith();
 
-        address owner = IERC721(sub.space).ownerOf(sub.tokenId);
-        if (msg.sender != owner) SubscriptionModule__InvalidCaller.selector.revertWith();
+        _requireOwnership(sub);
 
         _pauseSubscription(sub, msg.sender, entityId);
     }
@@ -352,176 +329,18 @@ contract SubscriptionModuleFacet is
     }
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
-    /*                           Internal                         */
+    /*                      SPACE FACTORY                         */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-    function _hasEntityId(
-        SubscriptionModuleStorage.Layout storage $,
-        address account,
-        uint32 entityId
-    ) internal view returns (bool) {
-        return $.entityIds[account].contains(entityId);
-    }
-
-    /// @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,
-        IMembership membershipFacet,
-        uint256 actualRenewalPrice
-    ) internal {
-        // Construct the renewal call to space contract
-        bytes memory renewalCall = abi.encodeCall(IMembership.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 = ValidationLocatorLib.packSignature(
-            params.entityId,
-            false, // selector-based
-            bytes.concat(hex"ff", 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);
-
-        // Calculate next renewal time ensuring it's strictly in the future
-        uint256 duration = membershipFacet.getMembershipDuration();
-        sub.nextRenewalTime = _enforceMinimumBuffer(
-            _calculateBaseRenewalTime(newExpiresAt, duration),
-            newExpiresAt,
-            duration
-        );
-        sub.lastRenewalTime = block.timestamp.toUint40();
-        sub.spent += actualRenewalPrice;
-
-        emit SubscriptionRenewed(
-            params.account,
-            params.entityId,
-            sub.space,
-            sub.tokenId,
-            sub.nextRenewalTime,
-            newExpiresAt
-        );
-        emit SubscriptionSpent(params.account, params.entityId, actualRenewalPrice, sub.spent);
-    }
-
-    /// @dev Determines the appropriate renewal buffer time based on membership duration
-    /// @param duration The membership duration in seconds
-    /// @return The appropriate buffer time in seconds before expiration
-    function _getRenewalBuffer(uint256 duration) internal pure returns (uint256) {
-        // For memberships shorter than 1 hour, use immediate buffer (2 minutes)
-        if (duration <= 1 hours) return BUFFER_IMMEDIATE;
-
-        // For memberships shorter than 6 hours, use short buffer (1 hour)
-        if (duration <= 6 hours) return BUFFER_SHORT;
-
-        // For memberships shorter than 24 hours, use medium buffer (6 hours)
-        if (duration <= 24 hours) return BUFFER_MEDIUM;
-
-        // For memberships longer than 24 hours, use long buffer (12 hours)
-        return BUFFER_LONG;
-    }
-
-    /// @dev Calculates the base renewal time without minimum buffer enforcement
-    /// @param expirationTime The expiration timestamp of the membership
-    /// @param duration The membership duration in seconds
-    /// @return The base renewal time as uint40
-    function _calculateBaseRenewalTime(
-        uint256 expirationTime,
-        uint256 duration
-    ) internal view returns (uint40) {
-        // If membership is already expired, schedule for the future
-        if (expirationTime <= block.timestamp) {
-            return (block.timestamp + duration).toUint40();
-        }
-
-        uint256 buffer = _getRenewalBuffer(duration);
-        uint256 timeUntilExpiration = expirationTime - block.timestamp;
-
-        if (buffer >= timeUntilExpiration) {
-            // If buffer is larger than time until expiration,
-            // schedule for after the expiration by the same amount
-            return (expirationTime + (buffer - timeUntilExpiration)).toUint40();
-        }
-
-        return (expirationTime - buffer).toUint40();
-    }
-
-    /// @dev Enforces minimum buffer to prevent double renewals
-    /// @param baseTime The base calculated renewal time
-    /// @param expirationTime The expiration timestamp of the membership
-    /// @param duration The membership duration in seconds
-    /// @return The adjusted renewal time with minimum buffer enforced
-    function _enforceMinimumBuffer(
-        uint40 baseTime,
-        uint256 expirationTime,
-        uint256 duration
-    ) internal view returns (uint40) {
-        uint256 operatorBuffer = SubscriptionModuleStorage.getOperatorBuffer(msg.sender);
-
-        // If base time is far enough in the future, use it
-        if (baseTime > block.timestamp + operatorBuffer) {
-            return baseTime;
-        }
-
-        // For very short durations, schedule close to expiration with minimum buffer
-        if (duration <= 1 hours) {
-            return (expirationTime - operatorBuffer).toUint40();
-        }
-
-        // For longer durations, use standard calculation with minimum buffer
-        uint256 buffer = _getRenewalBuffer(duration);
-        uint256 minFutureTime = block.timestamp + duration - buffer;
-
-        return (minFutureTime > baseTime ? minFutureTime : baseTime).toUint40();
-    }
-
-    /// @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)
-            );
+    /// @inheritdoc ISubscriptionModule
+    function setSpaceFactory(address spaceFactory) external onlyOwner {
+        Validator.checkAddress(spaceFactory);
+        SubscriptionModuleStorage.getLayout().spaceFactory = spaceFactory;
+        emit SpaceFactoryChanged(spaceFactory);
     }
 
-    function _pauseSubscription(
-        Subscription storage sub,
-        address account,
-        uint32 entityId
-    ) internal {
-        sub.active = false;
-        emit SubscriptionPaused(account, entityId);
+    /// @inheritdoc ISubscriptionModule
+    function getSpaceFactory() external view returns (address) {
+        return SubscriptionModuleStorage.getLayout().spaceFactory;
     }
 }

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

@@ -11,7 +11,9 @@ struct Subscription {
     uint40 lastRenewalTime; // 5 bytes
     uint40 nextRenewalTime; // 5 bytes
     bool active; // 1 byte
-    uint64 duration;
+    uint64 duration; // 8 bytes
+    uint256 lastKnownRenewalPrice; // 32 bytes
+    uint256 lastKnownExpiresAt; // 32 bytes
 }
 
 struct OperatorConfig {
@@ -32,6 +34,8 @@ library SubscriptionModuleStorage {
         mapping(address account => mapping(uint32 entityId => Subscription)) subscriptions;
         mapping(address account => EnumerableSetLib.Uint256Set entityIds) entityIds;
         mapping(address operator => OperatorConfig) operatorConfig;
+        mapping(address account => mapping(address space => uint256 tokenId)) tokenIdByAccountBySpace;
+        address spaceFactory;
     }
 
     // keccak256(abi.encode(uint256(keccak256("towns.subscription.validation.module.storage")) - 1)) & ~bytes32(uint256(0xff))

package/scripts/interactions/InteractEnableNewSnapshotFormat.s.sol

@@ -1,27 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.24;
-
-// interfaces
-import {IRiverConfig} from "src/river/registry/facets/config/IRiverConfig.sol";
-
-// libraries
-import {RiverConfigValues} from "scripts/interactions/helpers/RiverConfigValues.sol";
-
-// contracts
-import {Interaction} from "scripts/common/Interaction.s.sol";
-
-contract InteractEnableNewSnapshotFormat is Interaction {
-    function __interact(address deployer) internal override {
-        address riverRegistry = getDeployment("riverRegistry");
-
-        uint64 value = 1;
-
-        vm.startBroadcast(deployer);
-        IRiverConfig(riverRegistry).setConfiguration(
-            RiverConfigValues.ENABLE_NEW_SNAPSHOT_FORMAT,
-            0,
-            abi.encode(value)
-        );
-        vm.stopBroadcast();
-    }
-}