@towns-protocol/contracts 0.0.302

package/src/spaces/facets/membership/pricing/tiered/TieredLogPricingOracleV2.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IMembershipPricing} from "src/spaces/facets/membership/pricing/IMembershipPricing.sol";
+import {AggregatorV3Interface} from "src/utils/interfaces/AggregatorV3Interface.sol";
+
+// libraries
+import {Casting, UD60x18, log10} from "@prb/math/UD60x18.sol";
+
+// contracts
+import {IntrospectionFacet} from "@towns-protocol/diamond/src/facets/introspection/IntrospectionFacet.sol";
+
+/**
+ * @title TieredLogPricingOracle
+ * @notice Network: Base (Sepolia)
+ */
+contract TieredLogPricingOracleV2 is IMembershipPricing, IntrospectionFacet {
+    AggregatorV3Interface internal dataFeed;
+
+    uint256 internal constant SCALE = 1e18; // 1 ether
+    uint256 internal constant CENT_SCALE = 100;
+    uint256 internal constant LOG_BASE = 10 ** 16;
+    uint256 internal constant FEED_TIMEOUT = 24 hours;
+
+    // Cached values for optimization
+    uint256 private immutable exchangeRateDecimals;
+    uint256 private immutable exchangeRateScale;
+
+    // Error messages
+    error TieredLogPricingOracle__InvalidAnswer();
+    error TieredLogPricingOracle__InvalidRound();
+    error TieredLogPricingOracle__InvalidTimestamp();
+    error TieredLogPricingOracle__StaleData();
+
+    constructor(address priceFeed) {
+        __IntrospectionBase_init();
+        _addInterface(type(IMembershipPricing).interfaceId);
+        dataFeed = AggregatorV3Interface(priceFeed);
+        exchangeRateDecimals = 10 ** dataFeed.decimals();
+        exchangeRateScale = exchangeRateDecimals * CENT_SCALE;
+    }
+
+    function name() public pure override returns (string memory) {
+        return "TieredLogPricingOracleV2";
+    }
+
+    function description() public pure override returns (string memory) {
+        return "Free for the first 100 members, then logarithmically increasing price";
+    }
+
+    function setPrice(uint256) external pure {
+        revert("TieredLogPricingOracle: price is calculated");
+    }
+
+    function getPrice(uint256 freeAllocation, uint256 totalMinted) public view returns (uint256) {
+        uint256 stablePriceCents = _calculateStablePrice(freeAllocation, totalMinted);
+
+        return _getWeiFromCents(stablePriceCents);
+    }
+
+    // =============================================================
+    //                           Internal
+    // =============================================================
+
+    function getChainlinkDataFeedLatestAnswer() public view returns (uint256) {
+        // prettier-ignore
+        (
+            uint80 roundId,
+            int256 answer,
+            /*uint startedAt*/
+            ,
+            uint256 updatedAt,
+            /*uint80 answeredInRound*/
+        ) = dataFeed.latestRoundData();
+
+        if (answer <= 0) revert TieredLogPricingOracle__InvalidAnswer();
+        if (roundId == 0) revert TieredLogPricingOracle__InvalidRound();
+        if (updatedAt == 0) revert TieredLogPricingOracle__InvalidTimestamp();
+        if (updatedAt > block.timestamp) {
+            revert TieredLogPricingOracle__InvalidTimestamp();
+        }
+        if (block.timestamp - updatedAt > FEED_TIMEOUT) {
+            revert TieredLogPricingOracle__StaleData();
+        }
+
+        return uint256(answer);
+    }
+
+    /// @notice Converts a price in cents to wei
+    /// @param cents The price in cents to convert
+    /// @return The price in wei
+    function _getWeiFromCents(uint256 cents) internal view returns (uint256) {
+        uint256 exchangeRate = getChainlinkDataFeedLatestAnswer(); // chainlink oracle returns this
+        // value
+
+        // oracle or governance
+        // multiple before divide to avoid truncation which ends up in precision loss
+        uint256 ethToUsdExchangeRateCents = (exchangeRate * 100) / exchangeRateDecimals;
+        uint256 oneCentInWei = SCALE / ethToUsdExchangeRateCents;
+
+        return oneCentInWei * cents;
+    }
+
+    function _calculateStablePrice(
+        uint256 freeAllocation,
+        uint256 totalMinted
+    ) internal pure returns (uint256) {
+        // Free allocation handling
+        if (freeAllocation > 0 && totalMinted < freeAllocation) {
+            return 0;
+        }
+
+        // Define minted tiers
+        uint256 tier1 = 100;
+        uint256 tier2 = 1000;
+        uint256 tier3 = 10_000;
+
+        // Define base prices in cents
+        uint256 basePriceTier1 = 100; // $1.00
+        uint256 basePriceTier2 = 1000; // $10.00
+        uint256 basePriceTier3 = 10_000; // $100.00
+
+        if (totalMinted > tier3) {
+            return basePriceTier3;
+        } else if (totalMinted > tier2) {
+            // Logarithmic scaling for tier 2
+            uint256 logScale = _calculateLogScale(totalMinted);
+            return logScale * 22 + basePriceTier2;
+        } else if (totalMinted > tier1) {
+            // Logarithmic scaling for tier 1
+            uint256 logScale = _calculateLogScale(totalMinted);
+            return logScale * 3 + basePriceTier1;
+        } else {
+            // Below tier 1
+            if (freeAllocation > totalMinted) return 0;
+
+            // Logarithmic scaling for tier 0
+            uint256 logScale = _calculateLogScale(totalMinted == 0 ? 1 : totalMinted);
+            return logScale / 2 + basePriceTier1; // // Dividing by 2 is an arbitrary scaling factor
+        }
+    }
+
+    function _calculateLogScale(uint256 value) private pure returns (uint256) {
+        UD60x18 logResult = log10(Casting.ud(value * SCALE));
+        return Casting.intoUint256(logResult) / LOG_BASE;
+    }
+}

package/src/spaces/facets/membership/pricing/tiered/TieredLogPricingOracleV3.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IMembershipPricing} from "src/spaces/facets/membership/pricing/IMembershipPricing.sol";
+import {AggregatorV3Interface} from "src/utils/interfaces/AggregatorV3Interface.sol";
+
+// libraries
+import {Casting, UD60x18, log10} from "@prb/math/UD60x18.sol";
+
+// contracts
+import {IntrospectionFacet} from "@towns-protocol/diamond/src/facets/introspection/IntrospectionFacet.sol";
+
+/**
+ * @title TieredLogPricingOracle
+ * @notice Network: Base (Sepolia)
+ */
+contract TieredLogPricingOracleV3 is IMembershipPricing, IntrospectionFacet {
+    AggregatorV3Interface internal dataFeed;
+
+    uint256 internal constant SCALE = 1e18; // 1 ether
+    uint256 internal constant CENT_SCALE = 100;
+    uint256 internal constant LOG_BASE = 10 ** 16;
+    uint256 internal constant FEED_TIMEOUT = 24 hours;
+
+    // Cached values for optimization
+    uint256 private immutable exchangeRateDecimals;
+    uint256 private immutable exchangeRateScale;
+
+    // Error messages
+    error TieredLogPricingOracle__InvalidAnswer();
+    error TieredLogPricingOracle__InvalidRound();
+    error TieredLogPricingOracle__InvalidTimestamp();
+    error TieredLogPricingOracle__StaleData();
+
+    constructor(address priceFeed) {
+        __IntrospectionBase_init();
+        _addInterface(type(IMembershipPricing).interfaceId);
+        dataFeed = AggregatorV3Interface(priceFeed);
+        exchangeRateDecimals = 10 ** dataFeed.decimals();
+        exchangeRateScale = exchangeRateDecimals * CENT_SCALE;
+    }
+
+    function name() public pure override returns (string memory) {
+        return "TieredLogPricingOracleV3";
+    }
+
+    function description() public pure override returns (string memory) {
+        return "Logarithmically increasing price";
+    }
+
+    function setPrice(uint256) external pure {
+        revert("TieredLogPricingOracle: price is calculated logarithmically");
+    }
+
+    function getPrice(uint256 freeAllocation, uint256 totalMinted) public view returns (uint256) {
+        uint256 stablePriceCents = _calculateStablePrice(freeAllocation, totalMinted);
+
+        return _getWeiFromCents(stablePriceCents);
+    }
+
+    // =============================================================
+    //                           Internal
+    // =============================================================
+
+    function getChainlinkDataFeedLatestAnswer() public view returns (uint256) {
+        // prettier-ignore
+        (
+            uint80 roundId,
+            int256 answer,
+            /*uint startedAt*/
+            ,
+            uint256 updatedAt,
+            /*uint80 answeredInRound*/
+        ) = dataFeed.latestRoundData();
+
+        if (answer <= 0) revert TieredLogPricingOracle__InvalidAnswer();
+        if (roundId == 0) revert TieredLogPricingOracle__InvalidRound();
+        if (updatedAt == 0) revert TieredLogPricingOracle__InvalidTimestamp();
+        if (updatedAt > block.timestamp) {
+            revert TieredLogPricingOracle__InvalidTimestamp();
+        }
+        if (block.timestamp - updatedAt > FEED_TIMEOUT) {
+            revert TieredLogPricingOracle__StaleData();
+        }
+
+        return uint256(answer);
+    }
+
+    /// @notice Converts a price in cents to wei
+    /// @param cents The price in cents to convert
+    /// @return The price in wei
+    function _getWeiFromCents(uint256 cents) internal view returns (uint256) {
+        uint256 exchangeRate = getChainlinkDataFeedLatestAnswer(); // chainlink oracle returns this
+        // value
+
+        // oracle or governance
+        // multiple before divide to avoid truncation which ends up in precision loss
+        uint256 ethToUsdExchangeRateCents = (exchangeRate * 100) / exchangeRateDecimals;
+        uint256 oneCentInWei = SCALE / ethToUsdExchangeRateCents;
+
+        return oneCentInWei * cents;
+    }
+
+    function _calculateStablePrice(uint256, uint256 totalMinted) internal pure returns (uint256) {
+        // Define minted tiers
+        uint256 tier1 = 100;
+        uint256 tier2 = 1000;
+        uint256 tier3 = 10_000;
+
+        // Define base prices in cents
+        uint256 basePriceTier1 = 100; // $1.00
+        uint256 basePriceTier2 = 1000; // $10.00
+        uint256 basePriceTier3 = 10_000; // $100.00
+
+        if (totalMinted <= tier1) {
+            // Logarithmic scaling for tier 1
+            uint256 logScale = _calculateLogScale(totalMinted == 0 ? 1 : totalMinted);
+            return logScale / 2 + basePriceTier1; // Dividing by 2 is an arbitrary scaling factor
+        } else if (totalMinted <= tier2) {
+            // Logarithmic scaling for tier 2
+            uint256 logScale = _calculateLogScale(totalMinted);
+            return logScale * 3 + basePriceTier1;
+        } else if (totalMinted <= tier3) {
+            // Logarithmic scaling for tier 3
+            uint256 logScale = _calculateLogScale(totalMinted);
+            return logScale * 22 + basePriceTier2;
+        } else {
+            return basePriceTier3;
+        }
+    }
+
+    function _calculateLogScale(uint256 value) private pure returns (uint256) {
+        UD60x18 logResult = log10(Casting.ud(value * SCALE));
+        return Casting.intoUint256(logResult) / LOG_BASE;
+    }
+}

package/src/spaces/facets/membership/token/MembershipToken.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IMembershipBase} from "src/spaces/facets/membership/IMembership.sol";
+
+// libraries
+
+// contracts
+import {ERC721A} from "src/diamond/facets/token/ERC721A/ERC721A.sol";
+import {BanningBase} from "src/spaces/facets/banning/BanningBase.sol";
+
+contract MembershipToken is ERC721A, BanningBase, IMembershipBase {
+    function _beforeTokenTransfers(
+        address from,
+        address to,
+        uint256 tokenId,
+        uint256 quantity
+    ) internal override {
+        if (from != address(0) && _isBanned(tokenId)) {
+            revert Membership__Banned();
+        }
+        super._beforeTokenTransfers(from, to, tokenId, quantity);
+    }
+}

package/src/spaces/facets/owner/ISpaceOwner.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+interface ISpaceOwnerBase {
+    struct Space {
+        string name;
+        string uri;
+        uint256 tokenId;
+        uint256 createdAt;
+        string shortDescription;
+        string longDescription;
+    }
+
+    error SpaceOwner__OnlyFactoryAllowed();
+    error SpaceOwner__OnlySpaceOwnerAllowed();
+    error SpaceOwner__SpaceNotFound();
+    error SpaceOwner__DefaultUriNotSet();
+
+    event SpaceOwner__UpdateSpace(address indexed space);
+    event SpaceOwner__SetFactory(address factory);
+    event SpaceOwner__SetDefaultUri(string uri);
+}
+
+interface ISpaceOwner is ISpaceOwnerBase {
+    /// @notice Set the factory address that is allowed to mint spaces
+    function setFactory(address factory) external;
+
+    /// @notice Get the factory address
+    function getFactory() external view returns (address);
+
+    /// @notice Set the default URI
+    function setDefaultUri(string memory uri) external;
+
+    /// @notice Get the default URI
+    function getDefaultUri() external view returns (string memory);
+
+    /// @notice Get the next token id that will be used to mint a space
+    function nextTokenId() external view returns (uint256);
+
+    /// @notice Mint a space
+    /// @dev Only the factory is allowed to mint spaces
+    /// @param name The name of the space
+    /// @param uri The URI of the space
+    /// @param space The address of the space
+    /// @param shortDescription The short description of the space
+    /// @param longDescription The long description of the space
+    /// @return tokenId The token id of the minted space
+    function mintSpace(
+        string memory name,
+        string memory uri,
+        address space,
+        string memory shortDescription,
+        string memory longDescription
+    ) external returns (uint256 tokenId);
+
+    /// @notice Get the space info
+    /// @param space The address of the space
+    /// @return space The space info
+    function getSpaceInfo(address space) external view returns (Space memory);
+
+    /// @notice Get the space address by token id
+    /// @param tokenId The token id of the space
+    /// @return space The address of the space
+    function getSpaceByTokenId(uint256 tokenId) external view returns (address);
+
+    /// @notice Update the space info
+    /// @dev Only the space owner is allowed to update the space info
+    /// @param space The address of the space
+    /// @param name The name of the space
+    /// @param uri The URI of the space
+    /// @param shortDescription The short description of the space
+    /// @param longDescription The long description of the space
+    function updateSpaceInfo(
+        address space,
+        string memory name,
+        string memory uri,
+        string memory shortDescription,
+        string memory longDescription
+    ) external;
+}

package/src/spaces/facets/owner/SpaceOwner.sol

@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {ISpaceOwner} from "./ISpaceOwner.sol";
+import {IERC4906} from "@openzeppelin/contracts/interfaces/IERC4906.sol";
+import {IMembershipMetadata} from "src/spaces/facets/membership/metadata/IMembershipMetadata.sol";
+
+// libraries
+
+// contracts
+
+import {SpaceOwnerBase} from "./SpaceOwnerBase.sol";
+
+import {SpaceOwnerUriBase} from "./SpaceOwnerUriBase.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {Votes} from "src/diamond/facets/governance/votes/Votes.sol";
+import {ERC721A} from "src/diamond/facets/token/ERC721A/ERC721A.sol";
+import {GuardianBase} from "src/spaces/facets/guardian/GuardianBase.sol";
+
+contract SpaceOwner is
+    ISpaceOwner,
+    SpaceOwnerBase,
+    SpaceOwnerUriBase,
+    OwnableBase,
+    GuardianBase,
+    Votes,
+    ERC721A
+{
+    function __SpaceOwner_init(string memory name, string memory symbol) external initializer {
+        __ERC721A_init_unchained(name, symbol);
+    }
+
+    // =============================================================
+    //                           Factory
+    // =============================================================
+
+    /// @inheritdoc ISpaceOwner
+    function setFactory(address factory) external onlyOwner {
+        _setFactory(factory);
+    }
+
+    /// @inheritdoc ISpaceOwner
+    function getFactory() external view returns (address) {
+        return _getFactory();
+    }
+
+    // =============================================================
+    //                           Space
+    // =============================================================
+
+    /// @inheritdoc ISpaceOwner
+    function nextTokenId() external view returns (uint256) {
+        return _nextTokenId();
+    }
+
+    /// @inheritdoc ISpaceOwner
+    function mintSpace(
+        string memory name,
+        string memory uri,
+        address space,
+        string memory shortDescription,
+        string memory longDescription
+    ) external onlyFactory returns (uint256 tokenId) {
+        tokenId = _nextTokenId();
+        _mintSpace(name, uri, tokenId, space, shortDescription, longDescription);
+        _mint(msg.sender, 1);
+    }
+
+    /// @inheritdoc ISpaceOwner
+    function getSpaceInfo(address space) external view returns (Space memory) {
+        return _getSpace(space);
+    }
+
+    /// @inheritdoc ISpaceOwner
+    function getSpaceByTokenId(uint256 tokenId) external view returns (address) {
+        return _getSpaceByTokenId(tokenId);
+    }
+
+    /// @inheritdoc ISpaceOwner
+    function updateSpaceInfo(
+        address space,
+        string memory name,
+        string memory uri,
+        string memory shortDescription,
+        string memory longDescription
+    ) external {
+        _onlySpaceOwner(space);
+        _updateSpace(space, name, uri, shortDescription, longDescription);
+
+        IMembershipMetadata(space).refreshMetadata();
+
+        emit IERC4906.MetadataUpdate(_getTokenId(space));
+    }
+
+    // =============================================================
+    //                           Uri
+    // =============================================================
+
+    /// @inheritdoc ISpaceOwner
+    function setDefaultUri(string memory uri) external onlyOwner {
+        _setDefaultUri(uri);
+    }
+
+    /// @inheritdoc ISpaceOwner
+    function getDefaultUri() external view returns (string memory) {
+        return _getDefaultUri();
+    }
+
+    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
+        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
+
+        return _render(tokenId);
+    }
+
+    // =============================================================
+    //                           Overrides
+    // =============================================================
+    function approve(address to, uint256 tokenId) public payable override {
+        // allow removing approvals even if guardian is enabled
+        if (to != address(0) && _guardianEnabled(msg.sender)) {
+            revert Guardian_Enabled();
+        }
+
+        super.approve(to, tokenId);
+    }
+
+    function setApprovalForAll(address operator, bool approved) public override {
+        // allow removing approvals even if guardian is enabled
+        if (approved && _guardianEnabled(msg.sender)) {
+            revert Guardian_Enabled();
+        }
+
+        super.setApprovalForAll(operator, approved);
+    }
+
+    function _beforeTokenTransfers(
+        address from,
+        address to,
+        uint256 startTokenId,
+        uint256 quantity
+    ) internal override {
+        if (from != address(0) && _guardianEnabled(from)) {
+            // allow transferring handle at minting time
+            revert Guardian_Enabled();
+        }
+
+        super._beforeTokenTransfers(from, to, startTokenId, quantity);
+    }
+
+    function _afterTokenTransfers(
+        address from,
+        address to,
+        uint256 firstTokenId,
+        uint256 batchSize
+    ) internal virtual override {
+        _transferVotingUnits(from, to, batchSize);
+        super._afterTokenTransfers(from, to, firstTokenId, batchSize);
+    }
+
+    function _getVotingUnits(address account) internal view virtual override returns (uint256) {
+        return balanceOf(account);
+    }
+
+    // =============================================================
+    //                           Internal
+    // =============================================================
+    function _onlySpaceOwner(address space) internal view {
+        if (_ownerOf(_getTokenId(space)) != msg.sender) {
+            revert SpaceOwner__OnlySpaceOwnerAllowed();
+        }
+    }
+}

package/src/spaces/facets/owner/SpaceOwnerBase.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ISpaceOwnerBase} from "./ISpaceOwner.sol";
+
+// libraries
+import {SpaceOwnerStorage} from "./SpaceOwnerStorage.sol";
+import {Validator} from "../../../utils/libraries/Validator.sol";
+
+// contracts
+
+abstract contract SpaceOwnerBase is ISpaceOwnerBase {
+    // =============================================================
+    //                           Factory
+    // =============================================================
+    modifier onlyFactory() {
+        SpaceOwnerStorage.Layout storage ds = SpaceOwnerStorage.layout();
+        if (msg.sender != ds.factory) {
+            revert SpaceOwner__OnlyFactoryAllowed();
+        }
+        _;
+    }
+
+    function _setFactory(address factory) internal {
+        Validator.checkAddress(factory);
+
+        SpaceOwnerStorage.Layout storage ds = SpaceOwnerStorage.layout();
+        ds.factory = factory;
+        emit SpaceOwner__SetFactory(factory);
+    }
+
+    function _getFactory() internal view returns (address) {
+        SpaceOwnerStorage.Layout storage ds = SpaceOwnerStorage.layout();
+        return ds.factory;
+    }
+
+    // =============================================================
+    //                           Space
+    // =============================================================
+
+    function _mintSpace(
+        string memory name,
+        string memory uri,
+        uint256 tokenId,
+        address space,
+        string memory shortDescription,
+        string memory longDescription
+    ) internal {
+        Validator.checkLength(name, 2);
+        // if the space uri is empty, it will default to `${defaultUri}/${spaceAddress}`
+        Validator.checkLength(uri, 0);
+        Validator.checkAddress(space);
+
+        SpaceOwnerStorage.Layout storage ds = SpaceOwnerStorage.layout();
+
+        ds.spaceByTokenId[tokenId] = space;
+        ds.spaceByAddress[space] = SpaceOwnerStorage.Space({
+            name: name,
+            uri: uri,
+            tokenId: tokenId,
+            createdAt: block.timestamp
+        });
+        ds.spaceMetadata[space] = SpaceOwnerStorage.SpaceMetadata({
+            shortDescription: shortDescription,
+            longDescription: longDescription
+        });
+    }
+
+    function _updateSpace(
+        address space,
+        string memory name,
+        string memory uri,
+        string memory shortDescription,
+        string memory longDescription
+    ) internal {
+        Validator.checkLength(name, 2);
+        // if the space uri is empty, it will default to `${defaultUri}/${spaceAddress}`
+        Validator.checkLength(uri, 0);
+
+        SpaceOwnerStorage.Layout storage ds = SpaceOwnerStorage.layout();
+
+        SpaceOwnerStorage.Space storage spaceInfo = ds.spaceByAddress[space];
+        spaceInfo.name = name;
+        spaceInfo.uri = uri;
+
+        SpaceOwnerStorage.SpaceMetadata storage metadata = ds.spaceMetadata[space];
+        metadata.shortDescription = shortDescription;
+        metadata.longDescription = longDescription;
+
+        emit SpaceOwner__UpdateSpace(space);
+    }
+
+    function _getSpace(address space) internal view returns (Space memory) {
+        SpaceOwnerStorage.Space storage spaceInfo = SpaceOwnerStorage.layout().spaceByAddress[
+            space
+        ];
+
+        SpaceOwnerStorage.SpaceMetadata storage metadata = SpaceOwnerStorage.layout().spaceMetadata[
+            space
+        ];
+
+        return
+            Space({
+                name: spaceInfo.name,
+                uri: spaceInfo.uri,
+                tokenId: spaceInfo.tokenId,
+                createdAt: spaceInfo.createdAt,
+                shortDescription: metadata.shortDescription,
+                longDescription: metadata.longDescription
+            });
+    }
+
+    function _getTokenId(address space) internal view returns (uint256) {
+        return SpaceOwnerStorage.layout().spaceByAddress[space].tokenId;
+    }
+
+    function _getSpaceByTokenId(uint256 tokenId) internal view returns (address) {
+        return SpaceOwnerStorage.layout().spaceByTokenId[tokenId];
+    }
+}