@towns-protocol/contracts 0.0.391 → 0.0.393

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.391",
-  "packageManager": "yarn@3.8.0",
+  "version": "0.0.393",
   "scripts": {
     "clean": "forge clean",
     "compile": "forge build",
@@ -34,7 +33,7 @@
     "@layerzerolabs/oapp-evm": "^0.3.2",
     "@openzeppelin/merkle-tree": "^1.0.8",
     "@prb/test": "^0.6.4",
-    "@towns-protocol/prettier-config": "^0.0.391",
+    "@towns-protocol/prettier-config": "^0.0.393",
     "@wagmi/cli": "^2.2.0",
     "forge-std": "github:foundry-rs/forge-std#v1.10.0",
     "prettier": "^3.5.3",
@@ -54,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cee1e497a4c9c60bad2675c43b20aabd0171e9a4"
+  "gitHead": "9379e7b0270d20a5b69bbaa1b674bdb27cef6c08"
 }

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

@@ -23,6 +23,7 @@ import {DeployMockLegacyArchitect} from "../facets/DeployMockLegacyArchitect.s.s
 import {DeployPartnerRegistry} from "../facets/DeployPartnerRegistry.s.sol";
 import {DeployPlatformRequirements} from "../facets/DeployPlatformRequirements.s.sol";
 import {DeployWalletLink} from "../facets/DeployWalletLink.s.sol";
+import {DeployFeeManager} from "../facets/DeployFeeManager.s.sol";
 import {LibString} from "solady/utils/LibString.sol";
 
 // contracts
@@ -152,6 +153,7 @@ contract DeploySpaceFactory is IDiamondInitHelper, DiamondHelper, Deployer {
         facetHelper.add("EIP712Facet");
         facetHelper.add("PartnerRegistry");
         facetHelper.add("FeatureManagerFacet");
+        facetHelper.add("FeeManagerFacet");
         facetHelper.add("SpaceProxyInitializer");
         facetHelper.add("SpaceFactoryInit");
 
@@ -272,6 +274,13 @@ contract DeploySpaceFactory is IDiamondInitHelper, DiamondHelper, Deployer {
             DeployFeatureManager.makeInitData()
         );
 
+        facet = facetHelper.getDeployedAddress("FeeManagerFacet");
+        addFacet(
+            makeCut(facet, FacetCutAction.Add, DeployFeeManager.selectors()),
+            facet,
+            DeployFeeManager.makeInitData(deployer)
+        );
+
         address spaceProxyInitializer = facetHelper.getDeployedAddress("SpaceProxyInitializer");
         spaceFactoryInit = facetHelper.getDeployedAddress("SpaceFactoryInit");
         spaceFactoryInitData = DeploySpaceFactoryInit.makeInitData(spaceProxyInitializer);
@@ -346,7 +355,7 @@ contract DeploySpaceFactory is IDiamondInitHelper, DiamondHelper, Deployer {
                     DeployPlatformRequirements.makeInitData(
                         deployer, // feeRecipient
                         500, // membershipBps 5%
-                        0.005 ether, // membershipFee
+                        0.0005 ether, // membershipFee
                         1000, // membershipFreeAllocation
                         365 days, // membershipDuration
                         0.001 ether // membershipMinPrice
@@ -395,6 +404,12 @@ contract DeploySpaceFactory is IDiamondInitHelper, DiamondHelper, Deployer {
                     facet,
                     DeployFeatureManager.makeInitData()
                 );
+            } else if (facetName.eq("FeeManagerFacet")) {
+                addFacet(
+                    makeCut(facet, FacetCutAction.Add, DeployFeeManager.selectors()),
+                    facet,
+                    DeployFeeManager.makeInitData(deployer)
+                );
             }
         }
     }

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

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IDiamond} from "@towns-protocol/diamond/src/Diamond.sol";
+import {IFeeManager} from "src/factory/facets/fee/IFeeManager.sol";
+
+// libraries
+import {LibDeploy} from "@towns-protocol/diamond/src/utils/LibDeploy.sol";
+import {DynamicArrayLib} from "solady/utils/DynamicArrayLib.sol";
+
+library DeployFeeManager {
+    using DynamicArrayLib for DynamicArrayLib.DynamicArray;
+
+    function selectors() internal pure returns (bytes4[] memory res) {
+        DynamicArrayLib.DynamicArray memory arr = DynamicArrayLib.p().reserve(8);
+        arr.p(IFeeManager.calculateFee.selector);
+        arr.p(IFeeManager.chargeFee.selector);
+        arr.p(IFeeManager.setFeeConfig.selector);
+        arr.p(IFeeManager.setFeeHook.selector);
+        arr.p(IFeeManager.setProtocolFeeRecipient.selector);
+        arr.p(IFeeManager.getFeeConfig.selector);
+        arr.p(IFeeManager.getFeeHook.selector);
+        arr.p(IFeeManager.getProtocolFeeRecipient.selector);
+
+        bytes32[] memory selectors_ = arr.asBytes32Array();
+        assembly ("memory-safe") {
+            res := selectors_
+        }
+    }
+
+    function makeCut(
+        address facetAddress,
+        IDiamond.FacetCutAction action
+    ) internal pure returns (IDiamond.FacetCut memory) {
+        return IDiamond.FacetCut(facetAddress, action, selectors());
+    }
+
+    function deploy() internal returns (address) {
+        return LibDeploy.deployCode("FeeManagerFacet.sol", "");
+    }
+
+    function makeInitData(address protocolFeeRecipient) internal pure returns (bytes memory) {
+        return abi.encodeCall(IFeeManager.__FeeManagerFacet__init, protocolFeeRecipient);
+    }
+}

package/scripts/interactions/{diamonds/InteractAppRegistry.s.sol → InteractAppRegistry.s.sol}

@@ -2,21 +2,21 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-import {IAppFactory, IAppFactoryBase} from "src/apps/facets/factory/IAppFactory.sol";
+import {IAppFactoryBase} from "src/apps/facets/factory/IAppFactory.sol";
 
 // libraries
 import {console} from "forge-std/console.sol";
 
 // contracts
-import {Interaction} from "../../common/Interaction.s.sol";
-import {AlphaHelper} from "../helpers/AlphaHelper.sol";
-import {DeployAppRegistry} from "../../deployments/diamonds/DeployAppRegistry.s.sol";
-import {DeploySimpleAppBeacon} from "../../deployments/diamonds/DeploySimpleAppBeacon.s.sol";
+import {Interaction} from "../common/Interaction.s.sol";
+import {AlphaHelper} from "./helpers/AlphaHelper.sol";
+import {DeployAppRegistry} from "../deployments/diamonds/DeployAppRegistry.s.sol";
+import {DeploySimpleAppBeacon} from "../deployments/diamonds/DeploySimpleAppBeacon.s.sol";
 
 // facet deployers
-import {DeployAppRegistryFacet} from "../../deployments/facets/DeployAppRegistryFacet.s.sol";
-import {DeployAppInstallerFacet} from "../../deployments/facets/DeployAppInstallerFacet.s.sol";
-import {DeployAppFactoryFacet} from "../../deployments/facets/DeployAppFactoryFacet.s.sol";
+import {DeployAppRegistryFacet} from "../deployments/facets/DeployAppRegistryFacet.s.sol";
+import {DeployAppInstallerFacet} from "../deployments/facets/DeployAppInstallerFacet.s.sol";
+import {DeployAppFactoryFacet} from "../deployments/facets/DeployAppFactoryFacet.s.sol";
 
 contract InteractAppRegistry is Interaction, AlphaHelper {
     DeployAppRegistry private deployHelper = new DeployAppRegistry();

package/scripts/interactions/InteractPostDeploy.s.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.23;
 
 // interfaces
 import {IImplementationRegistry} from "../../src/factory/facets/registry/IImplementationRegistry.sol";
-import {ISpaceDelegation} from "src/base/registry/facets/delegation/ISpaceDelegation.sol";
+import {IFeeManager} from "../../src/factory/facets/fee/IFeeManager.sol";
 import {IMainnetDelegation} from "src/base/registry/facets/mainnet/IMainnetDelegation.sol";
 import {ISpaceOwner} from "src/spaces/facets/owner/ISpaceOwner.sol";
 import {INodeOperator} from "src/base/registry/facets/operator/INodeOperator.sol";
@@ -12,6 +12,8 @@ import {ISubscriptionModule} from "src/apps/modules/subscription/ISubscriptionMo
 
 // libraries
 import {NodeOperatorStatus} from "src/base/registry/facets/operator/NodeOperatorStorage.sol";
+import {FeeCalculationMethod} from "../../src/factory/facets/fee/FeeManagerStorage.sol";
+import {FeeTypesLib} from "../../src/factory/facets/fee/FeeTypesLib.sol";
 
 // contracts
 import {MAX_CLAIMABLE_SUPPLY} from "./InteractClaimCondition.s.sol";
@@ -49,6 +51,14 @@ contract InteractPostDeploy is Interaction {
         IImplementationRegistry(spaceFactory).addImplementation(baseRegistry);
         IImplementationRegistry(spaceFactory).addImplementation(riverAirdrop);
         IImplementationRegistry(spaceFactory).addImplementation(appRegistry);
+        IFeeManager(spaceFactory).setFeeConfig(
+            FeeTypesLib.TIP_MEMBER,
+            deployer,
+            FeeCalculationMethod.PERCENT,
+            50,
+            0,
+            true
+        );
         ISubscriptionModule(subscriptionModule).setSpaceFactory(spaceFactory);
         IMainnetDelegation(baseRegistry).setProxyDelegation(proxyDelegation);
         IRewardsDistribution(baseRegistry).setRewardNotifier(deployer, true);

package/scripts/interactions/InteractSpace.s.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
+
+// libraries
+import {console} from "forge-std/console.sol";
+import {DeployTipping} from "../deployments/facets/DeployTipping.s.sol";
+
+// contracts
+import {Interaction} from "../common/Interaction.s.sol";
+import {AlphaHelper} from "./helpers/AlphaHelper.sol";
+
+contract InteractSpace is Interaction, AlphaHelper {
+    function __interact(address deployer) internal override {
+        // Get the deployed Space diamond address
+        address space = getDeployment("space");
+
+        console.log("Space Diamond:", space);
+
+        // Deploy new TippingFacet implementation
+        console.log("\n=== Deploying TippingFacet ===");
+        vm.setEnv("OVERRIDE_DEPLOYMENTS", "1");
+
+        address tippingFacet = DeployTipping.deploy();
+        console.log("TippingFacet deployed at:", tippingFacet);
+
+        // Add the cut for replacing the existing facet implementation
+        addCut(DeployTipping.makeCut(tippingFacet, FacetCutAction.Replace));
+
+        // Execute the diamond cut without initialization
+        console.log("\n=== Executing Diamond Cut to Replace TippingFacet ===");
+        vm.broadcast(deployer);
+        IDiamondCut(space).diamondCut(baseFacets(), address(0), "");
+
+        console.log("\n=== Diamond Cut Complete ===");
+        console.log("TippingFacet successfully updated on Space diamond");
+    }
+}

package/scripts/interactions/InteractSpaceFactory.s.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IFeeManager} from "src/factory/facets/fee/IFeeManager.sol";
+import {IPlatformRequirements} from "src/factory/facets/platform/requirements/IPlatformRequirements.sol";
+import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
+
+// libraries
+import {FeeTypesLib} from "src/factory/facets/fee/FeeTypesLib.sol";
+import {FeeCalculationMethod} from "src/factory/facets/fee/FeeManagerStorage.sol";
+import {console} from "forge-std/console.sol";
+import {DeployFeeManager} from "../deployments/facets/DeployFeeManager.s.sol";
+
+// contracts
+import {Interaction} from "../common/Interaction.s.sol";
+import {AlphaHelper} from "./helpers/AlphaHelper.sol";
+
+contract InteractSpaceFactory is Interaction, AlphaHelper {
+    function __interact(address deployer) internal override {
+        // Get the deployed SpaceFactory diamond address
+        address spaceFactory = getDeployment("spaceFactory");
+
+        console.log("SpaceFactory Diamond:", spaceFactory);
+
+        // Set fee recipient in PlatformRequirementsFacet
+        console.log("\n=== Setting Fee Recipient in PlatformRequirementsFacet ===");
+        vm.broadcast(deployer);
+        IPlatformRequirements(spaceFactory).setFeeRecipient(deployer);
+        console.log("Fee recipient set to:", deployer);
+
+        // Get fee recipient from PlatformRequirementsFacet
+        address protocolFeeRecipient = IPlatformRequirements(spaceFactory).getFeeRecipient();
+        console.log("Protocol Fee Recipient:", protocolFeeRecipient);
+
+        // Deploy new FeeManagerFacet implementation
+        console.log("\n=== Deploying FeeManagerFacet ===");
+        vm.setEnv("OVERRIDE_DEPLOYMENTS", "1");
+
+        address feeManagerFacet = DeployFeeManager.deploy();
+        console.log("FeeManagerFacet deployed at:", feeManagerFacet);
+
+        // Add the cut for the new facet implementation
+        addCut(DeployFeeManager.makeCut(feeManagerFacet, FacetCutAction.Add));
+
+        // Prepare initialization data with the fee recipient from PlatformRequirementsFacet
+        bytes memory initData = DeployFeeManager.makeInitData(protocolFeeRecipient);
+
+        // Execute the diamond cut with initialization
+        console.log("\n=== Executing Diamond Cut with Initialization ===");
+        vm.broadcast(deployer);
+        IDiamondCut(spaceFactory).diamondCut(baseFacets(), feeManagerFacet, initData);
+
+        console.log("\n=== Diamond Cut Complete ===");
+
+        // Set fee config for tipping
+        console.log("\n=== Setting Fee Config for Tipping ===");
+        vm.broadcast(deployer);
+        IFeeManager(spaceFactory).setFeeConfig(
+            FeeTypesLib.TIP_MEMBER,
+            address(0),
+            FeeCalculationMethod.PERCENT,
+            50, // 0.5% (50 basis points)
+            0,
+            true
+        );
+
+        console.log("Fee config set for TIP_MEMBER: 0.5% (50 bps)");
+        console.log("\n=== Interaction Complete ===");
+    }
+}

package/src/apps/facets/registry/IAppRegistry.sol

@@ -48,7 +48,6 @@ interface IAppRegistryBase {
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
     event AppRegistered(address indexed app, bytes32 uid);
     event AppUnregistered(address indexed app, bytes32 uid);
-    event AppUpdated(address indexed app, bytes32 uid);
     event AppBanned(address indexed app, bytes32 uid);
     event AppSchemaSet(bytes32 uid);
     event AppInstalled(address indexed app, address indexed account, bytes32 indexed appId);

package/src/base/registry/facets/xchain/XChainCheckLib.sol

@@ -57,10 +57,10 @@ library XChainCheckLib {
         uint256 requestId,
         IEntitlementGatedBase.NodeVoteStatus result
     ) internal {
-        uint256 nodeCount = self.nodes[requestId].length();
+        uint256 voteCount = self.votes[requestId].length;
         bool voteRecorded = false;
 
-        for (uint256 i; i < nodeCount; ++i) {
+        for (uint256 i; i < voteCount; ++i) {
             IEntitlementGatedBase.NodeVote storage currentVote = self.votes[requestId][i];
 
             if (currentVote.node == msg.sender) {
@@ -82,9 +82,10 @@ library XChainCheckLib {
         XChainLib.Check storage self,
         uint256 requestId
     ) internal view returns (VoteResults memory results) {
+        uint256 voteCount = self.votes[requestId].length;
         results.totalNodes = self.nodes[requestId].length();
 
-        for (uint256 i; i < results.totalNodes; ++i) {
+        for (uint256 i; i < voteCount; ++i) {
             IEntitlementGatedBase.NodeVote storage vote = self.votes[requestId][i];
 
             if (vote.vote == IEntitlementGatedBase.NodeVoteStatus.PASSED) {

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

@@ -0,0 +1,233 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IFeeHook, FeeHookResult} from "./IFeeHook.sol";
+import {IFeeManagerBase} from "./IFeeManager.sol";
+
+// libraries
+import {BasisPoints} from "src/utils/libraries/BasisPoints.sol";
+import {CurrencyTransfer} from "src/utils/libraries/CurrencyTransfer.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {FeeCalculationMethod, FeeConfig, FeeManagerStorage} from "./FeeManagerStorage.sol";
+import {FixedPointMathLib} from "solady/utils/FixedPointMathLib.sol";
+
+/// @title FeeManagerBase
+/// @notice Base contract with internal fee management logic
+abstract contract FeeManagerBase is IFeeManagerBase {
+    using CustomRevert for bytes4;
+    using FeeManagerStorage for FeeManagerStorage.Layout;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                    INTERNAL CALCULATIONS                   */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Calculates base fee before hook processing
+    /// @param config Fee configuration
+    /// @param amount Base amount for percentage calculations
+    /// @return baseFee The calculated base fee
+    function _calculateBaseFee(
+        FeeConfig storage config,
+        uint256 amount
+    ) internal view returns (uint256 baseFee) {
+        FeeCalculationMethod method = config.method;
+        if (method == FeeCalculationMethod.FIXED) {
+            return config.fixedFee;
+        } else if (method == FeeCalculationMethod.PERCENT) {
+            return BasisPoints.calculate(amount, config.bps);
+        } else if (method == FeeCalculationMethod.HYBRID) {
+            uint256 percentFee = BasisPoints.calculate(amount, config.bps);
+            return FixedPointMathLib.max(percentFee, config.fixedFee);
+        }
+        return 0;
+    }
+
+    /// @notice Calculates fee for estimation (view function)
+    /// @dev Does not modify state, calls hook's calculateFee if configured
+    /// @param feeType The type of fee to calculate
+    /// @param user The address that would be charged
+    /// @param amount The base amount for percentage calculations
+    /// @param extraData Additional data passed to hooks
+    /// @return finalFee The calculated fee amount
+    function _calculateFee(
+        bytes32 feeType,
+        address user,
+        uint256 amount,
+        bytes calldata extraData
+    ) internal view returns (uint256 finalFee) {
+        FeeManagerStorage.Layout storage $ = FeeManagerStorage.getLayout();
+        FeeConfig storage config = $.feeConfigs[feeType];
+
+        // Check if fee is configured and enabled
+        if (!config.enabled) return 0;
+
+        // Calculate base fee
+        uint256 baseFee = _calculateBaseFee(config, amount);
+
+        // Apply hook if configured
+        address hook = config.hook;
+        if (hook != address(0)) {
+            try IFeeHook(hook).calculateFee(feeType, user, baseFee, extraData) returns (
+                FeeHookResult memory result
+            ) {
+                return result.finalFee;
+            } catch {
+                // If hook fails, fall back to base fee
+                return baseFee;
+            }
+        }
+
+        return baseFee;
+    }
+
+    /// @notice Charges fee and transfers it (state-changing)
+    /// @dev Calls hook's onChargeFee if configured, then transfers currency
+    /// @dev Note: `user` is metadata for hooks/events. Actual payment comes from msg.sender.
+    /// @dev Hook failures fall back to base fee (consistent with calculateFee behavior)
+    /// @param feeType The type of fee to charge
+    /// @param user The address for whom the fee is being charged (for hooks/events)
+    /// @param amount The base amount for percentage calculations
+    /// @param currency The currency contract (address(0) for native token)
+    /// @param context Additional context passed to hooks
+    /// @return finalFee The actual fee charged
+    function _chargeFee(
+        bytes32 feeType,
+        address user,
+        uint256 amount,
+        address currency,
+        uint256 maxFee,
+        bytes calldata context
+    ) internal virtual returns (uint256 finalFee) {
+        FeeManagerStorage.Layout storage $ = FeeManagerStorage.getLayout();
+        FeeConfig storage config = _getFeeConfig(feeType);
+
+        // Check if fee is configured and enabled
+        if (!config.enabled) return 0;
+
+        // Calculate base fee
+        uint256 baseFee = _calculateBaseFee(config, amount);
+
+        // Apply hook if configured, with fallback to base fee on failure
+        address hook = config.hook;
+        if (hook != address(0)) {
+            try IFeeHook(hook).onChargeFee(feeType, user, baseFee, context) returns (
+                FeeHookResult memory result
+            ) {
+                finalFee = result.finalFee;
+            } catch {
+                // If hook fails, fall back to base fee (consistent with calculateFee)
+                finalFee = baseFee;
+            }
+        } else {
+            finalFee = baseFee;
+        }
+
+        // Enforce slippage protection
+        if (finalFee > maxFee) FeeManager__ExceedsMaxFee.selector.revertWith();
+
+        // Determine recipient (fallback to protocol recipient if not set)
+        address recipient = config.recipient;
+        if (recipient == address(0)) recipient = $.protocolFeeRecipient;
+
+        // Emit event before external calls (checks-effects-interactions pattern)
+        if (finalFee > 0) {
+            emit FeeCharged(feeType, user, currency, finalFee, recipient);
+        }
+
+        // Transfer fee and/or refund excess if maxFee > 0
+        if (maxFee > 0) {
+            // Convert address(0) to NATIVE_TOKEN for CurrencyTransfer library
+            address feeCurrency = currency == address(0) ? CurrencyTransfer.NATIVE_TOKEN : currency;
+
+            // For native token, validate msg.value matches maxFee
+            if (feeCurrency == CurrencyTransfer.NATIVE_TOKEN && msg.value != maxFee) {
+                CurrencyTransfer.MsgValueMismatch.selector.revertWith();
+            }
+
+            CurrencyTransfer.transferFeeWithRefund(
+                feeCurrency,
+                msg.sender,
+                recipient,
+                finalFee,
+                maxFee
+            );
+        }
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                   INTERNAL CONFIGURATION                   */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Sets fee configuration
+    /// @param feeType The fee type identifier
+    /// @param recipient Fee recipient (zero address = use protocol fee recipient)
+    /// @param method Calculation method
+    /// @param bps Basis points (1-10000)
+    /// @param fixedFee Fixed fee amount
+    /// @param enabled Whether the fee is active
+    function _setFeeConfig(
+        bytes32 feeType,
+        address recipient,
+        FeeCalculationMethod method,
+        uint16 bps,
+        uint128 fixedFee,
+        bool enabled
+    ) internal {
+        // Allow zero address recipient to fallback to protocol fee recipient
+        // Validation that protocol fee recipient is set happens at initialization
+        if (bps > BasisPoints.MAX_BPS) FeeManager__InvalidBps.selector.revertWith();
+
+        FeeConfig storage config = _getFeeConfig(feeType);
+        config.recipient = recipient;
+        config.lastUpdated = uint48(block.timestamp);
+        config.bps = bps;
+        config.method = method;
+        config.enabled = enabled;
+        config.fixedFee = fixedFee;
+
+        emit FeeConfigured(feeType, recipient, method, bps, fixedFee, enabled);
+    }
+
+    /// @notice Sets fee hook
+    /// @param feeType The fee type identifier
+    /// @param hook Address of the hook contract (zero to remove)
+    function _setFeeHook(bytes32 feeType, address hook) internal {
+        FeeConfig storage config = _getFeeConfig(feeType);
+        config.hook = hook;
+        emit FeeHookSet(feeType, hook);
+    }
+
+    /// @notice Sets protocol fee recipient
+    /// @param recipient New protocol fee recipient
+    function _setProtocolFeeRecipient(address recipient) internal {
+        if (recipient == address(0)) FeeManager__InvalidRecipient.selector.revertWith();
+        FeeManagerStorage.Layout storage $ = FeeManagerStorage.getLayout();
+        $.protocolFeeRecipient = recipient;
+        emit ProtocolFeeRecipientSet(recipient);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                     INTERNAL GETTERS                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Returns fee configuration
+    /// @param feeType The fee type identifier
+    /// @return config The fee configuration
+    function _getFeeConfig(bytes32 feeType) internal view returns (FeeConfig storage config) {
+        return FeeManagerStorage.getLayout().feeConfigs[feeType];
+    }
+
+    /// @notice Returns fee hook address
+    /// @param feeType The fee type identifier
+    /// @return hook The hook contract address
+    function _getFeeHook(bytes32 feeType) internal view returns (address hook) {
+        FeeConfig storage config = _getFeeConfig(feeType);
+        return config.hook;
+    }
+
+    /// @notice Returns protocol fee recipient
+    /// @return recipient The protocol fee recipient address
+    function _getProtocolFeeRecipient() internal view returns (address recipient) {
+        return FeeManagerStorage.getLayout().protocolFeeRecipient;
+    }
+}

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

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+import {IFeeManager} from "./IFeeManager.sol";
+import {FeeManagerBase} from "./FeeManagerBase.sol";
+import {FeeCalculationMethod, FeeConfig} from "./FeeManagerStorage.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {ReentrancyGuardTransient} from "solady/utils/ReentrancyGuardTransient.sol";
+
+/// @title FeeManagerFacet
+/// @notice Facet for unified fee management across the protocol
+contract FeeManagerFacet is
+    IFeeManager,
+    FeeManagerBase,
+    OwnableBase,
+    Facet,
+    ReentrancyGuardTransient
+{
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                   INITIALIZATION                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function __FeeManagerFacet__init(address protocolRecipient) external onlyInitializing {
+        _addInterface(type(IFeeManager).interfaceId);
+        __FeeManagerFacet__init_unchained(protocolRecipient);
+    }
+
+    function __FeeManagerFacet__init_unchained(address protocolRecipient) internal {
+        _setProtocolFeeRecipient(protocolRecipient);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       FEE OPERATIONS                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IFeeManager
+    function calculateFee(
+        bytes32 feeType,
+        address user,
+        uint256 amount,
+        bytes calldata extraData
+    ) external view returns (uint256 finalFee) {
+        return _calculateFee(feeType, user, amount, extraData);
+    }
+
+    /// @inheritdoc IFeeManager
+    function chargeFee(
+        bytes32 feeType,
+        address user,
+        uint256 amount,
+        address currency,
+        uint256 maxFee,
+        bytes calldata extraData
+    ) external payable nonReentrant returns (uint256 finalFee) {
+        return _chargeFee(feeType, user, amount, currency, maxFee, extraData);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                   CONFIGURATION (OWNER)                    */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IFeeManager
+    function setFeeConfig(
+        bytes32 feeType,
+        address recipient,
+        FeeCalculationMethod method,
+        uint16 bps,
+        uint128 fixedFee,
+        bool enabled
+    ) external onlyOwner {
+        _setFeeConfig(feeType, recipient, method, bps, fixedFee, enabled);
+    }
+
+    /// @inheritdoc IFeeManager
+    function setFeeHook(bytes32 feeType, address hook) external onlyOwner {
+        _setFeeHook(feeType, hook);
+    }
+
+    /// @inheritdoc IFeeManager
+    function setProtocolFeeRecipient(address recipient) external onlyOwner {
+        _setProtocolFeeRecipient(recipient);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IFeeManager
+    function getFeeConfig(bytes32 feeType) external view returns (FeeConfig memory config) {
+        return _getFeeConfig(feeType);
+    }
+
+    /// @inheritdoc IFeeManager
+    function getFeeHook(bytes32 feeType) external view returns (address hook) {
+        return _getFeeHook(feeType);
+    }
+
+    /// @inheritdoc IFeeManager
+    function getProtocolFeeRecipient() external view returns (address recipient) {
+        return _getProtocolFeeRecipient();
+    }
+}

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

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+/// @notice Fee calculation methods
+enum FeeCalculationMethod {
+    FIXED, // Flat fee amount
+    PERCENT, // Percentage based on BPS
+    HYBRID // Maximum of fixed fee or percentage
+}
+
+/// @notice Fee configuration for a specific fee type
+/// @param recipient Address to receive the fee
+/// @param lastUpdated Timestamp of last configuration update
+/// @param bps Basis points (1-10000) for percentage calculations
+/// @param method Fee calculation method
+/// @param enabled Whether the fee is active
+/// @param fixedFee Fixed amount in wei for FIXED or HYBRID methods
+struct FeeConfig {
+    address recipient; // 20 bytes
+    uint48 lastUpdated; // 6 bytes
+    uint16 bps; // 2 bytes
+    FeeCalculationMethod method; // 1 byte
+    bool enabled; // 1 byte
+    uint128 fixedFee; // 16 bytes
+    address hook; // 20 bytes
+}
+
+/// @title FeeManagerStorage
+/// @notice Diamond storage for the FeeManager facet
+library FeeManagerStorage {
+    /// @dev Storage slot = keccak256(abi.encode(uint256(keccak256("factory.facets.fee.manager")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xabafe0aee5292a745cc432476bbe9b496b2fe07074e3d7dcb579a3e420babf00;
+
+    struct Layout {
+        /// @notice Fee configurations by fee type
+        mapping(bytes32 => FeeConfig) feeConfigs;
+        /// @notice Protocol fee recipient
+        address protocolFeeRecipient;
+    }
+
+    /// @notice Returns the diamond storage layout
+    function getLayout() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+/// @title FeeTypesLib
+/// @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
+    bytes32 internal constant MEMBERSHIP = keccak256("FEE_TYPE.MEMBERSHIP");
+
+    /// @notice Fee for app installations
+    bytes32 internal constant APP_INSTALL = keccak256("FEE_TYPE.APP_INSTALL");
+
+    /// @notice Fee for member-to-member tips
+    bytes32 internal constant TIP_MEMBER = keccak256("FEE_TYPE.TIP_MEMBER");
+
+    /// @notice Fee for bot tips (typically zero)
+    bytes32 internal constant TIP_BOT = keccak256("FEE_TYPE.TIP_BOT");
+
+    /// @notice Protocol fee for swap operations
+    bytes32 internal constant SWAP_PROTOCOL = keccak256("FEE_TYPE.SWAP_PROTOCOL");
+
+    /// @notice Poster fee for swap operations
+    bytes32 internal constant SWAP_POSTER = keccak256("FEE_TYPE.SWAP_POSTER");
+
+    /// @notice Fee for bot actions
+    bytes32 internal constant BOT_ACTION = keccak256("FEE_TYPE.BOT_ACTION");
+}

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

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+/// @notice Result returned by fee hooks
+/// @param finalFee The final fee amount after hook processing
+/// @param metadata Optional metadata for off-chain consumption
+struct FeeHookResult {
+    uint256 finalFee;
+    bytes metadata;
+}
+
+/// @title IFeeHook
+/// @notice Interface for fee hooks that provide dynamic fee adjustments
+/// @dev Hooks can modify fees, grant exemptions, enforce quotas, or apply complex logic
+///
+/// ## Hook Execution Flow
+///
+/// 1. **Read-Only Path (`calculateFee`)**: Used for fee estimation and UI display
+///    - Pure view function with no state changes
+///    - Safe to call from any context
+///    - Used by `FeeManager.calculateFee()`
+///
+/// 2. **Write Path (`onChargeFee`)**: Used during actual fee charging
+///    - May mutate state (e.g., quota tracking, usage limits)
+///    - Called by `FeeManager.chargeFee()`
+///    - Should include all logic from `calculateFee` plus state updates
+///
+/// ## Implementation Patterns
+///
+/// ### Simple Exemption (Staking-Based)
+/// ```solidity
+/// function calculateFee(...) external view returns (FeeHookResult memory) {
+///     bool exempt = stakingRegistry.stakedAmount(user) >= threshold;
+///     return FeeHookResult({
+///         finalFee: exempt ? 0 : baseFee,
+///         metadata: ""
+///     });
+/// }
+///
+/// function onChargeFee(...) external returns (FeeHookResult memory) {
+///     return calculateFee(...); // No state to update
+/// }
+/// ```
+///
+/// ### Quota-Based (Future)
+/// ```solidity
+/// function onChargeFee(...) external returns (FeeHookResult memory) {
+///     uint256 used = quotaUsed[user]++;
+///     bool exempt = used < quota[user];
+///     return FeeHookResult({
+///         finalFee: exempt ? 0 : baseFee,
+///         metadata: abi.encode(used, quota[user])
+///     });
+/// }
+/// ```
+interface IFeeHook {
+    /// @notice Calculates fee for estimation purposes (view function)
+    /// @dev This function MUST be view/pure and not modify state
+    /// @dev Used by UIs and contracts for fee previews
+    /// @param feeType The type of fee being calculated
+    /// @param user The address being charged the fee
+    /// @param baseFee The base fee amount before hook processing
+    /// @param context Additional context (e.g., amount being tipped, item being purchased)
+    /// @return result Fee calculation result with final fee
+    function calculateFee(
+        bytes32 feeType,
+        address user,
+        uint256 baseFee,
+        bytes calldata context
+    ) external view returns (FeeHookResult memory result);
+
+    /// @notice Processes fee during actual charging (may mutate state)
+    /// @dev This function MAY modify state (e.g., quota tracking, usage counts)
+    /// @dev Called during actual fee charging via `FeeManager.chargeFee()`
+    /// @param feeType The type of fee being charged
+    /// @param user The address being charged the fee
+    /// @param baseFee The base fee amount before hook processing
+    /// @param context Additional context (e.g., amount being tipped, item being purchased)
+    /// @return result Fee calculation result with final fee
+    function onChargeFee(
+        bytes32 feeType,
+        address user,
+        uint256 baseFee,
+        bytes calldata context
+    ) external returns (FeeHookResult memory result);
+}

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

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+import {FeeCalculationMethod, FeeConfig} from "./FeeManagerStorage.sol";
+
+/// @title IFeeManagerBase
+/// @notice Base interface with errors and events
+interface IFeeManagerBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       CUSTOM ERRORS                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Fee type is not configured or is disabled
+    error FeeManager__FeeNotConfigured();
+
+    /// @dev Invalid basis points (must be 1-10000)
+    error FeeManager__InvalidBps();
+
+    /// @dev Invalid fee recipient (zero address)
+    error FeeManager__InvalidRecipient();
+
+    /// @dev Hook execution failed
+    error FeeManager__HookFailed();
+
+    /// @dev Currency transfer failed
+    error FeeManager__TransferFailed();
+
+    /// @dev Invalid hook (zero address)
+    error FeeManager__InvalidHook();
+
+    /// @dev Invalid method
+    error FeeManager__InvalidMethod();
+
+    /// @dev Max fee exceeded
+    error FeeManager__ExceedsMaxFee();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Emitted when a fee configuration is updated
+    /// @param feeType The fee type identifier
+    /// @param recipient Fee recipient address
+    /// @param method Calculation method
+    /// @param bps Basis points
+    /// @param fixedFee Fixed fee amount
+    /// @param enabled Whether the fee is enabled
+    event FeeConfigured(
+        bytes32 indexed feeType,
+        address recipient,
+        FeeCalculationMethod method,
+        uint16 bps,
+        uint128 fixedFee,
+        bool enabled
+    );
+
+    /// @notice Emitted when a fee hook is set or removed
+    /// @param feeType The fee type identifier
+    /// @param hook Address of the hook contract (zero address to remove)
+    event FeeHookSet(bytes32 indexed feeType, address hook);
+
+    /// @notice Emitted when the protocol fee recipient is updated
+    /// @param recipient New protocol fee recipient
+    event ProtocolFeeRecipientSet(address recipient);
+
+    /// @notice Emitted when a fee is charged
+    /// @param feeType The fee type identifier
+    /// @param user Address being charged
+    /// @param currency Currency contract (address(0) for native token)
+    /// @param amount Fee amount charged
+    /// @param recipient Fee recipient
+    event FeeCharged(
+        bytes32 indexed feeType,
+        address indexed user,
+        address indexed currency,
+        uint256 amount,
+        address recipient
+    );
+}
+
+/// @title IFeeManager
+/// @notice Complete interface for the FeeManager facet
+interface IFeeManager is IFeeManagerBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                   INITIALIZATION                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Initializes the FeeManager facet
+    /// @param protocolFeeRecipient Protocol fee recipient for all fees
+    function __FeeManagerFacet__init(address protocolFeeRecipient) external;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       FEE OPERATIONS                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Calculates fee for estimation purposes (view function)
+    /// @dev Does not modify state, safe for UI/contract queries
+    /// @param feeType The type of fee to calculate
+    /// @param user The address that would be charged
+    /// @param amount The base amount for percentage calculations
+    /// @param extraData Additional data passed to hooks
+    /// @return finalFee The calculated fee amount
+    function calculateFee(
+        bytes32 feeType,
+        address user,
+        uint256 amount,
+        bytes calldata extraData
+    ) external view returns (uint256 finalFee);
+
+    /// @notice Charges a fee and transfers it to the recipient
+    /// @dev Modifies state, calls hook's onChargeFee, and transfers currency
+    /// @param feeType The type of fee to charge
+    /// @param user The address being charged
+    /// @param amount The base amount for percentage calculations
+    /// @param currency The currency contract (address(0) for native token)
+    /// @param maxFee The maximum fee that can be charged (amount + slippage tolerance)
+    /// @param extraData Additional data passed to hooks
+    /// @return finalFee The actual fee charged
+    function chargeFee(
+        bytes32 feeType,
+        address user,
+        uint256 amount,
+        address currency,
+        uint256 maxFee,
+        bytes calldata extraData
+    ) external payable returns (uint256 finalFee);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                   CONFIGURATION (OWNER)                    */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Configures a fee type
+    /// @dev Only owner can call
+    /// @param feeType The fee type identifier
+    /// @param recipient Fee recipient (uses global if zero address)
+    /// @param method Calculation method
+    /// @param bps Basis points (1-10000, 10000 = 100%)
+    /// @param fixedFee Fixed fee amount in wei
+    /// @param enabled Whether the fee is active
+    function setFeeConfig(
+        bytes32 feeType,
+        address recipient,
+        FeeCalculationMethod method,
+        uint16 bps,
+        uint128 fixedFee,
+        bool enabled
+    ) external;
+
+    /// @notice Sets a fee hook for dynamic fee adjustments
+    /// @dev Only owner can call. Set to zero address to remove hook.
+    /// @param feeType The fee type identifier
+    /// @param hook Address of the hook contract
+    function setFeeHook(bytes32 feeType, address hook) external;
+
+    /// @notice Sets the protocol fee recipient
+    /// @dev Only owner can call
+    /// @param recipient New protocol fee recipient
+    function setProtocolFeeRecipient(address recipient) external;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Returns the fee configuration for a fee type
+    /// @param feeType The fee type identifier
+    /// @return config The fee configuration
+    function getFeeConfig(bytes32 feeType) external view returns (FeeConfig memory config);
+
+    /// @notice Returns the fee hook for a fee type
+    /// @param feeType The fee type identifier
+    /// @return hook The hook contract address (zero if not set)
+    function getFeeHook(bytes32 feeType) external view returns (address hook);
+
+    /// @notice Returns the protocol fee recipient
+    /// @return recipient The protocol fee recipient address
+    function getProtocolFeeRecipient() external view returns (address recipient);
+}

package/src/spaces/facets/account/AppAccountBase.sol

@@ -141,12 +141,14 @@ abstract contract AppAccountBase is
         if (currentAppId == EMPTY_UID) AppNotInstalled.selector.revertWith();
         if (currentAppId == appId) AppAlreadyInstalled.selector.revertWith();
 
-        App memory app = _getAppRegistry().getAppById(appId);
+        App memory currentApp = _getAppRegistry().getAppById(currentAppId);
 
         // revoke the current app
-        _revokeGroupAccess(currentAppId, app.client);
+        _revokeGroupAccess(currentAppId, currentApp.client);
         _setGroupStatus(currentAppId, false);
 
+        App memory app = _getAppRegistry().getAppById(appId);
+
         // update the app
         _addApp(app.module, appId);
         _setGroupStatus(appId, true, _calcExpiration(appId, app.duration));

package/src/spaces/facets/executor/ExecutorBase.sol

@@ -460,18 +460,15 @@ abstract contract ExecutorBase is IExecutorBase {
         // Fetch restrictions that apply to the caller on the targeted function
         (bool allowed, uint32 delay) = _canCall(msg.sender, target, selector);
 
-        // If call is not authorized, revert
-        if (!allowed && delay == 0) {
-            UnauthorizedCall.selector.revertWith();
-        }
+        if (!allowed && delay == 0) UnauthorizedCall.selector.revertWith();
 
         bytes32 operationId = _hashOperation(msg.sender, target, data);
+        uint48 scheduleTimepoint = _getScheduleTimepoint(operationId);
 
-        // If caller is authorized, check operation was scheduled early enough
-        // Consume an available schedule even if there is no currently enforced delay
-        if (delay != 0 || _getScheduleTimepoint(operationId) != 0) {
-            nonce = _consumeScheduledOp(operationId);
-        }
+        if (delay != 0 && scheduleTimepoint == 0) NotScheduled.selector.revertWith();
+
+        // Consume scheduled operation if one exists
+        if (scheduleTimepoint != 0) nonce = _consumeScheduledOp(operationId);
     }
 
     /// @dev Determines if a caller can invoke a function on a target, and if a delay is required.

package/src/spaces/facets/tipping/TippingBase.sol

@@ -4,15 +4,18 @@ pragma solidity ^0.8.23;
 // interfaces
 import {ITippingBase} from "./ITipping.sol";
 import {ITownsPointsBase} from "../../../airdrop/points/ITownsPoints.sol";
-import {IPlatformRequirements} from "../../../factory/facets/platform/requirements/IPlatformRequirements.sol";
+import {IFeeManager} from "../../../factory/facets/fee/IFeeManager.sol";
+import {FeeTypesLib} from "../../../factory/facets/fee/FeeTypesLib.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 // libraries
 import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
-import {BasisPoints} from "../../../utils/libraries/BasisPoints.sol";
 import {CurrencyTransfer} from "../../../utils/libraries/CurrencyTransfer.sol";
 import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
 import {MembershipStorage} from "../membership/MembershipStorage.sol";
 import {TippingStorage} from "./TippingStorage.sol";
+import {BasisPoints} from "../../../utils/libraries/BasisPoints.sol";
+import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
 
 // contracts
 import {PointsBase} from "../points/PointsBase.sol";
@@ -21,6 +24,8 @@ abstract contract TippingBase is ITippingBase, PointsBase {
     using EnumerableSet for EnumerableSet.AddressSet;
     using CustomRevert for bytes4;
 
+    uint256 internal constant MAX_FEE_TOLERANCE = 100; // 1% tolerance
+
     /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
     /*                      Internal Functions                    */
     /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
@@ -45,20 +50,15 @@ abstract contract TippingBase is ITippingBase, PointsBase {
             tipRequest.amount
         );
 
-        uint256 tipAmount = tipRequest.amount;
+        // Validate payment and transfer tokens to space
+        _validateAndTransferPayment(tipRequest.currency, tipRequest.amount);
 
-        // Handle native token
-        if (tipRequest.currency == CurrencyTransfer.NATIVE_TOKEN) {
-            if (msg.value != tipAmount) MsgValueMismatch.selector.revertWith();
-            uint256 protocolFee = _handleProtocolFee(tipAmount);
-            tipAmount -= protocolFee;
-        } else {
-            if (msg.value != 0) UnexpectedETH.selector.revertWith();
-        }
+        // Charge protocol fee and calculate net tip amount
+        uint256 protocolFee = _handleProtocolFee(tipRequest.currency, tipRequest.amount);
+        uint256 tipAmount = tipRequest.amount - protocolFee;
 
         // Process tip
         _processTip(
-            msg.sender,
             tipRequest.receiver,
             tipRequest.tokenId,
             TipRecipientType.Member,
@@ -93,20 +93,15 @@ abstract contract TippingBase is ITippingBase, PointsBase {
         MembershipTipParams memory params = abi.decode(data, (MembershipTipParams));
         _validateTipRequest(msg.sender, params.receiver, params.currency, params.amount);
 
-        uint256 tipAmount = params.amount;
+        // Validate payment and transfer tokens to space
+        _validateAndTransferPayment(params.currency, params.amount);
 
-        // Handle native token
-        if (params.currency == CurrencyTransfer.NATIVE_TOKEN) {
-            if (msg.value != tipAmount) MsgValueMismatch.selector.revertWith();
-            uint256 protocolFee = _handleProtocolFee(tipAmount);
-            tipAmount -= protocolFee;
-        } else {
-            if (msg.value != 0) UnexpectedETH.selector.revertWith();
-        }
+        // Charge protocol fee and calculate net tip amount
+        uint256 protocolFee = _handleProtocolFee(params.currency, params.amount);
+        uint256 tipAmount = params.amount - protocolFee;
 
         // Process tip
         _processTip(
-            msg.sender,
             params.receiver,
             params.tokenId,
             TipRecipientType.Member,
@@ -139,24 +134,15 @@ abstract contract TippingBase is ITippingBase, PointsBase {
     function _sendBotTip(bytes calldata data) internal {
         BotTipParams memory params = abi.decode(data, (BotTipParams));
         _validateTipRequest(msg.sender, params.receiver, params.currency, params.amount);
-
-        uint256 tipAmount = params.amount;
-
-        // Handle native token (no protocol fee for bot tips)
-        if (params.currency == CurrencyTransfer.NATIVE_TOKEN) {
-            if (msg.value != tipAmount) MsgValueMismatch.selector.revertWith();
-        } else {
-            if (msg.value != 0) UnexpectedETH.selector.revertWith();
-        }
+        _validateAndTransferPayment(params.currency, params.amount);
 
         // Process tip (tokenId = 0 for bot tips)
         _processTip(
-            msg.sender,
             params.receiver,
             0, // No tokenId for bot tips
             TipRecipientType.Bot,
             params.currency,
-            tipAmount
+            params.amount
         );
 
         emit TipSent(
@@ -164,14 +150,13 @@ abstract contract TippingBase is ITippingBase, PointsBase {
             params.receiver,
             TipRecipientType.Bot,
             params.currency,
-            tipAmount,
+            params.amount,
             params.metadata.data
         );
     }
 
     /// @dev Core tip processing logic
     function _processTip(
-        address sender,
         address receiver,
         uint256 tokenId,
         TipRecipientType recipientType,
@@ -198,24 +183,63 @@ abstract contract TippingBase is ITippingBase, PointsBase {
         }
 
         // Transfer currency
-        CurrencyTransfer.transferCurrency(currency, sender, receiver, amount);
+        CurrencyTransfer.transferCurrency(currency, address(this), receiver, amount);
+    }
+
+    /// @dev Validates payment and transfers tokens to space contract
+    /// @param currency The currency being tipped (NATIVE_TOKEN or ERC20)
+    /// @param amount The amount being tipped
+    function _validateAndTransferPayment(address currency, uint256 amount) internal {
+        if (currency == CurrencyTransfer.NATIVE_TOKEN) {
+            if (msg.value != amount) MsgValueMismatch.selector.revertWith();
+        } else {
+            if (msg.value != 0) UnexpectedETH.selector.revertWith();
+            CurrencyTransfer.transferCurrency(currency, msg.sender, address(this), amount);
+        }
     }
 
-    /// @dev Handles protocol fee and points minting
-    function _handleProtocolFee(uint256 amount) internal returns (uint256 protocolFee) {
+    /// @dev Handles protocol fee charging and points minting
+    /// @param amount The tip amount to calculate fee on
+    /// @param currency The currency of the tip (NATIVE_TOKEN or ERC20 address)
+    /// @return protocolFee The fee amount charged
+    function _handleProtocolFee(
+        address currency,
+        uint256 amount
+    ) internal returns (uint256 protocolFee) {
         MembershipStorage.Layout storage ds = MembershipStorage.layout();
-        IPlatformRequirements platform = IPlatformRequirements(ds.spaceFactory);
+        address spaceFactory = ds.spaceFactory;
+
+        // Calculate expected fee
+        uint256 expectedFee = IFeeManager(spaceFactory).calculateFee(
+            FeeTypesLib.TIP_MEMBER,
+            msg.sender,
+            amount,
+            ""
+        );
+
+        if (expectedFee == 0) return 0;
 
-        protocolFee = BasisPoints.calculate(amount, 50); // 0.5%
+        // Add slippage tolerance (1%)
+        uint256 maxFee = expectedFee + BasisPoints.calculate(expectedFee, MAX_FEE_TOLERANCE);
 
-        CurrencyTransfer.transferCurrency(
-            CurrencyTransfer.NATIVE_TOKEN,
+        // Approve ERC20 if needed (native token sends value with call)
+        bool isNative = currency == CurrencyTransfer.NATIVE_TOKEN;
+        if (!isNative) SafeTransferLib.safeApproveWithRetry(currency, spaceFactory, maxFee);
+
+        // Charge fee (excess native token will be refunded)
+        protocolFee = IFeeManager(spaceFactory).chargeFee{value: isNative ? maxFee : 0}(
+            FeeTypesLib.TIP_MEMBER,
             msg.sender,
-            platform.getFeeRecipient(),
-            protocolFee
+            amount,
+            currency,
+            maxFee,
+            ""
         );
 
-        // Mint points
+        // Reset ERC20 approval
+        if (!isNative) SafeTransferLib.safeApprove(currency, spaceFactory, 0);
+
+        // Mint points for fee payment
         address airdropDiamond = _getAirdropDiamond();
         uint256 points = _getPoints(
             airdropDiamond,

package/src/utils/libraries/CurrencyTransfer.sol

@@ -96,4 +96,32 @@ library CurrencyTransfer {
             _nativeTokenWrapper.safeTransfer(to, value);
         }
     }
+
+    /// @notice Transfers fee amount and refunds excess native token
+    /// @dev For native tokens, the subtraction maxPaid - actualFee will underflow and revert if actualFee > maxPaid.
+    /// @param currency The currency (address(0) for native)
+    /// @param payer The payer to refund
+    /// @param recipient The fee recipient
+    /// @param actualFee The actual fee amount to charge
+    /// @param maxPaid The maximum amount paid (msg.value)
+    function transferFeeWithRefund(
+        address currency,
+        address payer,
+        address recipient,
+        uint256 actualFee,
+        uint256 maxPaid
+    ) internal {
+        if (currency == NATIVE_TOKEN) {
+            // Transfer fee to recipient if non-zero
+            if (actualFee > 0) safeTransferNativeToken(recipient, actualFee);
+
+            // NOTE: uint256 underflow here (maxPaid - actualFee) will revert if actualFee > maxPaid,
+            // acting as a slippage check (never over-withdraws from msg.value).
+            uint256 refund = maxPaid - actualFee;
+            if (refund > 0) safeTransferNativeToken(payer, refund);
+        } else {
+            // ERC20: only transfer if actualFee > 0
+            if (actualFee > 0) safeTransferERC20(currency, payer, recipient, actualFee);
+        }
+    }
 }