@towns-protocol/contracts 0.0.302

package/src/diamond/facets/token/ERC721A/ERC721ANonTransferable.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {ERC721A} from "./ERC721A.sol";
+
+contract ERC721ANonTransferable is ERC721A {
+    function _beforeTokenTransfers(
+        address from,
+        address to,
+        uint256 startTokenId,
+        uint256 quantity
+    ) internal virtual override {
+        if (from != address(0)) revert TransferFromIncorrectOwner();
+        super._beforeTokenTransfers(from, to, startTokenId, quantity);
+    }
+}

package/src/diamond/facets/token/ERC721A/ERC721AStorage.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IERC721ABase} from "./IERC721A.sol";
+
+library ERC721AStorage {
+    // keccak256(abi.encode(uint256(keccak256("diamond.facets.token.ERC721A.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x6569bde4a160c636ea8b8d11acb83a60d7fec0b8f2e09389306cba0e1340df00;
+
+    // Mask of an entry in packed address data.
+    uint256 internal constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
+
+    // The bit mask of the `burned` bit in packed ownership.
+    uint256 internal constant _BITMASK_BURNED = 1 << 224;
+
+    struct Layout {
+        // =============================================================
+        //                            STORAGE
+        // =============================================================
+
+        // The next token ID to be minted.
+        uint256 _currentIndex;
+        // The number of tokens burned.
+        uint256 _burnCounter;
+        // Token name
+        string _name;
+        // Token symbol
+        string _symbol;
+        // Mapping from token ID to ownership details
+        // An empty struct value does not necessarily mean the token is unowned.
+        // See {_packedOwnershipOf} implementation for details.
+        //
+        // Bits Layout:
+        // - [0..159]   `addr`
+        // - [160..223] `startTimestamp`
+        // - [224]      `burned`
+        // - [225]      `nextInitialized`
+        // - [232..255] `extraData`
+        mapping(uint256 => uint256) _packedOwnerships;
+        // Mapping owner address to address data.
+        //
+        // Bits Layout:
+        // - [0..63]    `balance`
+        // - [64..127]  `numberMinted`
+        // - [128..191] `numberBurned`
+        // - [192..255] `aux`
+        mapping(address => uint256) _packedAddressData;
+        // Mapping from token ID to approved address.
+        mapping(uint256 => IERC721ABase.TokenApprovalRef) _tokenApprovals;
+        // Mapping from owner to operator approvals
+        mapping(address => mapping(address => bool)) _operatorApprovals;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            l.slot := slot
+        }
+    }
+
+    function balanceOf(address owner) internal view returns (uint256) {
+        if (owner == address(0)) revert IERC721ABase.BalanceQueryForZeroAddress();
+        return layout()._packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
+    }
+
+    function ownerAt(uint256 startTokenId, uint256 tokenId) internal view returns (address) {
+        return address(uint160(packedOwnershipOf(startTokenId, tokenId)));
+    }
+
+    /**
+     * Returns the packed ownership data of `tokenId`.
+     */
+    function packedOwnershipOf(
+        uint256 startTokenId,
+        uint256 tokenId
+    ) internal view returns (uint256 packed) {
+        if (startTokenId <= tokenId) {
+            Layout storage $ = layout();
+
+            packed = $._packedOwnerships[tokenId];
+            // If not burned.
+            if (packed & _BITMASK_BURNED == 0) {
+                // If the data at the starting slot does not exist, start the scan.
+                if (packed == 0) {
+                    if (tokenId >= $._currentIndex) {
+                        revert IERC721ABase.OwnerQueryForNonexistentToken();
+                    }
+                    // Invariant:
+                    // There will always be an initialized ownership slot
+                    // (i.e. `ownership.addr != address(0) && ownership.burned == false`)
+                    // before an unintialized ownership slot
+                    // (i.e. `ownership.addr == address(0) && ownership.burned == false`)
+                    // Hence, `tokenId` will not underflow.
+                    //
+                    // We can directly compare the packed value.
+                    // If the address is zero, packed will be zero.
+                    for (;;) {
+                        unchecked {
+                            packed = $._packedOwnerships[--tokenId];
+                        }
+                        if (packed == 0) continue;
+                        return packed;
+                    }
+                }
+                // Otherwise, the data exists and is not burned. We can skip the scan.
+                // This is possible because we have already achieved the target condition.
+                // This saves 2143 gas on transfers of initialized tokens.
+                return packed;
+            }
+        }
+        revert IERC721ABase.OwnerQueryForNonexistentToken();
+    }
+}

package/src/diamond/facets/token/ERC721A/IERC721A.sol

@@ -0,0 +1,283 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/**
+ * @dev Interface of ERC721 token receiver.
+ */
+interface ERC721A__IERC721ReceiverUpgradeable {
+    function onERC721Received(
+        address operator,
+        address from,
+        uint256 tokenId,
+        bytes calldata data
+    ) external returns (bytes4);
+}
+
+interface IERC721ABase {
+    // =============================================================
+    //                            STRUCTS
+    // =============================================================
+    struct TokenApprovalRef {
+        address value;
+    }
+
+    struct TokenOwnership {
+        // The address of the owner.
+        address addr;
+        // Stores the start time of ownership with minimal overhead for tokenomics.
+        uint64 startTimestamp;
+        // Whether the token has been burned.
+        bool burned;
+        // Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
+        uint24 extraData;
+    }
+
+    // =============================================================
+    //                           ERRORS
+    // =============================================================
+
+    /**
+     * The caller must own the token or be an approved operator.
+     */
+    error ApprovalCallerNotOwnerNorApproved();
+
+    /**
+     * The token does not exist.
+     */
+    error ApprovalQueryForNonexistentToken();
+
+    /**
+     * Cannot query the balance for the zero address.
+     */
+    error BalanceQueryForZeroAddress();
+
+    /**
+     * Cannot mint to the zero address.
+     */
+    error MintToZeroAddress();
+
+    /**
+     * The quantity of tokens minted must be more than zero.
+     */
+    error MintZeroQuantity();
+
+    /**
+     * The token does not exist.
+     */
+    error OwnerQueryForNonexistentToken();
+
+    /**
+     * The caller must own the token or be an approved operator.
+     */
+    error TransferCallerNotOwnerNorApproved();
+
+    /**
+     * The token must be owned by `from`.
+     */
+    error TransferFromIncorrectOwner();
+
+    /**
+     * Cannot safely transfer to a contract that does not implement the
+     * ERC721Receiver interface.
+     */
+    error TransferToNonERC721ReceiverImplementer();
+
+    /**
+     * Cannot transfer to the zero address.
+     */
+    error TransferToZeroAddress();
+
+    /**
+     * The token does not exist.
+     */
+    error URIQueryForNonexistentToken();
+
+    /**
+     * The `quantity` minted with ERC2309 exceeds the safety limit.
+     */
+    error MintERC2309QuantityExceedsLimit();
+
+    /**
+     * The `extraData` cannot be set on an unintialized ownership slot.
+     */
+    error OwnershipNotInitializedForExtraData();
+
+    // =============================================================
+    //                            IERC721
+    // =============================================================
+
+    /**
+     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
+     */
+    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
+
+    /**
+     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
+     */
+    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
+
+    /**
+     * @dev Emitted when `owner` enables or disables
+     * (`approved`) `operator` to manage all of its assets.
+     */
+    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
+
+    // =============================================================
+    //                           IERC2309
+    // =============================================================
+
+    /**
+     * @dev Emitted when tokens in `fromTokenId` to `toTokenId`
+     * (inclusive) is transferred from `from` to `to`, as defined in the
+     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.
+     *
+     * See {_mintERC2309} for more details.
+     */
+    event ConsecutiveTransfer(
+        uint256 indexed fromTokenId,
+        uint256 toTokenId,
+        address indexed from,
+        address indexed to
+    );
+}
+
+/**
+ * @dev Interface of ERC721A.
+ */
+interface IERC721A is IERC721ABase {
+    // =============================================================
+    //                         TOKEN COUNTERS
+    // =============================================================
+
+    /**
+     * @dev Returns the total number of tokens in existence.
+     * Burned tokens will reduce the count.
+     * To get the total number of tokens minted, please see {_totalMinted}.
+     */
+    function totalSupply() external view returns (uint256);
+
+    /**
+     * @dev Returns the number of tokens in `owner`'s account.
+     */
+    function balanceOf(address owner) external view returns (uint256 balance);
+
+    /**
+     * @dev Returns the owner of the `tokenId` token.
+     *
+     * Requirements:
+     *
+     * - `tokenId` must exist.
+     */
+    function ownerOf(uint256 tokenId) external view returns (address owner);
+
+    /**
+     * @dev Safely transfers `tokenId` token from `from` to `to`,
+     * checking first that contract recipients are aware of the ERC721 protocol
+     * to prevent tokens from being forever locked.
+     *
+     * Requirements:
+     *
+     * - `from` cannot be the zero address.
+     * - `to` cannot be the zero address.
+     * - `tokenId` token must exist and be owned by `from`.
+     * - If the caller is not `from`, it must be have been allowed to move
+     * this token by either {approve} or {setApprovalForAll}.
+     * - If `to` refers to a smart contract, it must implement
+     * {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
+     *
+     * Emits a {Transfer} event.
+     */
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 tokenId,
+        bytes calldata data
+    ) external payable;
+
+    /**
+     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
+     */
+    function safeTransferFrom(address from, address to, uint256 tokenId) external payable;
+
+    /**
+     * @dev Transfers `tokenId` from `from` to `to`.
+     *
+     * WARNING: Usage of this method is discouraged, use {safeTransferFrom}
+     * whenever possible.
+     *
+     * Requirements:
+     *
+     * - `from` cannot be the zero address.
+     * - `to` cannot be the zero address.
+     * - `tokenId` token must be owned by `from`.
+     * - If the caller is not `from`, it must be approved to move this token
+     * by either {approve} or {setApprovalForAll}.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transferFrom(address from, address to, uint256 tokenId) external payable;
+
+    /**
+     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
+     * The approval is cleared when the token is transferred.
+     *
+     * Only a single account can be approved at a time, so approving the
+     * zero address clears previous approvals.
+     *
+     * Requirements:
+     *
+     * - The caller must own the token or be an approved operator.
+     * - `tokenId` must exist.
+     *
+     * Emits an {Approval} event.
+     */
+    function approve(address to, uint256 tokenId) external payable;
+
+    /**
+     * @dev Approve or remove `operator` as an operator for the caller.
+     * Operators can call {transferFrom} or {safeTransferFrom}
+     * for any token owned by the caller.
+     *
+     * Requirements:
+     *
+     * - The `operator` cannot be the caller.
+     *
+     * Emits an {ApprovalForAll} event.
+     */
+    function setApprovalForAll(address operator, bool _approved) external;
+
+    /**
+     * @dev Returns the account approved for `tokenId` token.
+     *
+     * Requirements:
+     *
+     * - `tokenId` must exist.
+     */
+    function getApproved(uint256 tokenId) external view returns (address operator);
+
+    /**
+     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
+     *
+     * See {setApprovalForAll}.
+     */
+    function isApprovedForAll(address owner, address operator) external view returns (bool);
+
+    // =============================================================
+    //                        IERC721Metadata
+    // =============================================================
+
+    /**
+     * @dev Returns the token collection name.
+     */
+    function name() external view returns (string memory);
+
+    /**
+     * @dev Returns the token collection symbol.
+     */
+    function symbol() external view returns (string memory);
+
+    /**
+     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
+     */
+    function tokenURI(uint256 tokenId) external view returns (string memory);
+}

package/src/diamond/facets/token/ERC721A/extensions/ERC721AQueryable.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC721AQueryable} from "./IERC721AQueryable.sol";
+
+// libraries
+
+// contracts
+import {ERC721ABase} from "../ERC721ABase.sol";
+
+contract ERC721AQueryable is ERC721ABase, IERC721AQueryable {
+    /// @inheritdoc IERC721AQueryable
+    function explicitOwnershipOf(
+        uint256 tokenId
+    ) public view override returns (TokenOwnership memory) {
+        TokenOwnership memory ownership;
+
+        if (tokenId < _startTokenId() || tokenId >= _nextTokenId()) {
+            return ownership;
+        }
+
+        ownership = _ownershipAt(tokenId);
+        if (ownership.burned) {
+            return ownership;
+        }
+
+        return _ownershipOf(tokenId);
+    }
+
+    /// @inheritdoc IERC721AQueryable
+    function explicitOwnershipsOf(
+        uint256[] calldata tokenIds
+    ) external view override returns (TokenOwnership[] memory) {
+        unchecked {
+            uint256 tokenIdsLen = tokenIds.length;
+            TokenOwnership[] memory ownerships = new TokenOwnership[](tokenIdsLen);
+            for (uint256 i; i < tokenIdsLen; ++i) {
+                ownerships[i] = explicitOwnershipOf(tokenIds[i]);
+            }
+            return ownerships;
+        }
+    }
+
+    /// @inheritdoc IERC721AQueryable
+    function tokensOfOwnerIn(
+        address owner,
+        uint256 start,
+        uint256 stop
+    ) external view virtual override returns (uint256[] memory) {
+        unchecked {
+            if (start >= stop) revert InvalidQueryRange();
+            uint256 tokenIdsIdx;
+            uint256 stopLimit = _nextTokenId();
+            // Set `start = max(start, _startTokenId())
+            if (start < _startTokenId()) {
+                start = _startTokenId();
+            }
+            // Set `stop = min(stop, _nextTokenId())
+            if (stop > stopLimit) {
+                stop = stopLimit;
+            }
+            uint256 tokenIdsMaxLen = _balanceOf(owner);
+            // Set `tokenIdsMaxLength = min(balanceOf(owner), stop - start)`,
+            // to cater for cases where `balanceOf(owner)` is too large.
+            if (start < stop) {
+                uint256 rangeLen = stop - start;
+                if (rangeLen < tokenIdsMaxLen) {
+                    tokenIdsMaxLen = rangeLen;
+                }
+            } else {
+                tokenIdsMaxLen = 0;
+            }
+
+            uint256[] memory tokenIds = new uint256[](tokenIdsMaxLen);
+            if (tokenIdsMaxLen == 0) {
+                return tokenIds;
+            }
+
+            // We need to call `explicitOwnershipOf(start)`,
+            // because the slot at `start` may not be initialized
+            TokenOwnership memory ownership = explicitOwnershipOf(start);
+            address currOwnershipAddr;
+            // If starting slot exists (i.e. not burned), initialize `currOwnershipAddr`
+            if (!ownership.burned) {
+                currOwnershipAddr = ownership.addr;
+            }
+
+            for (uint256 i = start; i != stop && tokenIdsIdx != tokenIdsMaxLen; ++i) {
+                ownership = _ownershipAt(i);
+                if (ownership.burned) {
+                    continue;
+                }
+                if (ownership.addr != address(0)) {
+                    currOwnershipAddr = ownership.addr;
+                }
+                if (currOwnershipAddr == owner) {
+                    tokenIds[tokenIdsIdx++] = i;
+                }
+            }
+            // Downsize array
+            assembly {
+                mstore(tokenIds, tokenIdsIdx)
+            }
+            return tokenIds;
+        }
+    }
+
+    /// @inheritdoc IERC721AQueryable
+    function tokensOfOwner(
+        address owner
+    ) external view virtual override returns (uint256[] memory) {
+        unchecked {
+            uint256 tokenIdsIdx;
+            address currOwnershipAddr;
+            uint256 tokenIdsLen = _balanceOf(owner);
+            uint256[] memory tokenIds = new uint256[](tokenIdsLen);
+            TokenOwnership memory ownership;
+            for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLen; ++i) {
+                ownership = _ownershipAt(i);
+                if (ownership.burned) {
+                    continue;
+                }
+                if (ownership.addr != address(0)) {
+                    currOwnershipAddr = ownership.addr;
+                }
+                if (currOwnershipAddr == owner) {
+                    tokenIds[tokenIdsIdx++] = i;
+                }
+            }
+            return tokenIds;
+        }
+    }
+}

package/src/diamond/facets/token/ERC721A/extensions/IERC721AQueryable.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC721ABase} from "../IERC721A.sol";
+
+// libraries
+
+// contracts
+
+/**
+ * @dev Interface of ERC721AQueryable.
+ */
+interface IERC721AQueryable is IERC721ABase {
+    /**
+     * Invalid query range (`start` >= `stop`).
+     */
+    error InvalidQueryRange();
+
+    /**
+     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
+     *
+     * If the `tokenId` is out of bounds:
+     *
+     * - `addr = address(0)`
+     * - `startTimestamp = 0`
+     * - `burned = false`
+     * - `extraData = 0`
+     *
+     * If the `tokenId` is burned:
+     *
+     * - `addr = <Address of owner before token was burned>`
+     * - `startTimestamp = <Timestamp when token was burned>`
+     * - `burned = true`
+     * - `extraData = <Extra data when token was burned>`
+     *
+     * Otherwise:
+     *
+     * - `addr = <Address of owner>`
+     * - `startTimestamp = <Timestamp of start of ownership>`
+     * - `burned = false`
+     * - `extraData = <Extra data at start of ownership>`
+     */
+    function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);
+
+    /**
+     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
+     * See {ERC721AQueryable-explicitOwnershipOf}
+     */
+    function explicitOwnershipsOf(
+        uint256[] memory tokenIds
+    ) external view returns (TokenOwnership[] memory);
+
+    /**
+     * @dev Returns an array of token IDs owned by `owner`,
+     * in the range [`start`, `stop`)
+     * (i.e. `start <= tokenId < stop`).
+     *
+     * This function allows for tokens to be queried if the collection
+     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
+     *
+     * Requirements:
+     *
+     * - `start < stop`
+     */
+    function tokensOfOwnerIn(
+        address owner,
+        uint256 start,
+        uint256 stop
+    ) external view returns (uint256[] memory);
+
+    /**
+     * @dev Returns an array of token IDs owned by `owner`.
+     *
+     * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
+     * It is meant to be called off-chain.
+     *
+     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
+     * multiple smaller scans if the collection is large enough to cause
+     * an out-of-gas error (10K collections should be fine).
+     */
+    function tokensOfOwner(address owner) external view returns (uint256[] memory);
+}

package/src/diamond/utils/Context.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+
+    function _msgData() internal view virtual returns (bytes calldata) {
+        this;
+        return msg.data;
+    }
+}

package/src/factory/SpaceFactoryInit.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
+
+// libraries
+import {ImplementationStorage} from "src/factory/facets/architect/ImplementationStorage.sol";
+
+// contracts
+
+contract SpaceFactoryInit {
+    function initialize(address proxyInitializer) external {
+        ImplementationStorage.Layout storage ds = ImplementationStorage.layout();
+        ds.proxyInitializer = ISpaceProxyInitializer(proxyInitializer);
+    }
+}