@towns-protocol/contracts 0.0.352 → 0.0.353

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.352",
+  "version": "0.0.353",
   "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.352",
+    "@towns-protocol/prettier-config": "^0.0.353",
     "@typechain/ethers-v5": "^10.1.1",
     "@wagmi/cli": "^2.2.0",
     "forge-std": "github:foundry-rs/forge-std#v1.10.0",
@@ -57,5 +57,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b3b37f6306c5f111996218bd0772adfc03498fcd"
+  "gitHead": "8ef3c377692fbe02a8825159d53e390684290560"
 }

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

@@ -15,7 +15,7 @@ library DeploySubscriptionModuleFacet {
     using DynamicArrayLib for DynamicArrayLib.DynamicArray;
 
     function selectors() internal pure returns (bytes4[] memory res) {
-        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(20);
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(19);
         arr.p(SubscriptionModuleFacet.moduleId.selector);
         arr.p(SubscriptionModuleFacet.onInstall.selector);
         arr.p(SubscriptionModuleFacet.onUninstall.selector);
@@ -26,7 +26,7 @@ library DeploySubscriptionModuleFacet {
         arr.p(SubscriptionModuleFacet.preRuntimeValidationHook.selector);
         arr.p(SubscriptionModuleFacet.preSignatureValidationHook.selector);
         arr.p(SubscriptionModuleFacet.batchProcessRenewals.selector);
-        arr.p(SubscriptionModuleFacet.processRenewal.selector);
+        arr.p(SubscriptionModuleFacet.getRenewalBuffer.selector);
         arr.p(SubscriptionModuleFacet.getSubscription.selector);
         arr.p(SubscriptionModuleFacet.pauseSubscription.selector);
         arr.p(SubscriptionModuleFacet.getEntityIds.selector);
@@ -34,7 +34,6 @@ library DeploySubscriptionModuleFacet {
         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();

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

@@ -39,6 +39,7 @@ interface ISubscriptionModuleBase {
     error SubscriptionModule__EmptyBatch();
     error SubscriptionModule__InvalidTokenOwner();
     error SubscriptionModule__InsufficientBalance();
+    error SubscriptionModule__ActiveSubscription();
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                           Events                           */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
@@ -53,6 +54,8 @@ interface ISubscriptionModuleBase {
 
     event SubscriptionDeactivated(address indexed account, uint32 indexed entityId);
 
+    event SubscriptionActivated(address indexed account, uint32 indexed entityId);
+
     event SubscriptionSpent(
         address indexed account,
         uint32 indexed entityId,
@@ -66,7 +69,15 @@ interface ISubscriptionModuleBase {
         uint256 nextRenewalTime
     );
 
+    /// @notice Emitted when a subscription's next renewal time is synced to on-chain expiration
+    event SubscriptionSynced(
+        address indexed account,
+        uint32 indexed entityId,
+        uint256 newNextRenewalTime
+    );
+
     event SubscriptionPaused(address indexed account, uint32 indexed entityId);
+    event SubscriptionNotDue(address indexed account, uint32 indexed entityId);
 
     event BatchRenewalSkipped(address indexed account, uint32 indexed entityId, string reason);
 
@@ -83,10 +94,6 @@ interface ISubscriptionModule is ISubscriptionModuleBase {
     /// @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
@@ -96,6 +103,15 @@ interface ISubscriptionModule is ISubscriptionModuleBase {
         uint32 entityId
     ) external view returns (Subscription memory);
 
+    /// @notice Gets the renewal buffer for an expiration time
+    /// @param expirationTime The expiration time to get the renewal buffer for
+    /// @return The renewal buffer for the expiration time
+    function getRenewalBuffer(uint256 expirationTime) external view returns (uint256);
+
+    /// @notice Activates a subscription
+    /// @param entityId The entity ID of the subscription to activate
+    function activateSubscription(uint32 entityId) external;
+
     /// @notice Pauses a subscription
     /// @param entityId The entity ID of the subscription to pause
     function pauseSubscription(uint32 entityId) external;

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

@@ -43,9 +43,14 @@ contract SubscriptionModuleFacet is
     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;
 
+    // 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);
         _addInterface(type(IValidationModule).interfaceId);
@@ -81,7 +86,8 @@ contract SubscriptionModuleFacet is
         sub.space = space;
         sub.active = true;
         sub.tokenId = tokenId;
-        sub.nextRenewalTime = uint40(expiresAt - RENEWAL_BUFFER);
+        sub.installTime = uint40(block.timestamp);
+        sub.nextRenewalTime = _calculateNextRenewalTime(expiresAt, sub.installTime);
 
         $.entityIds[msg.sender].add(entityId);
 
@@ -168,49 +174,68 @@ contract SubscriptionModuleFacet is
 
     /// @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();
+        uint256 paramsLen = params.length;
+        if (paramsLen > MAX_BATCH_SIZE)
+            SubscriptionModule__ExceedsMaxBatchSize.selector.revertWith();
+        if (paramsLen == 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();
+        if (!$.operators.contains(msg.sender))
+            SubscriptionModule__InvalidCaller.selector.revertWith();
 
+        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 renewal not due
-            if (block.timestamp < sub.nextRenewalTime) {
-                emit BatchRenewalSkipped(params[i].account, params[i].entityId, "NOT_DUE");
+            // 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;
             }
 
-            // 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");
+            // 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;
             }
 
-            _processRenewal(sub, params[i]);
-        }
-    }
+            MembershipFacet membershipFacet = MembershipFacet(sub.space);
+            uint256 expiresAt = membershipFacet.expiresAt(sub.tokenId);
 
-    /// @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
-        );
+            // Sync next renewal time from on-chain expiration if user called renewMembership directly
+            uint40 correctNextRenewalTime = _calculateNextRenewalTime(expiresAt, sub.installTime);
+            if (sub.nextRenewalTime != correctNextRenewalTime) {
+                sub.nextRenewalTime = correctNextRenewalTime;
+                emit SubscriptionSynced(params[i].account, params[i].entityId, sub.nextRenewalTime);
+            }
+
+            uint256 actualRenewalPrice = membershipFacet.getMembershipRenewalPrice(sub.tokenId);
+
+            if (params[i].account.balance < actualRenewalPrice) {
+                emit BatchRenewalSkipped(
+                    params[i].account,
+                    params[i].entityId,
+                    "INSUFFICIENT_BALANCE"
+                );
+                continue;
+            }
+
+            _processRenewal(sub, params[i], membershipFacet, actualRenewalPrice);
+        }
     }
 
     /// @inheritdoc ISubscriptionModule
@@ -221,6 +246,26 @@ contract SubscriptionModuleFacet is
         return SubscriptionModuleStorage.getLayout().subscriptions[account][entityId];
     }
 
+    /// @inheritdoc ISubscriptionModule
+    function getRenewalBuffer(uint256 expirationTime) external view returns (uint256) {
+        return _getRenewalBuffer(expirationTime);
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function activateSubscription(uint32 entityId) external {
+        Subscription storage sub = SubscriptionModuleStorage.getLayout().subscriptions[msg.sender][
+            entityId
+        ];
+
+        if (sub.active) SubscriptionModule__ActiveSubscription.selector.revertWith();
+
+        address owner = IERC721(sub.space).ownerOf(sub.tokenId);
+        if (msg.sender != owner) SubscriptionModule__InvalidCaller.selector.revertWith();
+
+        sub.active = true;
+        emit SubscriptionActivated(msg.sender, entityId);
+    }
+
     /// @inheritdoc ISubscriptionModule
     function pauseSubscription(uint32 entityId) external {
         Subscription storage sub = SubscriptionModuleStorage.getLayout().subscriptions[msg.sender][
@@ -229,8 +274,10 @@ contract SubscriptionModuleFacet is
 
         if (!sub.active) SubscriptionModule__InactiveSubscription.selector.revertWith();
 
-        sub.active = false;
-        emit SubscriptionPaused(msg.sender, entityId);
+        address owner = IERC721(sub.space).ownerOf(sub.tokenId);
+        if (msg.sender != owner) SubscriptionModule__InvalidCaller.selector.revertWith();
+
+        _pauseSubscription(sub, msg.sender, entityId);
     }
 
     /// @inheritdoc ISubscriptionModule
@@ -264,28 +311,12 @@ contract SubscriptionModuleFacet is
     /// @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();
-
+    function _processRenewal(
+        Subscription storage sub,
+        RenewalParams calldata params,
+        MembershipFacet membershipFacet,
+        uint256 actualRenewalPrice
+    ) internal {
         // Construct the renewal call to space contract
         bytes memory renewalCall = abi.encodeCall(MembershipFacet.renewMembership, (sub.tokenId));
 
@@ -301,9 +332,10 @@ contract SubscriptionModuleFacet is
         );
 
         // Use the proper pack function from ValidationLocatorLib
-        bytes memory authorization = _runtimeFinal(
+        bytes memory authorization = ValidationLocatorLib.packSignature(
             params.entityId,
-            abi.encode(sub.space, sub.tokenId)
+            false, // selector-based
+            bytes.concat(hex"ff", abi.encode(sub.space, sub.tokenId))
         );
 
         // Call executeWithRuntimeValidation with the correct parameters
@@ -320,15 +352,74 @@ contract SubscriptionModuleFacet is
 
         // 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.nextRenewalTime = _calculateNextRenewalTime(newExpiresAt, sub.installTime);
         sub.lastRenewalTime = uint40(block.timestamp);
         sub.spent += actualRenewalPrice;
 
         emit SubscriptionRenewed(params.account, params.entityId, sub.nextRenewalTime);
     }
 
+    /// @dev Determines the appropriate renewal buffer time based on original membership duration
+    /// @param expirationTime The expiration timestamp of the membership
+    /// @param installTime The time when the subscription was installed
+    /// @return The appropriate buffer time in seconds before expiration
+    function _getRenewalBuffer(
+        uint256 expirationTime,
+        uint256 installTime
+    ) internal pure returns (uint256) {
+        uint256 originalDuration = expirationTime >= installTime ? expirationTime - installTime : 0;
+
+        // For memberships shorter than 1 hour, use immediate buffer (2 minutes)
+        if (originalDuration <= 1 hours) {
+            return BUFFER_IMMEDIATE;
+        }
+
+        // For memberships shorter than 6 hours, use short buffer (1 hour)
+        if (originalDuration <= 6 hours) {
+            return BUFFER_SHORT;
+        }
+
+        // For memberships shorter than 24 hours, use medium buffer (6 hours)
+        if (originalDuration <= 24 hours) {
+            return BUFFER_MEDIUM;
+        }
+
+        // For memberships longer than 24 hours, use long buffer (12 hours)
+        return BUFFER_LONG;
+    }
+
+    /// @dev Legacy function for backward compatibility - uses current time as install time
+    /// @param expirationTime The expiration timestamp of the membership
+    /// @return The appropriate buffer time in seconds before expiration
+    function _getRenewalBuffer(uint256 expirationTime) internal view returns (uint256) {
+        return _getRenewalBuffer(expirationTime, block.timestamp);
+    }
+
+    /// @dev Calculates the correct next renewal time for a given expiration using install time
+    /// @param expirationTime The expiration timestamp of the membership
+    /// @param installTime The time when the subscription was installed
+    /// @return The next renewal time as uint40
+    function _calculateNextRenewalTime(
+        uint256 expirationTime,
+        uint256 installTime
+    ) internal view returns (uint40) {
+        if (expirationTime <= block.timestamp) return uint40(block.timestamp);
+
+        uint256 buffer = _getRenewalBuffer(expirationTime, installTime);
+        uint256 timeUntilExpiration = expirationTime - block.timestamp;
+
+        if (buffer >= timeUntilExpiration) return uint40(block.timestamp);
+
+        return uint40(expirationTime - buffer);
+    }
+
+    /// @dev Legacy function for backward compatibility - uses current time as install time
+    /// @param expirationTime The expiration timestamp of the membership
+    /// @return The next renewal time as uint40
+    function _calculateNextRenewalTime(uint256 expirationTime) internal view returns (uint40) {
+        return _calculateNextRenewalTime(expirationTime, block.timestamp);
+    }
+
     /// @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
@@ -345,15 +436,12 @@ contract SubscriptionModuleFacet is
             );
     }
 
-    /// @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);
+    function _pauseSubscription(
+        Subscription storage sub,
+        address account,
+        uint32 entityId
+    ) internal {
+        sub.active = false;
+        emit SubscriptionPaused(account, entityId);
     }
 }

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

@@ -7,6 +7,7 @@ struct Subscription {
     uint256 tokenId; // 32 bytes
     uint256 spent; // 32 bytes
     address space; // 20 bytes
+    uint40 installTime; // 5 bytes - when subscription was first installed
     uint40 lastRenewalTime; // 5 bytes
     uint40 nextRenewalTime; // 5 bytes
     bool active; // 1 byte