@towns-protocol/contracts 0.0.302

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

@@ -0,0 +1,272 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IPlatformRequirements} from "../../../factory/facets/platform/requirements/IPlatformRequirements.sol";
+import {IPricingModules} from "../../../factory/facets/architect/pricing/IPricingModules.sol";
+import {IMembershipBase} from "./IMembership.sol";
+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 {MembershipStorage} from "./MembershipStorage.sol";
+
+abstract contract MembershipBase is IMembershipBase {
+    using CustomRevert for bytes4;
+    using SafeTransferLib for address;
+
+    function __MembershipBase_init(Membership memory info, address spaceFactory) internal {
+        MembershipStorage.Layout storage ds = MembershipStorage.layout();
+
+        ds.spaceFactory = spaceFactory;
+        ds.pricingModule = info.pricingModule;
+        ds.membershipCurrency = CurrencyTransfer.NATIVE_TOKEN;
+        ds.membershipMaxSupply = info.maxSupply;
+
+        if (info.freeAllocation > 0) {
+            _verifyFreeAllocation(info.freeAllocation);
+            ds.freeAllocation = info.freeAllocation;
+        }
+
+        ds.freeAllocationEnabled = true;
+
+        if (info.price > 0) {
+            _verifyPrice(info.price);
+            IMembershipPricing(info.pricingModule).setPrice(info.price);
+        }
+
+        if (info.duration > 0) {
+            _verifyDuration(info.duration);
+            ds.membershipDuration = info.duration;
+        }
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         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 _getProtocolFee(uint256 membershipPrice) internal view returns (uint256) {
+        IPlatformRequirements platform = _getPlatformRequirements();
+
+        uint256 minPrice = platform.getMembershipMinPrice();
+
+        if (membershipPrice < minPrice) return platform.getMembershipFee();
+
+        return BasisPoints.calculate(membershipPrice, platform.getMembershipBps());
+    }
+
+    function _transferIn(address from, uint256 amount) internal returns (uint256) {
+        MembershipStorage.Layout storage ds = MembershipStorage.layout();
+
+        // get the currency being used for membership
+        address currency = _getMembershipCurrency();
+
+        if (currency == CurrencyTransfer.NATIVE_TOKEN) {
+            ds.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();
+
+        ds.tokenBalance += finalAmount;
+        return finalAmount;
+    }
+
+    function _getCreatorBalance() internal view returns (uint256) {
+        return MembershipStorage.layout().tokenBalance;
+    }
+
+    function _setCreatorBalance(uint256 newBalance) internal {
+        MembershipStorage.layout().tokenBalance = newBalance;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          DURATION                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _verifyDuration(uint64 duration) internal view {
+        uint256 maxDuration = _getPlatformRequirements().getMembershipDuration();
+
+        if (duration == 0) Membership__InvalidDuration.selector.revertWith();
+
+        if (duration > maxDuration) Membership__InvalidDuration.selector.revertWith();
+    }
+
+    function _getMembershipDuration() internal view returns (uint64 duration) {
+        duration = MembershipStorage.layout().membershipDuration;
+
+        if (duration == 0) duration = _getPlatformRequirements().getMembershipDuration();
+    }
+
+    function _setMembershipDuration(uint64 duration) internal {
+        _verifyDuration(duration);
+        MembershipStorage.layout().membershipDuration = duration;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       PRICING MODULE                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _verifyPricingModule(address pricingModule) internal view {
+        if (pricingModule == address(0)) Membership__InvalidPricingModule.selector.revertWith();
+
+        if (!IPricingModules(_getSpaceFactory()).isPricingModule(pricingModule)) {
+            Membership__InvalidPricingModule.selector.revertWith();
+        }
+    }
+
+    function _setPricingModule(address newPricingModule) internal {
+        MembershipStorage.layout().pricingModule = newPricingModule;
+    }
+
+    function _getPricingModule() internal view returns (address) {
+        return MembershipStorage.layout().pricingModule;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           PRICING                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _verifyPrice(uint256 newPrice) internal view {
+        uint256 minFee = _getPlatformRequirements().getMembershipFee();
+        if (newPrice < minFee) Membership__PriceTooLow.selector.revertWith();
+    }
+
+    /// @dev Makes it virtual to allow other pricing strategies
+    function _getMembershipPrice(
+        uint256 totalSupply
+    ) internal view virtual returns (uint256 membershipPrice) {
+        // get free allocation
+        uint256 freeAllocation = _getMembershipFreeAllocation();
+        address pricingModule = _getPricingModule();
+
+        IPlatformRequirements platform = _getPlatformRequirements();
+
+        if (pricingModule == address(0)) return platform.getMembershipFee();
+
+        membershipPrice = IMembershipPricing(pricingModule).getPrice(freeAllocation, totalSupply);
+        uint256 minPrice = platform.getMembershipMinPrice();
+        if (membershipPrice < minPrice) return platform.getMembershipFee();
+    }
+
+    function _setMembershipRenewalPrice(uint256 tokenId, uint256 pricePaid) internal {
+        MembershipStorage.layout().renewalPriceByTokenId[tokenId] = pricePaid;
+    }
+
+    function _getMembershipRenewalPrice(
+        uint256 tokenId,
+        uint256 totalSupply
+    ) internal view returns (uint256) {
+        MembershipStorage.Layout storage ds = MembershipStorage.layout();
+        IPlatformRequirements platform = _getPlatformRequirements();
+
+        uint256 minFee = platform.getMembershipFee();
+        uint256 renewalPrice = ds.renewalPriceByTokenId[tokenId];
+
+        if (renewalPrice != 0) return FixedPointMathLib.max(renewalPrice, minFee);
+
+        uint256 price = _getMembershipPrice(totalSupply);
+        return FixedPointMathLib.max(price, minFee);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         ALLOCATION                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _verifyFreeAllocation(uint256 newAllocation) internal view {
+        // verify newLimit is not more than the allowed platform limit
+        if (newAllocation > _getPlatformRequirements().getMembershipMintLimit()) {
+            Membership__InvalidFreeAllocation.selector.revertWith();
+        }
+    }
+
+    function _setMembershipFreeAllocation(uint256 newAllocation) internal {
+        MembershipStorage.Layout storage ds = MembershipStorage.layout();
+        ds.freeAllocation = newAllocation;
+        ds.freeAllocationEnabled = true;
+        emit MembershipFreeAllocationUpdated(newAllocation);
+    }
+
+    function _getMembershipFreeAllocation() internal view returns (uint256) {
+        MembershipStorage.Layout storage ds = MembershipStorage.layout();
+
+        if (ds.freeAllocationEnabled) return ds.freeAllocation;
+
+        return _getPlatformRequirements().getMembershipMintLimit();
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        SUPPLY LIMIT                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _verifyMaxSupply(uint256 newLimit, uint256 totalSupply) internal pure {
+        // if the new limit is less than the current total supply, revert
+        if (newLimit < totalSupply) Membership__InvalidMaxSupply.selector.revertWith();
+    }
+
+    function _setMembershipSupplyLimit(uint256 newLimit) internal {
+        MembershipStorage.layout().membershipMaxSupply = newLimit;
+    }
+
+    function _getMembershipSupplyLimit() internal view returns (uint256) {
+        return MembershipStorage.layout().membershipMaxSupply;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          CURRENCY                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _getMembershipCurrency() internal view returns (address) {
+        return MembershipStorage.layout().membershipCurrency;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           FACTORY                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _getSpaceFactory() internal view returns (address) {
+        return MembershipStorage.layout().spaceFactory;
+    }
+
+    function _getPlatformRequirements() internal view returns (IPlatformRequirements) {
+        return IPlatformRequirements(_getSpaceFactory());
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                            IMAGE                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _getMembershipImage() internal view returns (string memory) {
+        return MembershipStorage.layout().membershipImage;
+    }
+
+    function _setMembershipImage(string memory image) internal {
+        MembershipStorage.layout().membershipImage = image;
+    }
+}

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

@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IMembership} from "./IMembership.sol";
+import {IMembershipPricing} from "./pricing/IMembershipPricing.sol";
+
+// libraries
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {ReentrancyGuard} from "solady/utils/ReentrancyGuard.sol";
+import {MembershipJoin} from "./join/MembershipJoin.sol";
+
+contract MembershipFacet is IMembership, MembershipJoin, ReentrancyGuard, Facet {
+    using CustomRevert for bytes4;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                            JOIN                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IMembership
+    function joinSpace(JoinType action, bytes calldata data) external payable nonReentrant {
+        if (action == JoinType.Basic) {
+            address receiver = abi.decode(data, (address));
+            _joinSpace(receiver);
+        } else if (action == JoinType.WithReferral) {
+            (address receiver, ReferralTypes memory referral) = abi.decode(
+                data,
+                (address, ReferralTypes)
+            );
+            _joinSpaceWithReferral(receiver, referral);
+        } else {
+            Membership__InvalidAction.selector.revertWith();
+        }
+    }
+
+    /// @inheritdoc IMembership
+    function joinSpace(address receiver) external payable nonReentrant {
+        _joinSpace(receiver);
+    }
+
+    /// @inheritdoc IMembership
+    function joinSpaceWithReferral(
+        address receiver,
+        ReferralTypes memory referral
+    ) external payable nonReentrant {
+        _joinSpaceWithReferral(receiver, referral);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           RENEWAL                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IMembership
+    function renewMembership(uint256 tokenId) external payable nonReentrant {
+        _renewMembership(msg.sender, tokenId);
+    }
+
+    /// @inheritdoc IMembership
+    function expiresAt(uint256 tokenId) external view returns (uint256) {
+        return _expiresAt(tokenId);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          DURATION                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IMembership
+    function setMembershipDuration(uint64 duration) external onlyOwner {
+        _setMembershipDuration(duration);
+    }
+
+    /// @inheritdoc IMembership
+    function getMembershipDuration() external view returns (uint64) {
+        return _getMembershipDuration();
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       PRICING MODULE                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IMembership
+    function setMembershipPricingModule(address pricingModule) external onlyOwner {
+        _verifyPricingModule(pricingModule);
+        _setPricingModule(pricingModule);
+    }
+
+    /// @inheritdoc IMembership
+    function getMembershipPricingModule() external view returns (address) {
+        return _getPricingModule();
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           PRICING                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IMembership
+    function setMembershipPrice(uint256 newPrice) external onlyOwner {
+        _verifyPrice(newPrice);
+        IMembershipPricing(_getPricingModule()).setPrice(newPrice);
+    }
+
+    /// @inheritdoc IMembership
+    function getMembershipPrice() external view returns (uint256) {
+        return _getMembershipPrice(_totalSupply());
+    }
+
+    /// @inheritdoc IMembership
+    function getMembershipRenewalPrice(uint256 tokenId) external view returns (uint256) {
+        return _getMembershipRenewalPrice(tokenId, _totalSupply());
+    }
+
+    /// @inheritdoc IMembership
+    function getProtocolFee() external view returns (uint256) {
+        return _getProtocolFee(_getMembershipPrice(_totalSupply()));
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         ALLOCATION                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IMembership
+    function setMembershipFreeAllocation(uint256 newAllocation) external onlyOwner {
+        // get current supply limit
+        uint256 currentSupplyLimit = _getMembershipSupplyLimit();
+
+        // verify newLimit is not more than the max supply limit
+        if (currentSupplyLimit != 0 && newAllocation > currentSupplyLimit) {
+            Membership__InvalidFreeAllocation.selector.revertWith();
+        }
+
+        // verify newLimit is not more than the allowed platform limit
+        _verifyFreeAllocation(newAllocation);
+        _setMembershipFreeAllocation(newAllocation);
+    }
+
+    /// @inheritdoc IMembership
+    function getMembershipFreeAllocation() external view returns (uint256) {
+        return _getMembershipFreeAllocation();
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        SUPPLY LIMIT                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IMembership
+    function setMembershipLimit(uint256 newLimit) external onlyOwner {
+        _verifyMaxSupply(newLimit, _totalSupply());
+        _setMembershipSupplyLimit(newLimit);
+    }
+
+    /// @inheritdoc IMembership
+    function getMembershipLimit() external view returns (uint256) {
+        return _getMembershipSupplyLimit();
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                            IMAGE                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IMembership
+    function setMembershipImage(string calldata newImage) external onlyOwner {
+        _setMembershipImage(newImage);
+    }
+
+    /// @inheritdoc IMembership
+    function getMembershipImage() external view returns (string memory) {
+        return _getMembershipImage();
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IMembership
+    function getMembershipCurrency() external view returns (address) {
+        return _getMembershipCurrency();
+    }
+
+    /// @inheritdoc IMembership
+    function getSpaceFactory() external view returns (address) {
+        return _getSpaceFactory();
+    }
+
+    /// @inheritdoc IMembership
+    function revenue() external view returns (uint256) {
+        return address(this).balance;
+    }
+}

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

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library MembershipStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.membership.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 public constant STORAGE_SLOT =
+        0xc21004fcc619240a31f006438274d15cd813308303284436eef6055f0fdcb600;
+
+    struct Layout {
+        mapping(uint256 => address) deprecatedMemberByTokenId;
+        mapping(address => uint256) deprecatedTokenIdByMember;
+        uint256 membershipPrice;
+        uint256 membershipMaxSupply;
+        address membershipCurrency;
+        address membershipFeeRecipient;
+        address spaceFactory;
+        uint64 membershipDuration;
+        uint256 freeAllocation;
+        address pricingModule;
+        mapping(uint256 => uint256) renewalPriceByTokenId;
+        uint256 tokenBalance;
+        mapping(bytes32 => address) pendingJoinRequests;
+        string membershipImage;
+        bool freeAllocationEnabled;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            l.slot := slot
+        }
+    }
+}