@towns-protocol/contracts 0.0.442 → 0.0.444

package/src/factory/facets/feature/FeatureManagerMod.sol

@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IRewardsDistribution} from "../../../base/registry/facets/distribution/v2/IRewardsDistribution.sol";
+
+// libraries
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+import {LibCall} from "solady/utils/LibCall.sol";
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+
+// types
+using EnumerableSetLib for EnumerableSetLib.Bytes32Set;
+using CustomRevert for bytes4;
+
+/// @notice Emitted when a feature condition is set or updated
+/// @param featureId The unique identifier for the feature whose condition was set
+/// @param condition The condition parameters that were set for the feature
+event FeatureConditionSet(bytes32 indexed featureId, FeatureCondition condition);
+
+/// @notice Emitted when a feature condition is disabled
+/// @param featureId The unique identifier for the feature whose condition was disabled
+event FeatureConditionDisabled(bytes32 indexed featureId);
+
+/// @notice Error thrown when a threshold exceeds the token's total supply
+error InvalidThreshold();
+
+/// @notice Error thrown when a token has zero total supply
+error InvalidTotalSupply();
+
+/// @notice Error thrown when an invalid token address is provided (e.g., zero address)
+error InvalidToken();
+
+/// @notice Error thrown when the token does not implement the required interfaces (e.g., IVotes and ERC20 totalSupply)
+error InvalidInterface();
+
+/// @notice Error thrown when a feature condition is not active
+error FeatureNotActive();
+
+/// @notice Error thrown when a feature condition already exists
+error FeatureAlreadyExists();
+
+/// @notice Error thrown when an invalid condition type is provided
+error InvalidConditionType();
+
+/// @notice The type of condition for a feature
+/// @param VotingPower The condition is based on voting power
+/// @param StakingPower The condition is based on staking power
+enum ConditionType {
+    VotingPower,
+    StakingPower
+}
+
+/// @notice Represents a condition for feature activation
+/// @dev Used to determine if a feature should be enabled based on token voting power
+/// @param checker The address of the checker used for voting (must implement IVotes)
+/// @param threshold The minimum voting power (votes) required to activate the feature
+/// @param active Whether the condition is currently active
+/// @param extraData Additional data that might be used for specialized condition logic
+struct FeatureCondition {
+    address checker;
+    bool active;
+    uint256 threshold;
+    bytes extraData;
+    ConditionType conditionType;
+}
+
+// keccak256(abi.encode(uint256(keccak256("factory.facets.feature.manager.storage")) - 1)) & ~bytes32(uint256(0xff))
+bytes32 constant STORAGE_SLOT = 0x20c456a8ea15fcf7965033c954321ffd9dc82a2c65f686a77e2a67da65c29000;
+
+/// @notice Storage layout for the FeatureManager
+/// @dev Maps feature IDs to their activation conditions
+/// @custom:storage-location erc7201:factory.facets.feature.manager.storage
+struct Layout {
+    // Feature IDs
+    EnumerableSetLib.Bytes32Set featureIds;
+    // Feature ID => Condition
+    mapping(bytes32 featureId => FeatureCondition condition) conditions;
+}
+
+function getStorage() pure returns (Layout storage $) {
+    assembly {
+        $.slot := STORAGE_SLOT
+    }
+}
+
+function getSelf() view returns (address self) {
+    assembly {
+        self := address()
+    }
+}
+
+/// @notice Creates or updates a feature condition based on the create flag
+/// @dev Validates token interface compliance before storing the condition
+/// @param featureId The unique identifier for the feature
+/// @param condition The condition struct containing token, threshold, active status, and extra data
+/// @param writeIfNotExists True to write the condition if it does not exist, false to revert if it does not exist
+function upsertFeatureCondition(
+    bytes32 featureId,
+    FeatureCondition calldata condition,
+    bool writeIfNotExists
+) {
+    if (condition.conditionType == ConditionType.VotingPower) {
+        validateVotingInterface(condition);
+    } else if (condition.conditionType == ConditionType.StakingPower) {
+        validateStakingInterface(condition);
+    } else {
+        InvalidConditionType.selector.revertWith();
+    }
+
+    Layout storage $ = getStorage();
+    if (!writeIfNotExists) {
+        if (!$.featureIds.contains(featureId)) FeatureNotActive.selector.revertWith();
+    } else {
+        if (!$.featureIds.add(featureId)) FeatureAlreadyExists.selector.revertWith();
+    }
+
+    $.conditions[featureId] = condition;
+    emit FeatureConditionSet(featureId, condition);
+}
+
+/// @notice Disables a feature by setting its active flag to false
+/// @dev This does not delete the condition, only deactivates it
+/// @param featureId The unique identifier for the feature to disable
+function disableFeatureCondition(bytes32 featureId) {
+    FeatureCondition storage condition = getFeatureCondition(featureId);
+    if (!condition.active) FeatureNotActive.selector.revertWith();
+    condition.active = false;
+    emit FeatureConditionDisabled(featureId);
+}
+
+/// @notice Retrieves the condition for a specific feature
+/// @dev Returns the complete condition struct with all parameters
+/// @param featureId The unique identifier for the feature
+/// @return The complete condition configuration for the feature
+function getFeatureCondition(bytes32 featureId) view returns (FeatureCondition storage) {
+    return getStorage().conditions[featureId];
+}
+
+/// @notice Retrieves all feature conditions
+/// @dev Returns an array of all feature conditions
+/// @return conditions An array of all feature conditions
+function getFeatureConditions() view returns (FeatureCondition[] memory conditions) {
+    Layout storage $ = getStorage();
+    // Use values() over at() for full iteration - avoids bounds checking overhead
+    bytes32[] memory ids = $.featureIds.values();
+    uint256 featureCount = ids.length;
+
+    conditions = new FeatureCondition[](featureCount);
+    for (uint256 i; i < featureCount; ++i) {
+        conditions[i] = $.conditions[ids[i]];
+    }
+}
+
+/// @notice Retrieves all feature conditions for a specific addr
+/// @dev Returns an array of all feature conditions that are active for the addr
+/// @return conditions An array of all feature conditions that are active for the addr
+function getFeatureConditionsForAddress(
+    address addr
+) view returns (FeatureCondition[] memory conditions) {
+    Layout storage $ = getStorage();
+    // Use values() over at() for full iteration - avoids bounds checking overhead
+    bytes32[] memory ids = $.featureIds.values();
+    uint256 featureCount = ids.length;
+
+    // Gas optimization: Allocate full array then resize (memory cheaper than storage reads)
+    conditions = new FeatureCondition[](featureCount);
+    uint256 index;
+
+    for (uint256 i; i < featureCount; ++i) {
+        FeatureCondition storage cond = $.conditions[ids[i]];
+
+        if (isValidCondition(cond, addr)) {
+            conditions[index++] = cond;
+        }
+    }
+
+    // Resize array to actual number of valid conditions
+    assembly ("memory-safe") {
+        mstore(conditions, index)
+    }
+}
+
+function validateVotingInterface(FeatureCondition calldata condition) view {
+    if (condition.checker == address(0)) InvalidToken.selector.revertWith();
+
+    address self = getSelf();
+
+    // Check if the token implements IVotes.getVotes with proper return data
+    (bool success, bool exceededMaxCopy, bytes memory data) = LibCall.tryStaticCall(
+        condition.checker,
+        gasleft(),
+        32,
+        abi.encodeCall(IVotes.getVotes, (self))
+    );
+
+    if (!success || exceededMaxCopy || data.length != 32) InvalidInterface.selector.revertWith();
+
+    // Check if the token implements ERC20.totalSupply with proper return data
+    (success, exceededMaxCopy, data) = LibCall.tryStaticCall(
+        condition.checker,
+        gasleft(),
+        32,
+        abi.encodeCall(IERC20.totalSupply, ())
+    );
+
+    if (!success || exceededMaxCopy || data.length != 32) InvalidInterface.selector.revertWith();
+
+    uint256 totalSupply = abi.decode(data, (uint256));
+    if (totalSupply == 0) InvalidTotalSupply.selector.revertWith();
+    if (condition.threshold > totalSupply) InvalidThreshold.selector.revertWith();
+}
+
+function validateStakingInterface(FeatureCondition calldata condition) view {
+    if (condition.checker == address(0)) InvalidToken.selector.revertWith();
+    if (condition.threshold > type(uint96).max) InvalidThreshold.selector.revertWith();
+
+    address self = getSelf();
+    (bool success, bool exceededMaxCopy, bytes memory data) = LibCall.tryStaticCall(
+        condition.checker,
+        gasleft(),
+        32,
+        abi.encodeCall(IRewardsDistribution.stakedByDepositor, (self))
+    );
+
+    if (!success || exceededMaxCopy || data.length != 32) InvalidInterface.selector.revertWith();
+}
+
+/// @notice Checks if a condition should be included for a given address
+/// @dev Returns true if the condition is active, has a valid token, and meets the threshold
+/// @param condition The condition to check
+/// @param addr The address to check against
+/// @return True if the condition should be included, false otherwise
+function isValidCondition(FeatureCondition storage condition, address addr) view returns (bool) {
+    if (!condition.active) return false;
+    if (condition.checker == address(0)) return false;
+    if (condition.conditionType == ConditionType.VotingPower) {
+        uint256 votes = IVotes(condition.checker).getVotes(addr);
+        return votes >= condition.threshold;
+    } else if (condition.conditionType == ConditionType.StakingPower) {
+        uint96 staked = IRewardsDistribution(condition.checker).stakedByDepositor(addr);
+        return staked >= condition.threshold;
+    } else {
+        return false;
+    }
+}

package/src/factory/facets/feature/{IFeatureManagerFacet.sol → IFeatureManager.sol}

@@ -2,42 +2,9 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
-import {FeatureCondition} from "./FeatureManagerStorage.sol";
+import {FeatureCondition} from "./FeatureManagerMod.sol";
 
-/// @title IFeatureManagerFacetBase
-/// @notice Base interface for the FeatureManager facet defining errors and events
-/// @dev Used by the FeatureManager facet and any other facets that need to access feature conditions
-interface IFeatureManagerFacetBase {
-    /// @notice Emitted when a feature condition is set or updated
-    /// @param featureId The unique identifier for the feature whose condition was set
-    /// @param condition The condition parameters that were set for the feature
-    event FeatureConditionSet(bytes32 indexed featureId, FeatureCondition condition);
-
-    /// @notice Emitted when a feature condition is disabled
-    /// @param featureId The unique identifier for the feature whose condition was disabled
-    event FeatureConditionDisabled(bytes32 indexed featureId);
-
-    /// @notice Error thrown when a threshold exceeds the token's total supply
-    error InvalidThreshold();
-
-    /// @notice Error thrown when a token has zero total supply
-    error InvalidTotalSupply();
-
-    /// @notice Error thrown when an invalid token address is provided (e.g., zero address)
-    error InvalidToken();
-
-    /// @notice Error thrown when the token does not implement the required interfaces (e.g., IVotes and ERC20 totalSupply)
-    error InvalidInterface();
-
-    /// @notice Error thrown when a feature condition is not active
-    error FeatureNotActive();
-
-    /// @notice Error thrown when a feature condition already exists
-    error FeatureAlreadyExists();
-}
-
-interface IFeatureManagerFacet is IFeatureManagerFacetBase {
+interface IFeatureManager {
     /// @notice Sets the condition for a feature
     /// @param featureId The unique identifier for the feature
     /// @param condition The condition struct containing token, threshold, active status, and extra data

package/src/factory/facets/fee/FeeManagerFacet.sol

@@ -116,7 +116,7 @@ contract FeeManagerFacet is
             true
         );
 
-        // membership fee
+        // membership fee (ETH)
         _setFeeConfig(
             FeeTypesLib.MEMBERSHIP,
             protocolRecipient,

package/src/factory/facets/fee/FeeTypesLib.sol

@@ -5,7 +5,7 @@ pragma solidity ^0.8.29;
 /// @notice Library defining fee type constants for the FeeManager system
 /// @dev Uses keccak256 for gas-efficient constant generation
 library FeeTypesLib {
-    /// @notice Fee for space membership purchases
+    /// @notice Fee for space membership purchases (ETH)
     bytes32 internal constant MEMBERSHIP = keccak256("FEE_TYPE.MEMBERSHIP");
 
     /// @notice Fee for app installations
@@ -25,4 +25,11 @@ library FeeTypesLib {
 
     /// @notice Fee for bot actions
     bytes32 internal constant BOT_ACTION = keccak256("FEE_TYPE.BOT_ACTION");
+
+    /// @notice Generates fee type for membership based on currency
+    /// @param currency The payment currency address
+    /// @return The fee type identifier for the given currency
+    function membership(address currency) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked("FEE_TYPE.MEMBERSHIP", currency));
+    }
 }

package/src/spaces/facets/dispatcher/DispatcherBase.sol

@@ -25,9 +25,9 @@ abstract contract DispatcherBase is IDispatcherBase {
         return ds.transactionData.get(transactionId).value;
     }
 
-    function _captureValue(bytes32 transactionId) internal {
+    function _captureValue(bytes32 transactionId, uint256 value) internal {
         DispatcherStorage.Layout storage ds = DispatcherStorage.layout();
-        ds.transactionBalance[transactionId] += msg.value;
+        ds.transactionBalance[transactionId] += value;
     }
 
     function _releaseCapturedValue(bytes32 transactionId, uint256 value) internal {
@@ -62,9 +62,15 @@ abstract contract DispatcherBase is IDispatcherBase {
         return keccak256(abi.encodePacked(keyHash, inputSeed));
     }
 
+    /// @notice Registers a transaction and captures payment
+    /// @param sender The address initiating the transaction
+    /// @param data The encoded transaction data
+    /// @param capturedAmount The amount captured (ETH or ERC20)
+    /// @return transactionId The unique identifier for this transaction
     function _registerTransaction(
         address sender,
-        bytes memory data
+        bytes memory data,
+        uint256 capturedAmount
     ) internal returns (bytes32 transactionId) {
         bytes32 keyHash = keccak256(abi.encodePacked(sender, block.number));
 
@@ -75,12 +81,14 @@ abstract contract DispatcherBase is IDispatcherBase {
 
         DispatcherStorage.Layout storage ds = DispatcherStorage.layout();
         StoragePointer.Bytes storage capturedDataRef = ds.transactionData.get(transactionId);
+
         // revert if the transaction already exists
         if (capturedDataRef.value.length > 0) {
             Dispatcher__TransactionAlreadyExists.selector.revertWith();
         }
-
         capturedDataRef.value = data;
-        if (msg.value != 0) _captureValue(transactionId);
+
+        // Capture payment amount
+        if (capturedAmount != 0) _captureValue(transactionId, capturedAmount);
     }
 }

package/src/spaces/facets/gated/EntitlementGated.sol

@@ -3,7 +3,6 @@ pragma solidity ^0.8.23;
 
 // interfaces
 import {IEntitlementGated} from "./IEntitlementGated.sol";
-
 import {IEntitlementChecker} from "src/base/registry/facets/checker/IEntitlementChecker.sol";
 import {IRuleEntitlement} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
 
@@ -14,7 +13,12 @@ import {EntitlementGatedBase} from "./EntitlementGatedBase.sol";
 import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
 import {ReentrancyGuard} from "solady/utils/ReentrancyGuard.sol";
 
-contract EntitlementGated is IEntitlementGated, EntitlementGatedBase, ReentrancyGuard, Facet {
+abstract contract EntitlementGated is
+    IEntitlementGated,
+    EntitlementGatedBase,
+    ReentrancyGuard,
+    Facet
+{
     function __EntitlementGated_init(
         IEntitlementChecker entitlementChecker
     ) external onlyInitializing {
@@ -26,8 +30,8 @@ contract EntitlementGated is IEntitlementGated, EntitlementGatedBase, Reentrancy
         _setEntitlementChecker(entitlementChecker);
     }
 
-    // Called by the xchain node to post the result of the entitlement check
-    // the internal function validates the transactionId and the result
+    /// @notice Called by the xchain node to post the result of the entitlement check
+    /// @dev the internal function validates the transactionId and the result
     function postEntitlementCheckResult(
         bytes32 transactionId,
         uint256 roleId,
@@ -49,7 +53,7 @@ contract EntitlementGated is IEntitlementGated, EntitlementGatedBase, Reentrancy
         _postEntitlementCheckResultV2(transactionId, roleId, result);
     }
 
-    /// deprecated Use EntitlementDataQueryable.getCrossChainEntitlementData instead
+    /// @dev deprecated Use EntitlementDataQueryable.getCrossChainEntitlementData instead
     function getRuleData(
         bytes32 transactionId,
         uint256 roleId

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

@@ -58,6 +58,12 @@ interface IMembershipBase {
     error Membership__InvalidAction();
     error Membership__CannotSetFreeAllocationOnPaidSpace();
 
+    /// @notice Error thrown when ETH is sent for ERC20 payment
+    error Membership__UnexpectedValue();
+
+    /// @notice Error thrown when currency is not supported for fees
+    error Membership__UnsupportedCurrency();
+
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                           EVENTS                           */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
@@ -67,7 +73,7 @@ interface IMembershipBase {
     event MembershipCurrencyUpdated(address indexed currency);
     event MembershipFeeRecipientUpdated(address indexed recipient);
     event MembershipFreeAllocationUpdated(uint256 indexed allocation);
-    event MembershipWithdrawal(address indexed recipient, uint256 amount);
+    event MembershipWithdrawal(address indexed currency, address indexed recipient, uint256 amount);
     event MembershipTokenIssued(address indexed recipient, uint256 indexed tokenId);
     event MembershipTokenRejected(address indexed recipient);
 }
@@ -191,6 +197,10 @@ interface IMembership is IMembershipBase {
     /// @return The membership currency
     function getMembershipCurrency() external view returns (address);
 
+    /// @notice Set the membership currency
+    /// @param currency The new membership currency address
+    function setMembershipCurrency(address currency) external;
+
     /// @notice Get the space factory
     /// @return The space factory
     function getSpaceFactory() external view returns (address);

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

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.23;
 
 // interfaces
+import {IFeeManager} from "../../../factory/facets/fee/IFeeManager.sol";
 import {IPlatformRequirements} from "../../../factory/facets/platform/requirements/IPlatformRequirements.sol";
 import {IPricingModules} from "../../../factory/facets/architect/pricing/IPricingModules.sol";
 import {IMembershipBase} from "./IMembership.sol";
@@ -10,9 +11,10 @@ import {IMembershipPricing} from "./pricing/IMembershipPricing.sol";
 // libraries
 import {FixedPointMathLib} from "solady/utils/FixedPointMathLib.sol";
 import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
-import {BasisPoints} from "../../../utils/libraries/BasisPoints.sol";
 import {CurrencyTransfer} from "../../../utils/libraries/CurrencyTransfer.sol";
 import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {FeeTypesLib} from "../../../factory/facets/fee/FeeTypesLib.sol";
+import {FeeConfig} from "../../../factory/facets/fee/FeeManagerStorage.sol";
 import {MembershipStorage} from "./MembershipStorage.sol";
 
 abstract contract MembershipBase is IMembershipBase {
@@ -24,7 +26,7 @@ abstract contract MembershipBase is IMembershipBase {
 
         $.spaceFactory = spaceFactory;
         $.pricingModule = info.pricingModule;
-        $.membershipCurrency = CurrencyTransfer.NATIVE_TOKEN;
+        _setMembershipCurrency(info.currency);
         $.membershipMaxSupply = info.maxSupply;
 
         if (info.freeAllocation > 0) {
@@ -50,21 +52,6 @@ abstract contract MembershipBase is IMembershipBase {
     /*                         MEMBERSHIP                         */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-    function _collectProtocolFee(
-        address payer,
-        uint256 membershipPrice
-    ) internal returns (uint256 protocolFee) {
-        protocolFee = _getProtocolFee(membershipPrice);
-
-        // transfer the platform fee to the platform fee recipient
-        CurrencyTransfer.transferCurrency(
-            _getMembershipCurrency(),
-            payer, // from
-            _getPlatformRequirements().getFeeRecipient(), // to
-            protocolFee
-        );
-    }
-
     function _getMembershipPrice(
         uint256 totalSupply
     ) internal view virtual returns (uint256 membershipPrice) {
@@ -75,51 +62,23 @@ abstract contract MembershipBase is IMembershipBase {
     }
 
     function _getProtocolFee(uint256 membershipPrice) internal view returns (uint256) {
-        IPlatformRequirements platform = _getPlatformRequirements();
-        uint256 baseFee = platform.getMembershipFee();
-        if (membershipPrice == 0) return baseFee;
-        uint256 bpsFee = BasisPoints.calculate(membershipPrice, platform.getMembershipBps());
-        return FixedPointMathLib.max(bpsFee, baseFee);
+        bytes32 feeType = _getMembershipFeeType(_getMembershipCurrency());
+        return
+            IFeeManager(_getSpaceFactory()).calculateFee(feeType, address(0), membershipPrice, "");
+    }
+
+    /// @notice Returns the fee type for the membership currency
+    /// @dev Uses dynamic fee type for non-native currencies
+    function _getMembershipFeeType(address currency) internal pure returns (bytes32) {
+        if (currency == CurrencyTransfer.NATIVE_TOKEN) return FeeTypesLib.MEMBERSHIP;
+        return FeeTypesLib.membership(currency);
     }
 
     function _getTotalMembershipPayment(
         uint256 membershipPrice
     ) internal view returns (uint256 totalRequired, uint256 protocolFee) {
         protocolFee = _getProtocolFee(membershipPrice);
-        if (membershipPrice == 0) return (protocolFee, protocolFee);
-        return (membershipPrice + protocolFee, protocolFee);
-    }
-
-    function _transferIn(address from, uint256 amount) internal returns (uint256) {
-        MembershipStorage.Layout storage $ = MembershipStorage.layout();
-
-        // get the currency being used for membership
-        address currency = _getMembershipCurrency();
-
-        if (currency == CurrencyTransfer.NATIVE_TOKEN) {
-            $.tokenBalance += amount;
-            return amount;
-        }
-
-        // handle erc20 tokens
-        uint256 balanceBefore = currency.balanceOf(address(this));
-        CurrencyTransfer.safeTransferERC20(currency, from, address(this), amount);
-        uint256 balanceAfter = currency.balanceOf(address(this));
-
-        // Calculate the amount of tokens transferred
-        uint256 finalAmount = balanceAfter - balanceBefore;
-        if (finalAmount != amount) Membership__InsufficientPayment.selector.revertWith();
-
-        $.tokenBalance += finalAmount;
-        return finalAmount;
-    }
-
-    function _getCreatorBalance() internal view returns (uint256) {
-        return MembershipStorage.layout().tokenBalance;
-    }
-
-    function _setCreatorBalance(uint256 newBalance) internal {
-        MembershipStorage.layout().tokenBalance = newBalance;
+        totalRequired = membershipPrice + protocolFee;
     }
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
@@ -202,7 +161,6 @@ abstract contract MembershipBase is IMembershipBase {
     function _setMembershipFreeAllocation(uint256 newAllocation) internal {
         MembershipStorage.Layout storage $ = MembershipStorage.layout();
         ($.freeAllocation, $.freeAllocationEnabled) = (newAllocation, true);
-        emit MembershipFreeAllocationUpdated(newAllocation);
     }
 
     function _getMembershipFreeAllocation() internal view returns (uint256) {
@@ -234,8 +192,21 @@ abstract contract MembershipBase is IMembershipBase {
     /*                          CURRENCY                          */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-    function _getMembershipCurrency() internal view returns (address) {
-        return MembershipStorage.layout().membershipCurrency;
+    /// @dev Sets the membership currency. Only currencies with an enabled fee config in FeeManager
+    /// can be set. Native token (address(0) or NATIVE_TOKEN) is always supported.
+    function _setMembershipCurrency(address currency) internal {
+        if (!(currency == address(0) || currency == CurrencyTransfer.NATIVE_TOKEN)) {
+            bytes32 feeType = FeeTypesLib.membership(currency);
+            FeeConfig memory config = IFeeManager(_getSpaceFactory()).getFeeConfig(feeType);
+            if (!config.enabled) Membership__UnsupportedCurrency.selector.revertWith();
+        }
+        MembershipStorage.layout().membershipCurrency = currency;
+    }
+
+    function _getMembershipCurrency() internal view returns (address currency) {
+        currency = MembershipStorage.layout().membershipCurrency;
+        // Normalize address(0) to NATIVE_TOKEN for backwards compatibility
+        if (currency == address(0)) currency = CurrencyTransfer.NATIVE_TOKEN;
     }
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/

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

@@ -6,6 +6,8 @@ import {IMembership} from "./IMembership.sol";
 import {IMembershipPricing} from "./pricing/IMembershipPricing.sol";
 
 // libraries
+import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
+import {CurrencyTransfer} from "../../../utils/libraries/CurrencyTransfer.sol";
 import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
 
 // contracts
@@ -15,6 +17,7 @@ import {MembershipJoin} from "./join/MembershipJoin.sol";
 
 contract MembershipFacet is IMembership, MembershipJoin, ReentrancyGuard, Facet {
     using CustomRevert for bytes4;
+    using SafeTransferLib for address;
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                            JOIN                            */
@@ -141,6 +144,7 @@ contract MembershipFacet is IMembership, MembershipJoin, ReentrancyGuard, Facet
 
         _verifyFreeAllocation(newAllocation);
         _setMembershipFreeAllocation(newAllocation);
+        emit MembershipFreeAllocationUpdated(newAllocation);
     }
 
     /// @inheritdoc IMembership
@@ -178,14 +182,24 @@ contract MembershipFacet is IMembership, MembershipJoin, ReentrancyGuard, Facet
     }
 
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
-    /*                          GETTERS                           */
+    /*                          CURRENCY                          */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
+    /// @inheritdoc IMembership
+    function setMembershipCurrency(address currency) external onlyOwner {
+        _setMembershipCurrency(currency);
+        emit MembershipCurrencyUpdated(currency);
+    }
+
     /// @inheritdoc IMembership
     function getMembershipCurrency() external view returns (address) {
         return _getMembershipCurrency();
     }
 
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
     /// @inheritdoc IMembership
     function getSpaceFactory() external view returns (address) {
         return _getSpaceFactory();
@@ -193,6 +207,10 @@ contract MembershipFacet is IMembership, MembershipJoin, ReentrancyGuard, Facet
 
     /// @inheritdoc IMembership
     function revenue() external view returns (uint256) {
+        address currency = _getMembershipCurrency();
+        if (currency != CurrencyTransfer.NATIVE_TOKEN) {
+            return currency.balanceOf(address(this));
+        }
         return address(this).balance;
     }
 }

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

@@ -25,6 +25,7 @@ library MembershipStorage {
         uint256 freeAllocation;
         address pricingModule;
         mapping(uint256 => uint256) renewalPriceByTokenId;
+        // deprecated
         uint256 tokenBalance;
         mapping(bytes32 => address) pendingJoinRequests;
         string membershipImage;