@towns-protocol/contracts 0.0.302

package/src/diamond/facets/governance/votes/VotesBase.sol

@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
+
+// libraries
+
+import {Checkpoints} from "./Checkpoints.sol";
+import {VotesStorage} from "./VotesStorage.sol";
+import {ECDSA} from "solady/utils/ECDSA.sol";
+import {SafeCastLib} from "solady/utils/SafeCastLib.sol";
+
+// contracts
+import {Nonces} from "@towns-protocol/diamond/src/utils/Nonces.sol";
+import {EIP712Base} from "@towns-protocol/diamond/src/utils/cryptography/EIP712Base.sol";
+
+/**
+ * @dev This is a base abstract contract that tracks voting units, which are a measure of voting
+ * power that can be
+ * transferred, and provides a system of vote delegation, where an account can delegate its voting
+ * units to a sort of
+ * "representative" that will pool delegated voting units from different accounts and can then use
+ * it to vote in
+ * decisions. In fact, voting units _must_ be delegated in order to count as actual votes, and an
+ * account has to
+ * delegate those votes to itself if it wishes to participate in decisions and does not have a
+ * trusted representative.
+ *
+ * This contract is often combined with a token contract such that voting units correspond to token
+ * units. For an
+ * example, see {ERC721Votes}.
+ *
+ * The full history of delegate votes is tracked on-chain so that governance protocols can consider
+ * votes as distributed
+ * at a particular block number to protect against flash loans and double voting. The opt-in
+ * delegate system makes the
+ * cost of this history tracking optional.
+ *
+ * When using this module the derived contract must implement {_getVotingUnits} (for example, make
+ * it return
+ * {ERC721-balanceOf}), and can use {_transferVotingUnits} to track a change in the distribution of
+ * those units (in the
+ * previous example, it would be included in {ERC721-_beforeTokenTransfer}).
+ *
+ */
+abstract contract VotesBase is EIP712Base, Nonces {
+    using VotesStorage for VotesStorage.Layout;
+    using Checkpoints for Checkpoints.Trace224;
+
+    // =============================================================
+    //                         EIP 712
+    // =============================================================
+
+    bytes32 private constant _DELEGATION_TYPEHASH =
+        keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
+
+    // =============================================================
+    //                           ERC 5805
+    // =============================================================
+
+    /**
+     * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based
+     * checkpoints (and voting), in which case {CLOCK_MODE} should be overridden as well to match.
+     */
+    function _clock() internal view returns (uint48) {
+        return SafeCastLib.toUint48(block.number);
+    }
+
+    /**
+     * @dev Machine-readable description of the clock as specified in EIP-6372.
+     */
+    // solhint-disable-next-line func-name-mixedcase
+    function _clockMode() internal view returns (string memory) {
+        // Check that the clock was not modified
+        require(_clock() == block.number, "Votes: broken clock mode");
+        return "mode=blocknumber&from=default";
+    }
+
+    // =============================================================
+    //                           Votes
+    // =============================================================
+
+    /**
+     * @dev Returns the current amount of votes that `account` has.
+     */
+    function _getVotes(address account) internal view returns (uint256) {
+        return VotesStorage.layout()._delegateCheckpoints[account].latest();
+    }
+
+    /**
+     * @dev Returns the amount of votes that `account` had at a specific moment in the past. If the
+     * `clock()` is
+     * configured to use block numbers, this will return the value at the end of the corresponding
+     * block.
+     *
+     * Requirements:
+     *
+     * - `timepoint` must be in the past. If operating using block numbers, the block must be
+     * already
+     * mined.
+     */
+    function _getPastVotes(address account, uint256 timepoint) internal view returns (uint256) {
+        require(timepoint < _clock(), "Votes: future lookup");
+        return
+            VotesStorage.layout()._delegateCheckpoints[account].upperLookupRecent(
+                SafeCastLib.toUint32(timepoint)
+            );
+    }
+
+    /**
+     * @dev Returns the total supply of votes available at a specific moment in the past. If the
+     * `clock()` is
+     * configured to use block numbers, this will return the value at the end of the corresponding
+     * block.
+     *
+     * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all
+     * delegated votes.
+     * Votes that have not been delegated are still part of total supply, even though they would not
+     * participate in a
+     * vote.
+     *
+     * Requirements:
+     *
+     * - `timepoint` must be in the past. If operating using block numbers, the block must be
+     * already
+     * mined.
+     */
+    function _getPastTotalSupply(uint256 timepoint) internal view returns (uint256) {
+        require(timepoint < _clock(), "Votes: future lookup");
+        return
+            VotesStorage.layout()._totalCheckpoints.upperLookupRecent(
+                SafeCastLib.toUint32(timepoint)
+            );
+    }
+
+    /**
+     * @dev Returns the delegate that `account` has chosen.
+     */
+    function _delegates(address account) internal view returns (address) {
+        return VotesStorage.layout()._delegation[account];
+    }
+
+    /**
+     * @dev Delegates votes from signer to `delegatee`.
+     */
+    function _delegateBySig(
+        address delegatee,
+        uint256 nonce,
+        uint256 expiry,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) internal {
+        require(block.timestamp <= expiry, "Votes: signature expired");
+        address signer = ECDSA.recover(
+            _hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))),
+            v,
+            r,
+            s
+        );
+
+        _useCheckedNonce(signer, nonce);
+        _delegate(signer, delegatee);
+    }
+
+    /**
+     * @dev Must return the voting units held by an account.
+     */
+    function _getVotingUnits(address) internal view virtual returns (uint256);
+
+    // =============================================================
+    //                           Internal
+    // =============================================================
+
+    /**
+     * @dev Returns the current total supply of votes.
+     */
+    function _getTotalSupply() internal view virtual returns (uint256) {
+        return VotesStorage.layout()._totalCheckpoints.latest();
+    }
+
+    /**
+     * @dev Delegate all of `account`'s voting units to `delegatee`.
+     *
+     * Emits events {IVotes-DelegateChanged} and {IVotes-DelegateVotesChanged}.
+     */
+    function _delegate(address account, address delegatee) internal virtual {
+        _beforeDelegate(account, delegatee);
+
+        address oldDelegate = _delegates(account);
+        VotesStorage.layout()._delegation[account] = delegatee;
+
+        emit IVotes.DelegateChanged(account, oldDelegate, delegatee);
+        _moveDelegateVotes(oldDelegate, delegatee, _getVotingUnits(account));
+
+        _afterDelegate(account, delegatee);
+    }
+
+    /**
+     * @dev Transfers, mints, or burns voting units. To register a mint, `from` should be zero. To
+     * register a burn, `to`
+     * should be zero. Total supply of voting units will be adjusted with mints and burns.
+     */
+    function _transferVotingUnits(address from, address to, uint256 amount) internal virtual {
+        if (from == address(0)) {
+            _push(VotesStorage.layout()._totalCheckpoints, _add, SafeCastLib.toUint224(amount));
+        }
+        if (to == address(0)) {
+            _push(
+                VotesStorage.layout()._totalCheckpoints,
+                _subtract,
+                SafeCastLib.toUint224(amount)
+            );
+        }
+        _moveDelegateVotes(_delegates(from), _delegates(to), amount);
+    }
+
+    /**
+     * @dev Moves delegated votes from one delegate to another.
+     */
+    function _moveDelegateVotes(address from, address to, uint256 amount) private {
+        if (from != to && amount > 0) {
+            if (from != address(0)) {
+                (uint256 oldValue, uint256 newValue) = _push(
+                    VotesStorage.layout()._delegateCheckpoints[from],
+                    _subtract,
+                    SafeCastLib.toUint224(amount)
+                );
+                emit IVotes.DelegateVotesChanged(from, oldValue, newValue);
+            }
+            if (to != address(0)) {
+                (uint256 oldValue, uint256 newValue) = _push(
+                    VotesStorage.layout()._delegateCheckpoints[to],
+                    _add,
+                    SafeCastLib.toUint224(amount)
+                );
+                emit IVotes.DelegateVotesChanged(to, oldValue, newValue);
+            }
+        }
+    }
+
+    function _push(
+        Checkpoints.Trace224 storage store,
+        function(uint224, uint224) view returns (uint224) op,
+        uint224 delta
+    ) private returns (uint224, uint224) {
+        return store.push(SafeCastLib.toUint32(_clock()), op(store.latest(), delta));
+    }
+
+    function _add(uint224 a, uint224 b) private pure returns (uint224) {
+        return a + b;
+    }
+
+    function _subtract(uint224 a, uint224 b) private pure returns (uint224) {
+        return a - b;
+    }
+
+    /**
+     * @dev Hook that is called before any delegate operation. This includes {delegate} and
+     * {delegateBySig}.
+     * @param signer The account that signs the delegation.
+     * @param delegatee The account that will be delegated to.
+     */
+    function _beforeDelegate(address signer, address delegatee) internal virtual {}
+
+    /**
+     * @dev Hook that is called after any delegate operation. This includes {delegate} and
+     * {delegateBySig}.
+     * @param account The account that has been delegated.
+     * @param delegatee The account that has been delegated to.
+     */
+    function _afterDelegate(address account, address delegatee) internal virtual {}
+}

package/src/diamond/facets/governance/votes/VotesStorage.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Checkpoints} from "./Checkpoints.sol";
+
+library VotesStorage {
+    bytes32 internal constant STORAGE_SLOT = keccak256("diamond.facets.governance.votes.storage");
+
+    struct Layout {
+        mapping(address => address) _delegation;
+        mapping(address => Checkpoints.Trace224) _delegateCheckpoints;
+        Checkpoints.Trace224 _totalCheckpoints;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 position = STORAGE_SLOT;
+        assembly {
+            l.slot := position
+        }
+    }
+}

package/src/diamond/facets/governance/votes/enumerable/IVotesEnumerable.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface IVotesEnumerable {
+    /// @notice Get all delegators who have delegated their voting power
+    /// @return Array of delegator addresses
+    function getDelegators() external view returns (address[] memory);
+
+    /// @notice Get the total number of delegators
+    /// @return Total number of delegators
+    function getDelegatorsCount() external view returns (uint256);
+
+    /// @notice Get a paginated list of delegators
+    /// @param cursor The starting index for pagination
+    /// @param size The number of delegators to return
+    /// @return delegators Array of delegator addresses for the requested page
+    /// @return next The cursor for the next page, returns 0 if no more pages
+    function getPaginatedDelegators(
+        uint256 cursor,
+        uint256 size
+    ) external view returns (address[] memory delegators, uint256 next);
+
+    /// @notice Get all delegators who have delegated their voting power to a specific account
+    /// @param account The delegatee address to get delegators for
+    /// @return Array of delegator addresses who delegated to the specified account
+    function getDelegatorsByDelegatee(address account) external view returns (address[] memory);
+
+    /// @notice Get the timestamp when a delegator last delegated their voting power
+    /// @param account The delegator address to get delegation time for
+    /// @return Timestamp of the last delegation, returns 0 if never delegated
+    function getDelegationTimeForDelegator(address account) external view returns (uint256);
+}

package/src/diamond/facets/governance/votes/enumerable/VotesEnumerable.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IVotesEnumerable} from "src/diamond/facets/governance/votes/enumerable/IVotesEnumerable.sol";
+
+// libraries
+import {VotesEnumerableLib} from "src/diamond/facets/governance/votes/enumerable/VotesEnumerableLib.sol";
+
+// contracts
+abstract contract VotesEnumerable is IVotesEnumerable {
+    /// @inheritdoc IVotesEnumerable
+    function getDelegators() external view returns (address[] memory) {
+        return VotesEnumerableLib.getDelegators();
+    }
+
+    /// @inheritdoc IVotesEnumerable
+    function getDelegatorsCount() external view returns (uint256) {
+        return VotesEnumerableLib.getDelegatorsCount();
+    }
+
+    /// @inheritdoc IVotesEnumerable
+    function getPaginatedDelegators(
+        uint256 cursor,
+        uint256 size
+    ) external view returns (address[] memory delegators, uint256 next) {
+        return VotesEnumerableLib.getPaginatedDelegators(cursor, size);
+    }
+
+    /// @inheritdoc IVotesEnumerable
+    function getDelegatorsByDelegatee(address delegatee) external view returns (address[] memory) {
+        return VotesEnumerableLib.getDelegatorsByDelegatee(delegatee);
+    }
+
+    /// @inheritdoc IVotesEnumerable
+    function getDelegationTimeForDelegator(address delegator) external view returns (uint256) {
+        return VotesEnumerableLib.getDelegationTimeForDelegator(delegator);
+    }
+}

package/src/diamond/facets/governance/votes/enumerable/VotesEnumerableLib.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// libraries
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+import {FixedPointMathLib} from "solady/utils/FixedPointMathLib.sol";
+
+library VotesEnumerableLib {
+    using EnumerableSetLib for EnumerableSetLib.AddressSet;
+
+    struct Layout {
+        // Set of all delegators
+        EnumerableSetLib.AddressSet delegators;
+        // Mapping of delegatee to their delegators
+        mapping(address => EnumerableSetLib.AddressSet) delegatorsByDelegatee;
+        // Mapping of delegator to their delegation timestamp
+        mapping(address => uint256) delegationTimeForDelegator;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("diamond.facets.governance.votes.enumerable.storage"))
+    // -
+    // 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xed095a1d53cef9e2be0aab14d20856bfa3fbcc76a945321739a0da68a6078e00;
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+
+    function getDelegators() internal view returns (address[] memory) {
+        return layout().delegators.values();
+    }
+
+    function getDelegatorsByDelegatee(address account) internal view returns (address[] memory) {
+        return layout().delegatorsByDelegatee[account].values();
+    }
+
+    function getDelegationTimeForDelegator(address account) internal view returns (uint256) {
+        return layout().delegationTimeForDelegator[account];
+    }
+
+    function getDelegatorsCount() internal view returns (uint256) {
+        return layout().delegators.length();
+    }
+
+    function getPaginatedDelegators(
+        uint256 cursor,
+        uint256 size
+    ) internal view returns (address[] memory delegators, uint256 next) {
+        Layout storage ds = layout();
+        uint256 length = ds.delegators.length();
+
+        // Return empty array if cursor is out of bounds
+        if (cursor >= length) {
+            return (new address[](0), 0);
+        }
+
+        // Calculate actual page size (handle last page case)
+        uint256 pageSize = FixedPointMathLib.min(size, length - cursor);
+
+        // Initialize return array
+        delegators = new address[](pageSize);
+
+        // Populate return array
+        for (uint256 i = 0; i < pageSize; ++i) {
+            delegators[i] = ds.delegators.at(cursor + i);
+        }
+
+        // Set next cursor
+        next = (cursor + pageSize) % length;
+
+        return (delegators, next);
+    }
+
+    function setDelegators(
+        address account,
+        address newDelegatee,
+        address currentDelegatee
+    ) internal {
+        Layout storage ds = layout();
+
+        // If current delegatee is address(0), add account to delegators
+        if (currentDelegatee == address(0)) {
+            ds.delegators.add(account);
+        } else {
+            // Remove account from current delegatee's delegators
+            ds.delegatorsByDelegatee[currentDelegatee].remove(account);
+        }
+
+        if (newDelegatee == address(0)) {
+            // Remove account from delegators and reset delegation time
+            ds.delegators.remove(account);
+            ds.delegationTimeForDelegator[account] = 0;
+        } else {
+            // Add account to new delegatee's delegators and update timestamp
+            ds.delegatorsByDelegatee[newDelegatee].add(account);
+            ds.delegationTimeForDelegator[account] = block.timestamp;
+        }
+    }
+}

package/src/diamond/facets/metadata/IMetadata.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface IMetadataBase {
+    /// @dev Emitted when the contract URI is changed
+    event ContractURIChanged(string uri);
+}
+
+interface IMetadata is IMetadataBase {
+    /// @dev Returns the contract type
+    function contractType() external view returns (bytes32);
+
+    /// @dev Returns the contract version
+    function contractVersion() external view returns (uint32);
+
+    /// @dev Returns the metadata URI of the contract
+    function contractURI() external view returns (string memory);
+
+    /// @dev Sets the metadata URI of the contract
+    function setContractURI(string calldata uri) external;
+}

package/src/diamond/facets/metadata/MetadataFacet.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IMetadata} from "./IMetadata.sol";
+
+// libraries
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+
+contract MetadataFacet is IMetadata, OwnableBase, Facet {
+    function __MetadataFacet_init(
+        bytes32 _contractType,
+        string memory _contractURI
+    ) external onlyInitializing {
+        __MetadataFacet_init_unchained(_contractType, _contractURI);
+    }
+
+    function __MetadataFacet_init_unchained(
+        bytes32 _contractType,
+        string memory _contractURI
+    ) internal {
+        _addInterface(type(IMetadata).interfaceId);
+
+        MetadataStorage.Layout storage ds = MetadataStorage.layout();
+        ds.contractType = _contractType;
+        ds.contractURI = _contractURI;
+    }
+
+    function contractType() external view returns (bytes32) {
+        return MetadataStorage.layout().contractType;
+    }
+
+    function contractVersion() external view virtual returns (uint32) {
+        return _getInitializedVersion();
+    }
+
+    function contractURI() external view returns (string memory) {
+        return MetadataStorage.layout().contractURI;
+    }
+
+    function setContractURI(string calldata uri) external onlyOwner {
+        MetadataStorage.layout().contractURI = uri;
+        emit ContractURIChanged(uri);
+    }
+}
+
+// =============================================================
+//                           Storage
+// =============================================================
+
+library MetadataStorage {
+    struct Layout {
+        bytes32 contractType;
+        string contractURI;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("diamond.facets.metadata.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xf5e7800d151c04390bdf7c63536bd6072359c9f89940782fbad33a288db56300;
+
+    function layout() internal pure returns (Layout storage ds) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            ds.slot := slot
+        }
+    }
+}

package/src/diamond/facets/token/ERC5643/ERC5643.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC5643} from "./IERC5643.sol";
+
+// libraries
+
+// contracts
+
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {ERC5643Base} from "src/diamond/facets/token/ERC5643/ERC5643Base.sol";
+import {ERC721ABase} from "src/diamond/facets/token/ERC721A/ERC721ABase.sol";
+
+contract ERC5643 is IERC5643, ERC5643Base, ERC721ABase, Facet {
+    function __ERC5643_init() external onlyInitializing {
+        _addInterface(type(IERC5643).interfaceId);
+    }
+
+    function renewSubscription(uint256 tokenId, uint64 duration) external payable virtual {
+        if (duration == 0) revert ERC5643__DurationZero();
+        if (!_isApprovedOrOwner(tokenId)) revert ERC5643__NotApprovedOrOwner();
+        _renewSubscription(tokenId, duration);
+    }
+
+    function cancelSubscription(uint256 tokenId) external payable virtual {
+        if (!_isApprovedOrOwner(tokenId)) revert ERC5643__NotApprovedOrOwner();
+        _cancelSubscription(tokenId);
+    }
+
+    function expiresAt(uint256 tokenId) external view returns (uint64) {
+        return _expiresAt(tokenId);
+    }
+
+    function isRenewable(uint256 tokenId) external view returns (bool) {
+        return _isRenewable(tokenId);
+    }
+
+    // =============================================================
+    //                           Internal
+    // =============================================================
+
+    function _isApprovedOrOwner(uint256 tokenId) internal view returns (bool) {
+        address owner = _ownerOf(tokenId);
+
+        return
+            (_msgSenderERC721A() == owner) ||
+            _isApprovedForAll(owner, _msgSenderERC721A()) ||
+            _getApproved(tokenId) == _msgSenderERC721A();
+    }
+}

package/src/diamond/facets/token/ERC5643/ERC5643Base.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC5643Base} from "./IERC5643.sol";
+
+// libraries
+import {ERC5643Storage} from "./ERC5643Storage.sol";
+
+// contracts
+
+abstract contract ERC5643Base is IERC5643Base {
+    function _renewSubscription(uint256 tokenId, uint64 duration) internal {
+        ERC5643Storage.Layout storage ds = ERC5643Storage.layout();
+        uint64 currentExpiration = ds.expiration[tokenId];
+
+        // Check renewability for existing subscriptions
+        if (currentExpiration != 0 && !_isRenewable(tokenId)) {
+            revert ERC5643__SubscriptionNotRenewable(tokenId);
+        }
+
+        // Calculate new expiration
+        uint64 newExpiration;
+        if (currentExpiration > block.timestamp) {
+            // Active subscription: extend from current expiration
+            newExpiration = currentExpiration + duration;
+        } else {
+            // New or expired subscription: start from current time
+            newExpiration = uint64(block.timestamp) + duration;
+        }
+
+        ds.expiration[tokenId] = newExpiration;
+        emit SubscriptionUpdate(tokenId, newExpiration);
+    }
+
+    function _cancelSubscription(uint256 tokenId) internal {
+        delete ERC5643Storage.layout().expiration[tokenId];
+        emit SubscriptionUpdate(tokenId, 0);
+    }
+
+    function _expiresAt(uint256 tokenId) internal view returns (uint64) {
+        return ERC5643Storage.layout().expiration[tokenId];
+    }
+
+    function _isRenewable(uint256) internal view virtual returns (bool) {
+        return true;
+    }
+}