@towns-protocol/contracts 0.0.452 → 0.0.455

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

@@ -6,19 +6,19 @@ import {IModule} from "@erc6900/reference-implementation/interfaces/IModule.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";
-import {ISubscriptionModule} from "./ISubscriptionModule.sol";
 import {IMembership} from "../../../spaces/facets/membership/IMembership.sol";
 import {IBanning} from "../../../spaces/facets/banning/IBanning.sol";
+import {ISubscriptionModule} from "./ISubscriptionModule.sol";
 
 // libraries
 import {PackedUserOperation} from "@eth-infinitism/account-abstraction/interfaces/PackedUserOperation.sol";
 import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
 import {ReentrancyGuardTransient} from "solady/utils/ReentrancyGuardTransient.sol";
+import {SafeCastLib} from "solady/utils/SafeCastLib.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";
 
 // contracts
 import {ModuleBase} from "modular-account/src/modules/ModuleBase.sol";
@@ -38,10 +38,10 @@ contract SubscriptionModuleFacet is
     SubscriptionModuleBase,
     Facet
 {
-    using EnumerableSetLib for EnumerableSetLib.Uint256Set;
     using EnumerableSetLib for EnumerableSetLib.AddressSet;
-    using SafeCastLib for uint256;
+    using EnumerableSetLib for EnumerableSetLib.Uint256Set;
     using CustomRevert for bytes4;
+    using SafeCastLib for uint256;
 
     uint256 internal constant _SIG_VALIDATION_FAILED = 1;
 
@@ -54,14 +54,34 @@ contract SubscriptionModuleFacet is
     }
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
-    /*                           External                         */
+    /*                       ADMIN FUNCTIONS                      */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-    /// @inheritdoc IModule
-    function moduleId() external pure returns (string memory) {
-        return "towns.subscription-module.1.0.0";
+    /// @inheritdoc ISubscriptionModule
+    function setSpaceFactory(address spaceFactory) external onlyOwner {
+        Validator.checkAddress(spaceFactory);
+        SubscriptionModuleStorage.getLayout().spaceFactory = spaceFactory;
+        emit SpaceFactoryChanged(spaceFactory);
     }
 
+    /// @inheritdoc ISubscriptionModule
+    function grantOperator(address operator) external onlyOwner {
+        Validator.checkAddress(operator);
+        SubscriptionModuleStorage.getLayout().operators.add(operator);
+        emit OperatorGranted(operator);
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function revokeOperator(address operator) external onlyOwner {
+        Validator.checkAddress(operator);
+        SubscriptionModuleStorage.getLayout().operators.remove(operator);
+        emit OperatorRevoked(operator);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      MODULE LIFECYCLE                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
     /// @inheritdoc IModule
     function onInstall(bytes calldata data) external override nonReentrant {
         (uint32 entityId, address space, uint256 tokenId) = abi.decode(
@@ -135,69 +155,9 @@ contract SubscriptionModuleFacet is
         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();
-    }
-
-    /// @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();
-    }
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                  STATE-CHANGING FUNCTIONS                  */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
     /// @inheritdoc ISubscriptionModule
     function batchProcessRenewals(RenewalParams[] calldata params) external nonReentrant {
@@ -257,19 +217,6 @@ contract SubscriptionModuleFacet is
         }
     }
 
-    /// @inheritdoc ISubscriptionModule
-    function getSubscription(
-        address account,
-        uint32 entityId
-    ) external view returns (Subscription memory) {
-        return SubscriptionModuleStorage.getLayout().subscriptions[account][entityId];
-    }
-
-    /// @inheritdoc ISubscriptionModule
-    function getRenewalBuffer(uint256 duration) external pure returns (uint256) {
-        return _getRenewalBuffer(duration);
-    }
-
     /// @inheritdoc ISubscriptionModule
     function activateSubscription(uint32 entityId) external nonReentrant {
         SubscriptionModuleStorage.Layout storage $ = SubscriptionModuleStorage.getLayout();
@@ -304,16 +251,26 @@ contract SubscriptionModuleFacet is
         _pauseSubscription(sub, msg.sender, entityId);
     }
 
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
     /// @inheritdoc ISubscriptionModule
-    function getEntityIds(address account) external view returns (uint256[] memory) {
-        return SubscriptionModuleStorage.getLayout().entityIds[account].values();
+    function getSpaceFactory() external view returns (address) {
+        return SubscriptionModuleStorage.getLayout().spaceFactory;
     }
 
     /// @inheritdoc ISubscriptionModule
-    function grantOperator(address operator) external onlyOwner {
-        Validator.checkAddress(operator);
-        SubscriptionModuleStorage.getLayout().operators.add(operator);
-        emit OperatorGranted(operator);
+    function getSubscription(
+        address account,
+        uint32 entityId
+    ) external view returns (Subscription memory) {
+        return SubscriptionModuleStorage.getLayout().subscriptions[account][entityId];
+    }
+
+    /// @inheritdoc ISubscriptionModule
+    function getEntityIds(address account) external view returns (uint256[] memory) {
+        return SubscriptionModuleStorage.getLayout().entityIds[account].values();
     }
 
     /// @inheritdoc ISubscriptionModule
@@ -321,26 +278,77 @@ contract SubscriptionModuleFacet is
         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);
+    /// @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();
     }
 
-    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
-    /*                      SPACE FACTORY                         */
-    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    /// @inheritdoc IModule
+    function moduleId() external pure returns (string memory) {
+        return "towns.subscription-module.1.0.0";
+    }
 
     /// @inheritdoc ISubscriptionModule
-    function setSpaceFactory(address spaceFactory) external onlyOwner {
-        Validator.checkAddress(spaceFactory);
-        SubscriptionModuleStorage.getLayout().spaceFactory = spaceFactory;
-        emit SpaceFactoryChanged(spaceFactory);
+    function getRenewalBuffer(uint256 duration) external pure returns (uint256) {
+        return _getRenewalBuffer(duration);
     }
 
-    /// @inheritdoc ISubscriptionModule
-    function getSpaceFactory() external view returns (address) {
-        return SubscriptionModuleStorage.getLayout().spaceFactory;
+    /// @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 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();
     }
 }

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

@@ -14,6 +14,7 @@ struct Subscription {
     uint64 duration; // 8 bytes
     uint256 lastKnownRenewalPrice; // 32 bytes
     uint256 lastKnownExpiresAt; // 32 bytes
+    address lastKnownCurrency; // 20 bytes - currency at install/sync time
 }
 
 struct OperatorConfig {
@@ -39,7 +40,7 @@ library SubscriptionModuleStorage {
     }
 
     // keccak256(abi.encode(uint256(keccak256("towns.subscription.validation.module.storage")) - 1)) & ~bytes32(uint256(0xff))
-    bytes32 private constant STORAGE_SLOT =
+    bytes32 internal constant STORAGE_SLOT =
         0xd241b3ceee256b40f80fe7a66fe789234ac389ed1408c472c4ee1cbb1deb8600;
 
     function getLayout() internal pure returns (Layout storage $) {

package/src/base/registry/facets/checker/EntitlementChecker.sol

@@ -121,17 +121,36 @@ contract EntitlementChecker is IEntitlementChecker, Facet {
     function requestEntitlementCheck(CheckType checkType, bytes calldata data) external payable {
         if (checkType == CheckType.V1) {
             if (msg.value != 0) EntitlementChecker_InvalidValue.selector.revertWith();
-            (address receiver, bytes32 transactionId, uint256 roleId, address[] memory nodes) = abi
-                .decode(data, (address, bytes32, uint256, address[]));
+            // equivalent: abi.decode(data, (address, bytes32, uint256, address[]))
+            address receiver;
+            bytes32 transactionId;
+            uint256 roleId;
+            address[] calldata nodes;
+            assembly {
+                receiver := shr(96, shl(96, calldataload(data.offset)))
+                transactionId := calldataload(add(data.offset, 0x20))
+                roleId := calldataload(add(data.offset, 0x40))
+                // nodes is dynamic: offset at 0x60, array starts at data.offset + offset
+                let nodesPtr := add(data.offset, calldataload(add(data.offset, 0x60)))
+                nodes.length := calldataload(nodesPtr)
+                nodes.offset := add(nodesPtr, 0x20)
+            }
             emit EntitlementCheckRequested(receiver, msg.sender, transactionId, roleId, nodes);
         } else if (checkType == CheckType.V2) {
-            (
-                address receiver,
-                bytes32 transactionId,
-                uint256 requestId,
-                bytes memory extraData
-            ) = abi.decode(data, (address, bytes32, uint256, bytes));
-            address sender = abi.decode(extraData, (address));
+            // equivalent: abi.decode(data, (address, bytes32, uint256, bytes))
+            // extraData contains: (address sender)
+            address receiver;
+            bytes32 transactionId;
+            uint256 requestId;
+            address sender;
+            assembly {
+                receiver := shr(96, shl(96, calldataload(data.offset)))
+                transactionId := calldataload(add(data.offset, 0x20))
+                requestId := calldataload(add(data.offset, 0x40))
+                // extraData offset at 0x60, sender is first word after length
+                let extraDataPtr := add(data.offset, calldataload(add(data.offset, 0x60)))
+                sender := shr(96, shl(96, calldataload(add(extraDataPtr, 0x20))))
+            }
             _requestEntitlementCheck(
                 receiver,
                 transactionId,
@@ -141,14 +160,21 @@ contract EntitlementChecker is IEntitlementChecker, Facet {
                 sender
             );
         } else if (checkType == CheckType.V3) {
-            (
-                address receiver,
-                bytes32 transactionId,
-                uint256 requestId,
-                address currency,
-                uint256 amount,
-                address sender
-            ) = abi.decode(data, (address, bytes32, uint256, address, uint256, address));
+            // equivalent: abi.decode(data, (address, bytes32, uint256, address, uint256, address))
+            address receiver;
+            bytes32 transactionId;
+            uint256 requestId;
+            address currency;
+            uint256 amount;
+            address sender;
+            assembly {
+                receiver := shr(96, shl(96, calldataload(data.offset)))
+                transactionId := calldataload(add(data.offset, 0x20))
+                requestId := calldataload(add(data.offset, 0x40))
+                currency := shr(96, shl(96, calldataload(add(data.offset, 0x60))))
+                amount := calldataload(add(data.offset, 0x80))
+                sender := shr(96, shl(96, calldataload(add(data.offset, 0xa0))))
+            }
             _requestEntitlementCheck(receiver, transactionId, requestId, currency, amount, sender);
         } else {
             EntitlementChecker_InvalidCheckType.selector.revertWith();

package/src/river/registry/facets/stream/StreamRegistry.sol

@@ -110,7 +110,10 @@ contract StreamRegistry is IStreamRegistry, RegistryModifiers {
 
             // Check if the lastMiniblockNum is the next expected miniblock and
             // the prevMiniblockHash is correct
-            if (stream.lastMiniblockNum >= miniblock.lastMiniblockNum) {
+            if (
+                stream.lastMiniblockNum + 1 != miniblock.lastMiniblockNum ||
+                stream.lastMiniblockHash != miniblock.prevMiniBlockHash
+            ) {
                 emit StreamLastMiniblockUpdateFailed(
                     miniblock.streamId,
                     miniblock.lastMiniblockHash,

package/src/spaces/facets/ProtocolFeeLib.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
+import {IFeeManager} from "../../factory/facets/fee/IFeeManager.sol";
+import {CurrencyTransfer} from "../../utils/libraries/CurrencyTransfer.sol";
+
+library ProtocolFeeLib {
+    using SafeTransferLib for address;
+
+    /// @notice Charges protocol fee via FeeManager with ERC20 approval handling
+    /// @param spaceFactory The FeeManager address
+    /// @param feeType The type of fee being charged
+    /// @param user The user paying the fee
+    /// @param currency The payment currency (NATIVE_TOKEN or ERC20)
+    /// @param amount The base amount for fee calculation
+    /// @param expectedFee The pre-calculated expected fee
+    /// @return protocolFee The actual fee charged
+    function charge(
+        address spaceFactory,
+        bytes32 feeType,
+        address user,
+        address currency,
+        uint256 amount,
+        uint256 expectedFee
+    ) internal returns (uint256 protocolFee) {
+        if (expectedFee == 0) return 0;
+
+        bool isNative = currency == CurrencyTransfer.NATIVE_TOKEN;
+        if (!isNative) currency.safeApproveWithRetry(spaceFactory, expectedFee);
+
+        protocolFee = IFeeManager(spaceFactory).chargeFee{value: isNative ? expectedFee : 0}(
+            feeType,
+            user,
+            amount,
+            currency,
+            expectedFee,
+            ""
+        );
+
+        if (!isNative) currency.safeApprove(spaceFactory, 0);
+    }
+}

package/src/spaces/facets/membership/IMembership.sol

@@ -75,6 +75,11 @@ interface IMembershipBase {
     event MembershipFreeAllocationUpdated(uint256 indexed allocation);
     event MembershipWithdrawal(address indexed currency, address indexed recipient, uint256 amount);
     event MembershipTokenIssued(address indexed recipient, uint256 indexed tokenId);
+    /// @notice Emitted when a membership payment is processed (new membership or renewal)
+    /// @param currency The currency used for payment (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for ETH)
+    /// @param price The base membership price paid
+    /// @param protocolFee The protocol fee paid
+    event MembershipPaid(address indexed currency, uint256 price, uint256 protocolFee);
     event MembershipTokenRejected(address indexed recipient);
 }
 
@@ -97,7 +102,7 @@ interface IMembership is IMembershipBase {
     /// @param referral The referral data
     function joinSpaceWithReferral(
         address receiver,
-        ReferralTypes memory referral
+        ReferralTypes calldata referral
     ) external payable;
 
     /// @notice Renew a space membership

package/src/spaces/facets/membership/MembershipFacet.sol

@@ -2,8 +2,8 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-import {IMembership} from "./IMembership.sol";
 import {IMembershipPricing} from "./pricing/IMembershipPricing.sol";
+import {IMembership} from "./IMembership.sol";
 
 // libraries
 import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
@@ -26,13 +26,22 @@ contract MembershipFacet is IMembership, MembershipJoin, ReentrancyGuard, Facet
     /// @inheritdoc IMembership
     function joinSpace(JoinType action, bytes calldata data) external payable nonReentrant {
         if (action == JoinType.Basic) {
-            address receiver = abi.decode(data, (address));
+            // equivalent: abi.decode(data, (address))
+            address receiver;
+            assembly {
+                receiver := shr(96, shl(96, calldataload(data.offset)))
+            }
             _joinSpace(receiver);
         } else if (action == JoinType.WithReferral) {
-            (address receiver, ReferralTypes memory referral) = abi.decode(
-                data,
-                (address, ReferralTypes)
-            );
+            // equivalent: abi.decode(data, (address, ReferralTypes))
+            address receiver;
+            ReferralTypes calldata referral;
+            assembly {
+                receiver := shr(96, shl(96, calldataload(data.offset)))
+                // this is a variable length struct, so (data.offset + 0x20) contains
+                // the offset from data.offset at which the struct begins
+                referral := add(data.offset, calldataload(add(data.offset, 0x20)))
+            }
             _joinSpaceWithReferral(receiver, referral);
         } else {
             Membership__InvalidAction.selector.revertWith();
@@ -47,7 +56,7 @@ contract MembershipFacet is IMembership, MembershipJoin, ReentrancyGuard, Facet
     /// @inheritdoc IMembership
     function joinSpaceWithReferral(
         address receiver,
-        ReferralTypes memory referral
+        ReferralTypes calldata referral
     ) external payable nonReentrant {
         _joinSpaceWithReferral(receiver, referral);
     }

package/src/spaces/facets/membership/join/MembershipJoin.sol

@@ -16,6 +16,7 @@ import {CurrencyTransfer} from "../../../../utils/libraries/CurrencyTransfer.sol
 import {CustomRevert} from "../../../../utils/libraries/CustomRevert.sol";
 import {MembershipStorage} from "../MembershipStorage.sol";
 import {Permissions} from "../../Permissions.sol";
+import {ProtocolFeeLib} from "../../ProtocolFeeLib.sol";
 
 // contracts
 import {ERC5643Base} from "../../../../diamond/facets/token/ERC5643/ERC5643Base.sol";
@@ -67,6 +68,7 @@ abstract contract MembershipJoin is
 
     struct PricingDetails {
         uint256 basePrice;
+        uint256 protocolFee;
         uint256 amountDue;
         bool shouldCharge;
     }
@@ -100,8 +102,12 @@ abstract contract MembershipJoin is
             return joinDetails;
         }
 
-        (uint256 totalRequired, ) = _getTotalMembershipPayment(membershipPrice);
-        (joinDetails.amountDue, joinDetails.shouldCharge) = (totalRequired, true);
+        (uint256 totalRequired, uint256 protocolFee) = _getTotalMembershipPayment(membershipPrice);
+        (joinDetails.protocolFee, joinDetails.amountDue, joinDetails.shouldCharge) = (
+            protocolFee,
+            totalRequired,
+            true
+        );
     }
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
@@ -150,7 +156,7 @@ abstract contract MembershipJoin is
     /// @notice Handles the process of joining a space with a referral
     /// @param receiver The address that will receive the membership token
     /// @param referral The referral information
-    function _joinSpaceWithReferral(address receiver, ReferralTypes memory referral) internal {
+    function _joinSpaceWithReferral(address receiver, ReferralTypes calldata referral) internal {
         _validateJoinSpace(receiver);
 
         PricingDetails memory joinDetails = _getPricingDetails();
@@ -229,7 +235,10 @@ abstract contract MembershipJoin is
         return amountRequired;
     }
 
-    function _validateUserReferral(address receiver, ReferralTypes memory referral) internal view {
+    function _validateUserReferral(
+        address receiver,
+        ReferralTypes calldata referral
+    ) internal view {
         if (referral.userReferral == receiver || referral.userReferral == msg.sender) {
             Membership__InvalidAddress.selector.revertWith();
         }
@@ -341,7 +350,10 @@ abstract contract MembershipJoin is
             Membership__InvalidTransactionType.selector.revertWith();
         }
 
-        _payProtocolFee(_getMembershipCurrency(), joinDetails.basePrice);
+        address currency = _getMembershipCurrency();
+        _payProtocolFee(currency, joinDetails.basePrice, joinDetails.protocolFee);
+
+        emit MembershipPaid(currency, joinDetails.basePrice, joinDetails.protocolFee);
 
         _afterChargeForJoinSpace(transactionId, receiver, joinDetails.amountDue);
     }
@@ -365,7 +377,7 @@ abstract contract MembershipJoin is
         ReferralTypes memory referral = abi.decode(referralData, (ReferralTypes));
 
         address currency = _getMembershipCurrency();
-        _payProtocolFee(currency, joinDetails.basePrice);
+        _payProtocolFee(currency, joinDetails.basePrice, joinDetails.protocolFee);
         _payPartnerFee(currency, referral.partner, joinDetails.basePrice);
         _payReferralFee(
             currency,
@@ -375,6 +387,8 @@ abstract contract MembershipJoin is
             joinDetails.basePrice
         );
 
+        emit MembershipPaid(currency, joinDetails.basePrice, joinDetails.protocolFee);
+
         _afterChargeForJoinSpace(transactionId, receiver, joinDetails.amountDue);
     }
 
@@ -410,7 +424,6 @@ abstract contract MembershipJoin is
         // set expiration of membership
         _renewSubscription(tokenId, _getMembershipDuration());
 
-        // emit event
         emit MembershipTokenIssued(receiver, tokenId);
     }
 
@@ -447,21 +460,18 @@ abstract contract MembershipJoin is
     /*                      FEE DISTRIBUTION                      */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-    /// @notice Pays the protocol fee to the platform fee recipient
+    /// @notice Pays the protocol fee via FeeManager
     /// @param currency The currency to pay in
-    /// @param membershipPrice The price of the membership
-    /// @return protocolFee The amount of protocol fee paid
-    function _payProtocolFee(
-        address currency,
-        uint256 membershipPrice
-    ) internal returns (uint256 protocolFee) {
-        protocolFee = _getProtocolFee(membershipPrice);
-
-        CurrencyTransfer.transferCurrency(
+    /// @param basePrice The base price of the membership (for fee calculation)
+    /// @param expectedFee The pre-calculated protocol fee
+    function _payProtocolFee(address currency, uint256 basePrice, uint256 expectedFee) internal {
+        ProtocolFeeLib.charge(
+            _getSpaceFactory(),
+            _getMembershipFeeType(currency),
+            msg.sender,
             currency,
-            address(this),
-            _getPlatformRequirements().getFeeRecipient(),
-            protocolFee
+            basePrice,
+            expectedFee
         );
     }
 
@@ -542,13 +552,13 @@ abstract contract MembershipJoin is
             return;
         }
 
-        (uint256 totalRequired, ) = _getTotalMembershipPayment(basePrice);
+        (uint256 totalRequired, uint256 protocolFee) = _getTotalMembershipPayment(basePrice);
 
         if (currency == CurrencyTransfer.NATIVE_TOKEN) {
             // ETH payment: validate msg.value
             if (totalRequired > msg.value) Membership__InvalidPayment.selector.revertWith();
 
-            _payProtocolFee(currency, basePrice);
+            _payProtocolFee(currency, basePrice, protocolFee);
 
             // Handle excess payment
             uint256 excess = msg.value - totalRequired;
@@ -562,9 +572,10 @@ abstract contract MembershipJoin is
             // Transfer ERC20 from payer to contract
             _transferIn(currency, payer, totalRequired);
 
-            _payProtocolFee(currency, basePrice);
+            _payProtocolFee(currency, basePrice, protocolFee);
         }
 
+        emit MembershipPaid(currency, basePrice, protocolFee);
         _mintMembershipPoints(receiver, totalRequired);
         _renewSubscription(tokenId, uint64(duration));
     }