@towns-protocol/contracts 0.0.302

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

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IRuleEntitlement} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+
+interface IEntitlementGatedBase {
+    enum NodeVoteStatus {
+        NOT_VOTED,
+        PASSED,
+        FAILED
+    }
+
+    struct NodeVote {
+        address node;
+        NodeVoteStatus vote;
+    }
+
+    struct Transaction {
+        bool finalized;
+        address clientAddress;
+        mapping(uint256 => NodeVote[]) nodeVotesArray;
+        mapping(uint256 => bool) isCompleted;
+        IRuleEntitlement entitlement;
+        uint256[] roleIds;
+    }
+
+    error EntitlementGated_InvalidAddress();
+    error EntitlementGated_TransactionCheckAlreadyRegistered();
+    error EntitlementGated_TransactionCheckAlreadyCompleted();
+    error EntitlementGated_TransactionNotRegistered();
+    error EntitlementGated_NodeNotFound();
+    error EntitlementGated_NodeAlreadyVoted();
+    error EntitlementGated_OnlyEntitlementChecker();
+    error EntitlementGated_InvalidEntitlement();
+    error EntitlementGated_RequestIdNotFound();
+    error EntitlementGated_InvalidValue();
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    event EntitlementCheckResultPosted(bytes32 indexed transactionId, NodeVoteStatus result);
+}
+
+interface IEntitlementGated is IEntitlementGatedBase {
+    function postEntitlementCheckResult(
+        bytes32 transactionId,
+        uint256 roleId,
+        NodeVoteStatus result
+    ) external;
+
+    function getRuleData(
+        bytes32 transactionId,
+        uint256 roleId
+    ) external view returns (IRuleEntitlement.RuleData memory);
+}

package/src/spaces/facets/guardian/GuardianBase.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IGuardianBase} from "./IGuardian.sol";
+
+// libraries
+
+import {GuardianStorage} from "./GuardianStorage.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {SpaceOwnerStorage} from "src/spaces/facets/owner/SpaceOwnerStorage.sol";
+
+abstract contract GuardianBase is IGuardianBase {
+    function _setDefaultCooldown(uint256 cooldown) internal {
+        GuardianStorage.layout().defaultCooldown = cooldown;
+        emit GuardianDefaultCooldownUpdated(cooldown);
+    }
+
+    function _getDefaultCooldown() internal view returns (uint256) {
+        return GuardianStorage.layout().defaultCooldown;
+    }
+
+    /**
+     * @notice Enables a guardian
+     * @param guardian The guardian address
+     */
+    function _enableGuardian(address guardian) internal {
+        GuardianStorage.Layout storage ds = GuardianStorage.layout();
+
+        if (ds.cooldownByAddress[guardian] == 0) {
+            revert Guardian_AlreadyEnabled();
+        }
+
+        ds.cooldownByAddress[guardian] = 0;
+
+        emit GuardianUpdated(guardian, true, 0, block.timestamp);
+    }
+
+    /**
+     * @notice Disables a guardian
+     * @param guardian The guardian address
+     */
+    function _disableGuardian(address guardian) internal {
+        GuardianStorage.Layout storage ds = GuardianStorage.layout();
+
+        if (ds.cooldownByAddress[guardian] != 0) {
+            revert Guardian_AlreadyDisabled();
+        }
+
+        ds.cooldownByAddress[guardian] = block.timestamp + ds.defaultCooldown;
+
+        emit GuardianUpdated(
+            guardian,
+            false,
+            block.timestamp + ds.defaultCooldown,
+            block.timestamp
+        );
+    }
+
+    function _guardianCooldown(address guardian) internal view returns (uint256) {
+        return GuardianStorage.layout().cooldownByAddress[guardian];
+    }
+
+    /**
+     * @notice Returns true if the guardian is enabled
+     * @param guardian The guardian address
+     * @return True if the guardian is enabled
+     */
+    function _guardianEnabled(address guardian) internal view returns (bool) {
+        GuardianStorage.Layout storage ds = GuardianStorage.layout();
+
+        // guardian is enabled if it is not a contract and
+        // - it has no cooldown or
+        // - it has a cooldown but it has not passed yet
+        return
+            SpaceOwnerStorage.layout().factory != guardian &&
+            (ds.cooldownByAddress[guardian] == 0 ||
+                block.timestamp < ds.cooldownByAddress[guardian]);
+    }
+}

package/src/spaces/facets/guardian/GuardianFacet.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IGuardian} from "./IGuardian.sol";
+
+// libraries
+
+// contracts
+import {GuardianBase} from "./GuardianBase.sol";
+
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+
+contract GuardianFacet is IGuardian, GuardianBase, OwnableBase, Facet {
+    function __GuardianFacet_init(uint256 cooldown) external onlyInitializing {
+        _setDefaultCooldown(cooldown);
+    }
+
+    function enableGuardian() external {
+        _enableGuardian(msg.sender);
+    }
+
+    function guardianCooldown(address guardian) external view returns (uint256) {
+        return _guardianCooldown(guardian);
+    }
+
+    function disableGuardian() external {
+        _disableGuardian(msg.sender);
+    }
+
+    function isGuardianEnabled(address guardian) external view returns (bool) {
+        return _guardianEnabled(guardian);
+    }
+
+    function getDefaultCooldown() external view returns (uint256) {
+        return _getDefaultCooldown();
+    }
+
+    function setDefaultCooldown(uint256 cooldown) external onlyOwner {
+        _setDefaultCooldown(cooldown);
+    }
+}

package/src/spaces/facets/guardian/GuardianStorage.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library GuardianStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.guardian.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 constant STORAGE_POSITION =
+        0x0c89d3aad1b583c77a2e9f9fffa651b386c9c29e300bf2a8e2f3de1bb0100a00;
+
+    struct Layout {
+        uint256 defaultCooldown;
+        mapping(address => uint256) cooldownByAddress;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 slot = STORAGE_POSITION;
+        assembly {
+            l.slot := slot
+        }
+    }
+}

package/src/spaces/facets/guardian/IGuardian.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface IGuardianBase {
+    error Guardian_Enabled();
+    error Guardian_AlreadyEnabled();
+    error Guardian_AlreadyDisabled();
+
+    event GuardianUpdated(
+        address indexed caller,
+        bool indexed enabled,
+        uint256 cooldown,
+        uint256 timestamp
+    );
+
+    event GuardianDefaultCooldownUpdated(uint256 indexed cooldown);
+}
+
+interface IGuardian is IGuardianBase {
+    /// @notice Enables the guardian mode for the caller
+    /// @dev Can only be called by an EOA (Externally Owned Account)
+    /// @dev Emits a GuardianUpdated event
+    function enableGuardian() external;
+
+    /// @notice Disables the guardian mode for the caller
+    /// @dev Can only be called by an EOA (Externally Owned Account)
+    /// @dev Emits a GuardianUpdated event
+    function disableGuardian() external;
+
+    /// @notice Returns the cooldown period for a specific guardian
+    /// @param guardian The address of the guardian to check
+    /// @return The cooldown period in seconds
+    function guardianCooldown(address guardian) external view returns (uint256);
+
+    /// @notice Checks if guardian mode is enabled for a specific address
+    /// @param guardian The address to check
+    /// @return True if guardian mode is enabled, false otherwise
+    function isGuardianEnabled(address guardian) external view returns (bool);
+
+    /// @notice Returns the default cooldown period
+    /// @return The default cooldown period in seconds
+    function getDefaultCooldown() external view returns (uint256);
+
+    /// @notice Sets the default cooldown period
+    /// @dev Can only be called by the contract owner
+    /// @param cooldown The new default cooldown period in seconds
+    function setDefaultCooldown(uint256 cooldown) external;
+}

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

@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+interface IMembershipBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           ENUMS                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice JoinType enum for unified membership join dispatch
+    /// @dev To encode data for each action:
+    ///   switch (action) {
+    ///     case JoinType.Basic:
+    ///       data = abi.encode(address receiver);
+    ///     case JoinType.WithReferral:
+    ///       data = abi.encode(address receiver, ReferralTypes memory referral);
+    ///   }
+    enum JoinType {
+        Basic, // Basic join with just receiver address
+        WithReferral // Join with referral information
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           STRUCTS                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    struct Membership {
+        string name;
+        string symbol;
+        uint256 price;
+        uint256 maxSupply;
+        uint64 duration;
+        address currency;
+        address feeRecipient;
+        uint256 freeAllocation;
+        address pricingModule;
+    }
+
+    struct ReferralTypes {
+        address partner;
+        address userReferral;
+        string referralCode;
+    }
+
+    struct PricingDetails {
+        uint256 basePrice;
+        uint256 amountDue;
+        bool shouldCharge;
+        bool isPrepaid;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           ERRORS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    error Membership__InvalidAddress();
+    error Membership__InvalidPrice();
+    error Membership__InvalidLimit();
+    error Membership__InvalidCurrency();
+    error Membership__InvalidFeeRecipient();
+    error Membership__InvalidDuration();
+    error Membership__InvalidMaxSupply();
+    error Membership__InvalidFreeAllocation();
+    error Membership__InvalidPricingModule();
+    error Membership__AlreadyMember();
+    error Membership__InsufficientPayment();
+    error Membership__PriceTooLow();
+    error Membership__MaxSupplyReached();
+    error Membership__InvalidTokenId();
+    error Membership__NotExpired();
+    error Membership__InsufficientAllowance();
+    error Membership__InvalidPayment();
+    error Membership__InvalidTransactionType();
+    error Membership__Banned();
+    error Membership__InvalidAction();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    event MembershipPriceUpdated(uint256 indexed price);
+    event MembershipLimitUpdated(uint256 indexed limit);
+    event MembershipCurrencyUpdated(address indexed currency);
+    event MembershipFeeRecipientUpdated(address indexed recipient);
+    event MembershipFreeAllocationUpdated(uint256 indexed allocation);
+    event MembershipWithdrawal(address indexed recipient, uint256 amount);
+    event MembershipTokenIssued(address indexed recipient, uint256 indexed tokenId);
+    event MembershipTokenRejected(address indexed recipient);
+}
+
+interface IMembership is IMembershipBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           MINTING                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Unified entry point for joining spaces with different configurations
+    /// @param action The type of join action to perform
+    /// @param data ABI-encoded data for the specific action type
+    function joinSpace(JoinType action, bytes calldata data) external payable;
+
+    /// @notice Join a space
+    /// @param receiver The address of the receiver
+    function joinSpace(address receiver) external payable;
+
+    /// @notice Join a space with a referral
+    /// @param receiver The address of the receiver
+    /// @param referral The referral data
+    function joinSpaceWithReferral(
+        address receiver,
+        ReferralTypes memory referral
+    ) external payable;
+
+    /// @notice Renew a space membership
+    /// @param tokenId The token id of the membership
+    function renewMembership(uint256 tokenId) external payable;
+
+    /// @notice Return the expiration date of a membership
+    /// @param tokenId The token id of the membership
+    function expiresAt(uint256 tokenId) external view returns (uint256);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         DURATION                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Get the membership duration
+    /// @return The membership duration
+    function getMembershipDuration() external view returns (uint64);
+
+    /// @notice Set the membership duration
+    /// @param duration The new membership duration in seconds
+    function setMembershipDuration(uint64 duration) external;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       PRICING MODULE                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Set the membership pricing module
+    /// @param pricingModule The new pricing module
+    function setMembershipPricingModule(address pricingModule) external;
+
+    /// @notice Get the membership pricing module
+    /// @return The membership pricing module
+    function getMembershipPricingModule() external view returns (address);
+
+    /// @notice Get the protocol fee
+    /// @return The protocol fee
+    function getProtocolFee() external view returns (uint256);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          PRICING                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Set the membership price
+    /// @param newPrice The new membership price
+    function setMembershipPrice(uint256 newPrice) external;
+
+    /// @notice Get the membership price
+    /// @return The membership price
+    function getMembershipPrice() external view returns (uint256);
+
+    /// @notice Get the membership renewal price
+    /// @param tokenId The token id of the membership
+    /// @return The membership renewal price
+    function getMembershipRenewalPrice(uint256 tokenId) external view returns (uint256);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         ALLOCATION                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Set the membership free allocation
+    /// @param newAllocation The new membership free allocation
+    function setMembershipFreeAllocation(uint256 newAllocation) external;
+
+    /// @notice Get the membership free allocation
+    /// @return The membership free allocation
+    function getMembershipFreeAllocation() external view returns (uint256);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          LIMITS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Set the membership limit
+    /// @param newLimit The new membership limit
+    function setMembershipLimit(uint256 newLimit) external;
+
+    /// @notice Get the membership limit
+    /// @return The membership limit
+    function getMembershipLimit() external view returns (uint256);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           IMAGE                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Set the membership image
+    /// @param image The new membership image
+    function setMembershipImage(string calldata image) external;
+
+    /// @notice Get the membership image
+    /// @return The membership image
+    function getMembershipImage() external view returns (string memory);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Get the membership currency
+    /// @return The membership currency
+    function getMembershipCurrency() external view returns (address);
+
+    /// @notice Get the space factory
+    /// @return The space factory
+    function getSpaceFactory() external view returns (address);
+
+    /// @notice Get the current balance of funds held by the space
+    /// @return The current balance of funds held by the space
+    function revenue() external view returns (uint256);
+}