@towns-protocol/contracts 0.0.302

package/src/spaces/facets/treasury/Treasury.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
+import {IMembershipBase} from "src/spaces/facets/membership/IMembership.sol";
+import {ITreasury} from "src/spaces/facets/treasury/ITreasury.sol";
+
+// libraries
+import {CurrencyTransfer} from "src/utils/libraries/CurrencyTransfer.sol";
+
+// contracts
+
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {TokenOwnableBase} from "@towns-protocol/diamond/src/facets/ownable/token/TokenOwnableBase.sol";
+import {MembershipStorage} from "src/spaces/facets/membership/MembershipStorage.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {ReentrancyGuard} from "solady/utils/ReentrancyGuard.sol";
+
+contract Treasury is TokenOwnableBase, ReentrancyGuard, Facet, ITreasury {
+    function __Treasury_init() external onlyInitializing {
+        _addInterface(type(IERC1155Receiver).interfaceId);
+    }
+
+    ///@inheritdoc ITreasury
+    function withdraw(address account) external onlyOwner nonReentrant {
+        if (account == address(0)) {
+            CustomRevert.revertWith(IMembershipBase.Membership__InvalidAddress.selector);
+        }
+
+        // get the balance
+        uint256 balance = address(this).balance;
+
+        // verify the balance is not 0
+        if (balance == 0) {
+            CustomRevert.revertWith(IMembershipBase.Membership__InsufficientPayment.selector);
+        }
+
+        address currency = MembershipStorage.layout().membershipCurrency;
+
+        CurrencyTransfer.transferCurrency(currency, address(this), account, balance);
+
+        emit IMembershipBase.MembershipWithdrawal(account, balance);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Hooks                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    ///@inheritdoc ITreasury
+    function onERC721Received(
+        address,
+        address,
+        uint256,
+        bytes memory
+    ) external pure returns (bytes4) {
+        return this.onERC721Received.selector;
+    }
+
+    ///@inheritdoc ITreasury
+    function onERC1155Received(
+        address,
+        address,
+        uint256,
+        uint256,
+        bytes memory
+    ) external pure returns (bytes4) {
+        return this.onERC1155Received.selector;
+    }
+
+    ///@inheritdoc ITreasury
+    function onERC1155BatchReceived(
+        address,
+        address,
+        uint256[] memory,
+        uint256[] memory,
+        bytes memory
+    ) external pure returns (bytes4) {
+        return this.onERC1155BatchReceived.selector;
+    }
+}

package/src/spaces/facets/xchain/SpaceEntitlementGated.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IMembership} from "../membership/IMembership.sol";
+
+// libraries
+
+// contracts
+import {EntitlementGated} from "../gated/EntitlementGated.sol";
+import {MembershipJoin} from "../membership/join/MembershipJoin.sol";
+
+/// @title SpaceEntitlementGated
+/// @notice Handles entitlement-gated access to spaces and membership token issuance
+/// @dev Inherits from ISpaceEntitlementGatedBase, MembershipJoin, and EntitlementGated
+contract SpaceEntitlementGated is MembershipJoin, EntitlementGated {
+    /// @notice Processes the result of an entitlement check
+    /// @dev This function is called when the result of an entitlement check is posted
+    /// @param transactionId The unique identifier for the transaction
+    /// @param result The result of the entitlement check (PASSED or FAILED)
+    function _onEntitlementCheckResultPosted(
+        bytes32 transactionId,
+        NodeVoteStatus result
+    ) internal override {
+        bytes storage data = _getCapturedData(transactionId);
+
+        if (data.length == 0) return;
+
+        (bytes4 transactionType, , address receiver, ) = abi.decode(
+            data,
+            (bytes4, address, address, bytes)
+        );
+
+        if (result == NodeVoteStatus.PASSED) {
+            PricingDetails memory joinDetails = _getPricingDetails();
+
+            if (joinDetails.shouldCharge) {
+                uint256 payment = _getCapturedValue(transactionId);
+
+                if (payment < joinDetails.amountDue) {
+                    _rejectMembership(transactionId, receiver);
+                    return;
+                }
+
+                if (transactionType == JOIN_SPACE_SELECTOR) {
+                    _chargeForJoinSpace(transactionId, joinDetails);
+                } else if (transactionType == IMembership.joinSpaceWithReferral.selector) {
+                    _chargeForJoinSpaceWithReferral(transactionId, joinDetails);
+                } else {
+                    _rejectMembership(transactionId, receiver);
+                    return;
+                }
+            }
+
+            _refundBalance(transactionId, receiver);
+            _issueToken(receiver);
+            return;
+        }
+
+        _rejectMembership(transactionId, receiver);
+    }
+}

package/src/tokens/Member.sol

@@ -0,0 +1,246 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+//interfaces
+
+//libraries
+import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
+
+//contracts
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+// @notice TEST CONTRACT, DO NOT USE IN PRODUCTION
+contract Member is ERC721, Ownable {
+    /// @notice emitted when an NFT is minted
+    /// @param recipient the address that receives the NFT
+    event Minted(address indexed recipient, uint256 tokenId, uint256 timestamp);
+
+    /// @notice emitted when the mint state is changed
+    /// @param caller the address that called the function
+    /// @param prevState the previous mint state
+    /// @param newState the new mint state
+    /// @param timestamp the timestamp of the state change
+    event MintStateChanged(
+        address indexed caller,
+        MintState indexed prevState,
+        MintState indexed newState,
+        uint256 timestamp
+    );
+
+    /// @notice thrown when user tries to mint more than 1 token with same wallet
+    error AlreadyMinted();
+
+    /// @notice thrown when an incorrect amount of ETH is sent to mint
+    error MintPriceNotPaid();
+
+    /// @notice thrown when the max supply is reached
+    error MaxSupplyReached();
+
+    /// @notice thrown when a token is not minted
+    error NonExistentTokenURI();
+
+    /// @notice thrown when the withdraw payment transaction fails
+    error WithdrawTransfer();
+
+    /// @notice thrown when the user is not allowed to perform the action
+    error NotAllowed();
+
+    /// @notice thrown when the mint state is invalid
+    error InvalidMintState();
+
+    /// @notice thrown when the address is invalid
+    error InvalidAddress();
+
+    /// @notice thrown when the proof is invalid
+    error InvalidProof();
+
+    /// @notice the current minting state
+    enum MintState {
+        Allowlist,
+        Waitlist,
+        Public
+    }
+
+    // =============================================================
+    //                           CONSTANTS
+    // =============================================================
+
+    /// @notice the total supply of the collection
+    uint256 public constant TOTAL_SUPPLY = 2500;
+
+    /// @notice the mint price for an individual nft
+    uint256 public constant MINT_PRICE = 0.08 ether;
+
+    // =============================================================
+    //                           STORAGE
+    // =============================================================
+
+    /// @notice the base uri
+    string public baseURI;
+
+    /// @notice mapping to track if a wallet has already minted
+    mapping(address => bool) public _hasMinted;
+
+    /// @notice the root of the merkle tree for the allowlist
+    bytes32 internal immutable _merkleRoot;
+
+    /// @notice the current minting state
+    MintState internal _mintState;
+
+    // @notice the counter token id for the next mint
+    uint256 public currentTokenId;
+
+    // =============================================================
+    //                          CONSTRUCTOR
+    // =============================================================
+
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        string memory baseURI_,
+        bytes32 merkleRoot_
+    ) ERC721(name_, symbol_) Ownable(msg.sender) {
+        baseURI = baseURI_;
+        _merkleRoot = merkleRoot_;
+        _mintState = MintState.Allowlist;
+    }
+
+    // =============================================================
+    //                        MINT OPERATIONS
+    // =============================================================
+    function privateMint(
+        address recipient,
+        uint256 allowance,
+        bytes32[] calldata proof
+    ) external payable returns (uint256) {
+        _validateInvalidAddress(recipient);
+        _validateMintPrice();
+        _validateMaxSupply();
+        _validateMinted(recipient);
+        _validateAllowlist(allowance);
+
+        bytes32 payload = keccak256(abi.encodePacked(recipient, allowance));
+
+        if (!MerkleProof.verify(proof, _merkleRoot, payload)) {
+            revert InvalidProof();
+        }
+
+        return _mintTo(recipient);
+    }
+
+    function publicMint(address recipient) external payable returns (uint256) {
+        _validateInvalidAddress(recipient);
+        _validateMintPrice();
+        _validateMaxSupply();
+        _validateMinted(recipient);
+        _validateState(MintState.Public);
+        return _mintTo(recipient);
+    }
+
+    // =============================================================
+    //                        BASE URI OPERATIONS
+    // =============================================================
+
+    function setBaseURI(string memory baseURI_) external onlyOwner {
+        baseURI = baseURI_;
+    }
+
+    function _baseURI() internal view override returns (string memory) {
+        return baseURI;
+    }
+
+    /// @notice Get the tokenURI for the given tokenId
+    /// @param tokenId the id of the token to get the tokenURI for
+    /// @return the tokenURI for the given tokenId
+    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
+        if (ownerOf(tokenId) == address(0)) {
+            revert NonExistentTokenURI();
+        }
+        return
+            bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, "councilmetadata")) : "";
+    }
+
+    // =============================================================
+    //                       MINT STATE OPERATIONS
+    // =============================================================
+
+    function startWaitlistMint() external onlyOwner {
+        _validateState(MintState.Allowlist);
+        _setState(MintState.Waitlist);
+    }
+
+    function startPublicMint() external onlyOwner {
+        _validateState(MintState.Waitlist);
+        _setState(MintState.Public);
+    }
+
+    // =============================================================
+    //                       ADMIN OPERATIONS
+    // =============================================================
+
+    /// @notice withdraw the balance from the contract
+    /// @param payee the address that will receive the withdrawn ether
+    function withdrawPayments(address payable payee) external onlyOwner {
+        uint256 balance = address(this).balance;
+        (bool transferTx, ) = payee.call{value: balance}("");
+        if (!transferTx) {
+            revert WithdrawTransfer();
+        }
+    }
+
+    // =============================================================
+    //                       INTERNAL OPERATIONS
+    // =============================================================
+    function _mintTo(address recipient) internal returns (uint256) {
+        _hasMinted[recipient] = true;
+        uint256 tokenId = currentTokenId;
+        currentTokenId++;
+        _safeMint(recipient, tokenId);
+        emit Minted(recipient, tokenId, block.timestamp);
+        return tokenId;
+    }
+
+    function _setState(MintState _state) internal {
+        MintState prevState = _mintState;
+        _mintState = _state;
+        emit MintStateChanged(msg.sender, prevState, _state, block.timestamp);
+    }
+
+    function _validateInvalidAddress(address recipient) internal pure {
+        if (recipient == address(0)) {
+            revert InvalidAddress();
+        }
+    }
+
+    function _validateMaxSupply() internal view {
+        if (currentTokenId >= TOTAL_SUPPLY) {
+            revert MaxSupplyReached();
+        }
+    }
+
+    function _validateState(MintState _state) internal view {
+        if (_mintState != _state) {
+            revert InvalidMintState();
+        }
+    }
+
+    function _validateAllowlist(uint256 allowance) internal view {
+        if (_mintState == MintState.Allowlist && allowance != 1) {
+            revert NotAllowed();
+        }
+    }
+
+    function _validateMinted(address recipient) internal view {
+        if (_hasMinted[recipient]) {
+            revert AlreadyMinted();
+        }
+    }
+
+    function _validateMintPrice() internal view {
+        if (msg.value != MINT_PRICE) {
+            revert MintPriceNotPaid();
+        }
+    }
+}

package/src/tokens/lock/ILock.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface ILockBase {
+    error LockNotAuthorized();
+
+    /// @notice Emitted when the lock is updated.
+    /// @param account The account that was updated.
+    /// @param enabled Whether the lock is enabled.
+    /// @param expiration The expiration of the lock.
+    event LockUpdated(address indexed account, bool indexed enabled, uint256 expiration);
+}
+
+interface ILock is ILockBase {
+    /// @notice Enables the lock for the given account.
+    /// @param account The account to enable the lock for.
+    function enableLock(address account) external;
+
+    /// @notice Disables the lock and starts the cooldown for the given account.
+    /// @param account The account to disable the lock for.
+    function disableLock(address account) external;
+
+    /// @notice Returns whether the lock is active for the given account.
+    /// @param account The account to check the lock for.
+    /// @return true if the lock is active
+    function isLockActive(address account) external view returns (bool);
+
+    /// @notice Returns the expiration of the lock for the given account.
+    /// @param account The account to check the lock expiration for.
+    /// @return The expiration timestamp.
+    function lockExpiration(address account) external view returns (uint256);
+
+    /// @notice Sets the default cooldown for the lock.
+    /// @param cooldown The cooldown in seconds.
+    function setLockCooldown(uint256 cooldown) external;
+}

package/src/tokens/lock/LockBase.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ILockBase} from "./ILock.sol";
+
+// libraries
+
+import {LockStorage} from "./LockStorage.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+
+abstract contract LockBase is ILockBase {
+    function __LockBase_init(uint256 cooldown) internal {
+        _setDefaultCooldown(cooldown);
+    }
+
+    modifier onlyAllowed() {
+        if (!_canLock()) CustomRevert.revertWith(LockNotAuthorized.selector);
+        _;
+    }
+
+    /// @dev Sets the default cooldown for the lock.
+    function _setDefaultCooldown(uint256 cooldown) internal {
+        LockStorage.layout().defaultCooldown = cooldown;
+    }
+
+    /// @dev Enables the lock for the given account.
+    function _enableLock(address account) internal {
+        LockStorage.Layout storage ds = LockStorage.layout();
+
+        ds.enabledByAddress[account] = true;
+        ds.expirationByAddress[account] = 0;
+
+        emit LockUpdated(account, true, 0);
+    }
+
+    /// @dev Disables the lock and starts the cooldown for the given account.
+    function _disableLock(address account) internal {
+        LockStorage.Layout storage ds = LockStorage.layout();
+
+        uint256 expiration = block.timestamp + ds.defaultCooldown;
+        ds.enabledByAddress[account] = false;
+        ds.expirationByAddress[account] = expiration;
+
+        emit LockUpdated(account, false, expiration);
+    }
+
+    /// @dev Returns the lock expiration for the given account.
+    function _lockExpiration(address account) internal view returns (uint256) {
+        return LockStorage.layout().expirationByAddress[account];
+    }
+
+    /// @dev Returns whether the lock is active for the given account.
+    function _isLockActive(address account) internal view returns (bool) {
+        LockStorage.Layout storage ds = LockStorage.layout();
+
+        if (ds.enabledByAddress[account]) return true;
+
+        return block.timestamp < ds.expirationByAddress[account];
+    }
+
+    /// @dev Returns whether the caller is authorized to lock.
+    function _canLock() internal view virtual returns (bool);
+}

package/src/tokens/lock/LockFacet.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ILock} from "./ILock.sol";
+
+// libraries
+
+// contracts
+
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {LockBase} from "src/tokens/lock/LockBase.sol";
+
+abstract contract LockFacet is ILock, LockBase, Facet {
+    function __LockFacet_init(uint256 cooldown) external onlyInitializing {
+        __LockBase_init(cooldown);
+        _addInterface(type(ILock).interfaceId);
+    }
+
+    /// @inheritdoc ILock
+    function isLockActive(address account) external view virtual returns (bool) {
+        return _isLockActive(account);
+    }
+
+    /// @inheritdoc ILock
+    function lockExpiration(address account) external view virtual returns (uint256) {
+        return _lockExpiration(account);
+    }
+
+    /// @inheritdoc ILock
+    function enableLock(address account) external virtual onlyAllowed {
+        _enableLock(account);
+    }
+
+    /// @inheritdoc ILock
+    function disableLock(address account) external virtual onlyAllowed {
+        _disableLock(account);
+    }
+
+    /// @inheritdoc ILock
+    function setLockCooldown(uint256 cooldown) external virtual onlyAllowed {
+        _setDefaultCooldown(cooldown);
+    }
+}

package/src/tokens/lock/LockStorage.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library LockStorage {
+    // keccak256("river.tokens.lock.storage")
+    bytes32 internal constant STORAGE_SLOT =
+        0xfd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c1;
+
+    struct Layout {
+        uint256 defaultCooldown;
+        mapping(address => bool) enabledByAddress;
+        mapping(address => uint256) expirationByAddress;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/tokens/mainnet/claimer/AuthorizedClaimerStorage.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library AuthorizedClaimerStorage {
+    // keccak256(abi.encode(uint256(keccak256("facets.authorized.claimer.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x5c7ae9c5b9b0882e9774077e2c97d13a2ab9f337fdc777b0f495e367ced70e00;
+
+    struct Layout {
+        mapping(address => address) authorizedClaimers;
+    }
+
+    function layout() internal pure returns (Layout storage s) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            s.slot := slot
+        }
+    }
+}

package/src/tokens/mainnet/claimer/AuthorizedClaimers.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IAuthorizedClaimers} from "./IAuthorizedClaimers.sol";
+
+// libraries
+import {AuthorizedClaimerStorage} from "./AuthorizedClaimerStorage.sol";
+import {ECDSA} from "solady/utils/ECDSA.sol";
+
+// contracts
+import {EIP712Facet} from "@towns-protocol/diamond/src/utils/cryptography/EIP712Facet.sol";
+
+contract AuthorizedClaimers is IAuthorizedClaimers, EIP712Facet {
+    // keccak256("Authorize(address owner,address claimer,uint256 nonce,uint256 expiry)")
+    bytes32 private constant _AUTHORIZE_TYPEHASH =
+        0x496b440527e20b246a460857dca887b9c1f290387cfc6ac9aa91bb6554be05ac;
+
+    function authorizeClaimerBySig(
+        address owner,
+        address claimer,
+        uint256 nonce,
+        uint256 expiry,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external {
+        if (expiry != 0 && block.timestamp >= expiry) {
+            revert AuthorizedClaimers_ExpiredSignature();
+        }
+
+        address signer = ECDSA.recover(
+            _hashTypedDataV4(
+                keccak256(abi.encode(_AUTHORIZE_TYPEHASH, owner, claimer, nonce, expiry))
+            ),
+            v,
+            r,
+            s
+        );
+
+        if (signer != owner) {
+            revert AuthorizedClaimers_InvalidSignature();
+        }
+
+        _useCheckedNonce(owner, nonce);
+        _authorizeClaimer(owner, claimer);
+    }
+
+    /// @inheritdoc IAuthorizedClaimers
+    function authorizeClaimer(address claimer) external {
+        _authorizeClaimer(msg.sender, claimer);
+    }
+
+    /// @inheritdoc IAuthorizedClaimers
+    function removeAuthorizedClaimer() external {
+        _authorizeClaimer(msg.sender, address(0));
+    }
+
+    /// @inheritdoc IAuthorizedClaimers
+    function getAuthorizedClaimer(address authorizer) external view returns (address) {
+        return AuthorizedClaimerStorage.layout().authorizedClaimers[authorizer];
+    }
+
+    // =============================================================
+    //                          Internal
+    // =============================================================
+    function _authorizeClaimer(address signer, address claimer) internal {
+        AuthorizedClaimerStorage.Layout storage ds = AuthorizedClaimerStorage.layout();
+
+        if (claimer == address(0)) {
+            delete ds.authorizedClaimers[signer];
+            emit AuthorizedClaimerRemoved(signer);
+        } else {
+            address currentClaimer = ds.authorizedClaimers[signer];
+            if (currentClaimer == claimer) {
+                revert AuthorizedClaimers_ClaimerAlreadyAuthorized();
+            }
+
+            ds.authorizedClaimers[signer] = claimer;
+
+            emit AuthorizedClaimerChanged(signer, claimer);
+        }
+    }
+}