@rarible/external-contracts 3.11.4

package/contracts/extension/Staking721Upgradeable.sol

@@ -0,0 +1,364 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/// @author thirdweb
+
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import "../external-deps/openzeppelin/utils/math/SafeMath.sol";
+import "../eip/interface/IERC721.sol";
+
+import "./interface/IStaking721.sol";
+
+abstract contract Staking721Upgradeable is ReentrancyGuardUpgradeable, IStaking721 {
+    /*///////////////////////////////////////////////////////////////
+                            State variables / Mappings
+    //////////////////////////////////////////////////////////////*/
+
+    ///@dev Address of ERC721 NFT contract -- staked tokens belong to this contract.
+    address public stakingToken;
+
+    /// @dev Flag to check direct transfers of staking tokens.
+    uint8 internal isStaking = 1;
+
+    ///@dev Next staking condition Id. Tracks number of conditon updates so far.
+    uint64 private nextConditionId;
+
+    ///@dev List of token-ids ever staked.
+    uint256[] public indexedTokens;
+
+    /// @dev List of accounts that have staked their NFTs.
+    address[] public stakersArray;
+
+    ///@dev Mapping from token-id to whether it is indexed or not.
+    mapping(uint256 => bool) public isIndexed;
+
+    ///@dev Mapping from staker address to Staker struct. See {struct IStaking721.Staker}.
+    mapping(address => Staker) public stakers;
+
+    /// @dev Mapping from staked token-id to staker address.
+    mapping(uint256 => address) public stakerAddress;
+
+    ///@dev Mapping from condition Id to staking condition. See {struct IStaking721.StakingCondition}
+    mapping(uint256 => StakingCondition) private stakingConditions;
+
+    function __Staking721_init(address _stakingToken) internal onlyInitializing {
+        __ReentrancyGuard_init();
+
+        require(address(_stakingToken) != address(0), "collection address 0");
+        stakingToken = _stakingToken;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        External/Public Functions
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice    Stake ERC721 Tokens.
+     *
+     *  @dev       See {_stake}. Override that to implement custom logic.
+     *
+     *  @param _tokenIds    List of tokens to stake.
+     */
+    function stake(uint256[] calldata _tokenIds) external nonReentrant {
+        _stake(_tokenIds);
+    }
+
+    /**
+     *  @notice    Withdraw staked tokens.
+     *
+     *  @dev       See {_withdraw}. Override that to implement custom logic.
+     *
+     *  @param _tokenIds    List of tokens to withdraw.
+     */
+    function withdraw(uint256[] calldata _tokenIds) external nonReentrant {
+        _withdraw(_tokenIds);
+    }
+
+    /**
+     *  @notice    Claim accumulated rewards.
+     *
+     *  @dev       See {_claimRewards}. Override that to implement custom logic.
+     *             See {_calculateRewards} for reward-calculation logic.
+     */
+    function claimRewards() external nonReentrant {
+        _claimRewards();
+    }
+
+    /**
+     *  @notice  Set time unit. Set as a number of seconds.
+     *           Could be specified as -- x * 1 hours, x * 1 days, etc.
+     *
+     *  @dev     Only admin/authorized-account can call it.
+     *
+     *
+     *  @param _timeUnit    New time unit.
+     */
+    function setTimeUnit(uint256 _timeUnit) external virtual {
+        if (!_canSetStakeConditions()) {
+            revert("Not authorized");
+        }
+
+        StakingCondition memory condition = stakingConditions[nextConditionId - 1];
+        require(_timeUnit != condition.timeUnit, "Time-unit unchanged.");
+
+        _setStakingCondition(_timeUnit, condition.rewardsPerUnitTime);
+
+        emit UpdatedTimeUnit(condition.timeUnit, _timeUnit);
+    }
+
+    /**
+     *  @notice  Set rewards per unit of time.
+     *           Interpreted as x rewards per second/per day/etc based on time-unit.
+     *
+     *  @dev     Only admin/authorized-account can call it.
+     *
+     *
+     *  @param _rewardsPerUnitTime    New rewards per unit time.
+     */
+    function setRewardsPerUnitTime(uint256 _rewardsPerUnitTime) external virtual {
+        if (!_canSetStakeConditions()) {
+            revert("Not authorized");
+        }
+
+        StakingCondition memory condition = stakingConditions[nextConditionId - 1];
+        require(_rewardsPerUnitTime != condition.rewardsPerUnitTime, "Reward unchanged.");
+
+        _setStakingCondition(condition.timeUnit, _rewardsPerUnitTime);
+
+        emit UpdatedRewardsPerUnitTime(condition.rewardsPerUnitTime, _rewardsPerUnitTime);
+    }
+
+    /**
+     *  @notice View amount staked and total rewards for a user.
+     *
+     *  @param _staker          Address for which to calculated rewards.
+     *  @return _tokensStaked   List of token-ids staked by staker.
+     *  @return _rewards        Available reward amount.
+     */
+    function getStakeInfo(
+        address _staker
+    ) external view virtual returns (uint256[] memory _tokensStaked, uint256 _rewards) {
+        uint256[] memory _indexedTokens = indexedTokens;
+        bool[] memory _isStakerToken = new bool[](_indexedTokens.length);
+        uint256 indexedTokenCount = _indexedTokens.length;
+        uint256 stakerTokenCount = 0;
+
+        for (uint256 i = 0; i < indexedTokenCount; i++) {
+            _isStakerToken[i] = stakerAddress[_indexedTokens[i]] == _staker;
+            if (_isStakerToken[i]) stakerTokenCount += 1;
+        }
+
+        _tokensStaked = new uint256[](stakerTokenCount);
+        uint256 count = 0;
+        for (uint256 i = 0; i < indexedTokenCount; i++) {
+            if (_isStakerToken[i]) {
+                _tokensStaked[count] = _indexedTokens[i];
+                count += 1;
+            }
+        }
+
+        _rewards = _availableRewards(_staker);
+    }
+
+    function getTimeUnit() public view returns (uint256 _timeUnit) {
+        _timeUnit = stakingConditions[nextConditionId - 1].timeUnit;
+    }
+
+    function getRewardsPerUnitTime() public view returns (uint256 _rewardsPerUnitTime) {
+        _rewardsPerUnitTime = stakingConditions[nextConditionId - 1].rewardsPerUnitTime;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            Internal Functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Staking logic. Override to add custom logic.
+    function _stake(uint256[] calldata _tokenIds) internal virtual {
+        uint64 len = uint64(_tokenIds.length);
+        require(len != 0, "Staking 0 tokens");
+
+        address _stakingToken = stakingToken;
+
+        if (stakers[_stakeMsgSender()].amountStaked > 0) {
+            _updateUnclaimedRewardsForStaker(_stakeMsgSender());
+        } else {
+            stakersArray.push(_stakeMsgSender());
+            stakers[_stakeMsgSender()].timeOfLastUpdate = uint128(block.timestamp);
+            stakers[_stakeMsgSender()].conditionIdOflastUpdate = nextConditionId - 1;
+        }
+        for (uint256 i = 0; i < len; ++i) {
+            isStaking = 2;
+            IERC721(_stakingToken).safeTransferFrom(_stakeMsgSender(), address(this), _tokenIds[i]);
+            isStaking = 1;
+
+            stakerAddress[_tokenIds[i]] = _stakeMsgSender();
+
+            if (!isIndexed[_tokenIds[i]]) {
+                isIndexed[_tokenIds[i]] = true;
+                indexedTokens.push(_tokenIds[i]);
+            }
+        }
+        stakers[_stakeMsgSender()].amountStaked += len;
+
+        emit TokensStaked(_stakeMsgSender(), _tokenIds);
+    }
+
+    /// @dev Withdraw logic. Override to add custom logic.
+    function _withdraw(uint256[] calldata _tokenIds) internal virtual {
+        uint256 _amountStaked = stakers[_stakeMsgSender()].amountStaked;
+        uint64 len = uint64(_tokenIds.length);
+        require(len != 0, "Withdrawing 0 tokens");
+        require(_amountStaked >= len, "Withdrawing more than staked");
+
+        address _stakingToken = stakingToken;
+
+        _updateUnclaimedRewardsForStaker(_stakeMsgSender());
+
+        if (_amountStaked == len) {
+            address[] memory _stakersArray = stakersArray;
+            for (uint256 i = 0; i < _stakersArray.length; ++i) {
+                if (_stakersArray[i] == _stakeMsgSender()) {
+                    stakersArray[i] = _stakersArray[_stakersArray.length - 1];
+                    stakersArray.pop();
+                    break;
+                }
+            }
+        }
+        stakers[_stakeMsgSender()].amountStaked -= len;
+
+        for (uint256 i = 0; i < len; ++i) {
+            require(stakerAddress[_tokenIds[i]] == _stakeMsgSender(), "Not staker");
+            stakerAddress[_tokenIds[i]] = address(0);
+            IERC721(_stakingToken).safeTransferFrom(address(this), _stakeMsgSender(), _tokenIds[i]);
+        }
+
+        emit TokensWithdrawn(_stakeMsgSender(), _tokenIds);
+    }
+
+    /// @dev Logic for claiming rewards. Override to add custom logic.
+    function _claimRewards() internal virtual {
+        uint256 rewards = stakers[_stakeMsgSender()].unclaimedRewards + _calculateRewards(_stakeMsgSender());
+
+        require(rewards != 0, "No rewards");
+
+        stakers[_stakeMsgSender()].timeOfLastUpdate = uint128(block.timestamp);
+        stakers[_stakeMsgSender()].unclaimedRewards = 0;
+        stakers[_stakeMsgSender()].conditionIdOflastUpdate = nextConditionId - 1;
+
+        _mintRewards(_stakeMsgSender(), rewards);
+
+        emit RewardsClaimed(_stakeMsgSender(), rewards);
+    }
+
+    /// @dev View available rewards for a user.
+    function _availableRewards(address _user) internal view virtual returns (uint256 _rewards) {
+        if (stakers[_user].amountStaked == 0) {
+            _rewards = stakers[_user].unclaimedRewards;
+        } else {
+            _rewards = stakers[_user].unclaimedRewards + _calculateRewards(_user);
+        }
+    }
+
+    /// @dev Update unclaimed rewards for a users. Called for every state change for a user.
+    function _updateUnclaimedRewardsForStaker(address _staker) internal virtual {
+        uint256 rewards = _calculateRewards(_staker);
+        stakers[_staker].unclaimedRewards += rewards;
+        stakers[_staker].timeOfLastUpdate = uint128(block.timestamp);
+        stakers[_staker].conditionIdOflastUpdate = nextConditionId - 1;
+    }
+
+    /// @dev Set staking conditions.
+    function _setStakingCondition(uint256 _timeUnit, uint256 _rewardsPerUnitTime) internal virtual {
+        require(_timeUnit != 0, "time-unit can't be 0");
+        uint256 conditionId = nextConditionId;
+        nextConditionId += 1;
+
+        stakingConditions[conditionId] = StakingCondition({
+            timeUnit: _timeUnit,
+            rewardsPerUnitTime: _rewardsPerUnitTime,
+            startTimestamp: block.timestamp,
+            endTimestamp: 0
+        });
+
+        if (conditionId > 0) {
+            stakingConditions[conditionId - 1].endTimestamp = block.timestamp;
+        }
+    }
+
+    /// @dev Calculate rewards for a staker.
+    function _calculateRewards(address _staker) internal view virtual returns (uint256 _rewards) {
+        Staker memory staker = stakers[_staker];
+
+        uint256 _stakerConditionId = staker.conditionIdOflastUpdate;
+        uint256 _nextConditionId = nextConditionId;
+
+        for (uint256 i = _stakerConditionId; i < _nextConditionId; i += 1) {
+            StakingCondition memory condition = stakingConditions[i];
+
+            uint256 startTime = i != _stakerConditionId ? condition.startTimestamp : staker.timeOfLastUpdate;
+            uint256 endTime = condition.endTimestamp != 0 ? condition.endTimestamp : block.timestamp;
+
+            (bool noOverflowProduct, uint256 rewardsProduct) = SafeMath.tryMul(
+                (endTime - startTime) * staker.amountStaked,
+                condition.rewardsPerUnitTime
+            );
+            (bool noOverflowSum, uint256 rewardsSum) = SafeMath.tryAdd(_rewards, rewardsProduct / condition.timeUnit);
+
+            _rewards = noOverflowProduct && noOverflowSum ? rewardsSum : _rewards;
+        }
+    }
+
+    /*////////////////////////////////////////////////////////////////////
+        Optional hooks that can be implemented in the derived contract
+    ///////////////////////////////////////////////////////////////////*/
+
+    /// @dev Exposes the ability to override the msg sender -- support ERC2771.
+    function _stakeMsgSender() internal virtual returns (address) {
+        return msg.sender;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+        Virtual functions to be implemented in derived contract
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice View total rewards available in the staking contract.
+     *
+     */
+    function getRewardTokenBalance() external view virtual returns (uint256 _rewardsAvailableInContract);
+
+    /**
+     *  @dev    Mint/Transfer ERC20 rewards to the staker. Must override.
+     *
+     *  @param _staker    Address for which to calculated rewards.
+     *  @param _rewards   Amount of tokens to be given out as reward.
+     *
+     *  For example, override as below to mint ERC20 rewards:
+     *
+     * ```
+     *  function _mintRewards(address _staker, uint256 _rewards) internal override {
+     *
+     *      TokenERC20(rewardTokenAddress).mintTo(_staker, _rewards);
+     *
+     *  }
+     * ```
+     */
+    function _mintRewards(address _staker, uint256 _rewards) internal virtual;
+
+    /**
+     *  @dev    Returns whether staking restrictions can be set in given execution context.
+     *          Must override.
+     *
+     *
+     *  For example, override as below to restrict access to admin:
+     *
+     * ```
+     *  function _canSetStakeConditions() internal override {
+     *
+     *      return msg.sender == adminAddress;
+     *
+     *  }
+     * ```
+     */
+    function _canSetStakeConditions() internal view virtual returns (bool);
+}

package/contracts/extension/TokenBundle.sol

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/ITokenBundle.sol";
+import { CurrencyTransferLib } from "../lib/CurrencyTransferLib.sol";
+
+interface IERC165 {
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}
+
+/**
+ *  @title   Token Bundle
+ *  @notice  `TokenBundle` contract extension allows bundling-up of ERC20/ERC721/ERC1155 and native-tokan assets
+ *           in a data structure, and provides logic for setting/getting IDs and URIs for created bundles.
+ *  @dev     See {ITokenBundle}
+ */
+
+abstract contract TokenBundle is ITokenBundle {
+    /// @dev Mapping from bundle UID => bundle info.
+    mapping(uint256 => BundleInfo) private bundle;
+
+    /// @dev Returns the total number of assets in a particular bundle.
+    function getTokenCountOfBundle(uint256 _bundleId) public view returns (uint256) {
+        return bundle[_bundleId].count;
+    }
+
+    /// @dev Returns an asset contained in a particular bundle, at a particular index.
+    function getTokenOfBundle(uint256 _bundleId, uint256 index) public view returns (Token memory) {
+        return bundle[_bundleId].tokens[index];
+    }
+
+    /// @dev Returns the uri of a particular bundle.
+    function getUriOfBundle(uint256 _bundleId) public view returns (string memory) {
+        return bundle[_bundleId].uri;
+    }
+
+    /// @dev Lets the calling contract create a bundle, by passing in a list of tokens and a unique id.
+    function _createBundle(Token[] calldata _tokensToBind, uint256 _bundleId) internal {
+        uint256 targetCount = _tokensToBind.length;
+
+        require(targetCount > 0, "!Tokens");
+        require(bundle[_bundleId].count == 0, "id exists");
+
+        for (uint256 i = 0; i < targetCount; i += 1) {
+            _checkTokenType(_tokensToBind[i]);
+            bundle[_bundleId].tokens[i] = _tokensToBind[i];
+        }
+
+        bundle[_bundleId].count = targetCount;
+    }
+
+    /// @dev Lets the calling contract update a bundle, by passing in a list of tokens and a unique id.
+    function _updateBundle(Token[] memory _tokensToBind, uint256 _bundleId) internal {
+        require(_tokensToBind.length > 0, "!Tokens");
+
+        uint256 currentCount = bundle[_bundleId].count;
+        uint256 targetCount = _tokensToBind.length;
+        uint256 check = currentCount > targetCount ? currentCount : targetCount;
+
+        for (uint256 i = 0; i < check; i += 1) {
+            if (i < targetCount) {
+                _checkTokenType(_tokensToBind[i]);
+                bundle[_bundleId].tokens[i] = _tokensToBind[i];
+            } else if (i < currentCount) {
+                delete bundle[_bundleId].tokens[i];
+            }
+        }
+
+        bundle[_bundleId].count = targetCount;
+    }
+
+    /// @dev Lets the calling contract add a token to a bundle for a unique bundle id and index.
+    function _addTokenInBundle(Token memory _tokenToBind, uint256 _bundleId) internal {
+        _checkTokenType(_tokenToBind);
+        uint256 id = bundle[_bundleId].count;
+
+        bundle[_bundleId].tokens[id] = _tokenToBind;
+        bundle[_bundleId].count += 1;
+    }
+
+    /// @dev Lets the calling contract update a token in a bundle for a unique bundle id and index.
+    function _updateTokenInBundle(Token memory _tokenToBind, uint256 _bundleId, uint256 _index) internal {
+        require(_index < bundle[_bundleId].count, "index DNE");
+        _checkTokenType(_tokenToBind);
+        bundle[_bundleId].tokens[_index] = _tokenToBind;
+    }
+
+    /// @dev Checks if the type of asset-contract is same as the TokenType specified.
+    function _checkTokenType(Token memory _token) internal view {
+        if (_token.tokenType == TokenType.ERC721) {
+            try IERC165(_token.assetContract).supportsInterface(0x80ac58cd) returns (bool supported721) {
+                require(supported721, "!TokenType");
+            } catch {
+                revert("!TokenType");
+            }
+        } else if (_token.tokenType == TokenType.ERC1155) {
+            try IERC165(_token.assetContract).supportsInterface(0xd9b67a26) returns (bool supported1155) {
+                require(supported1155, "!TokenType");
+            } catch {
+                revert("!TokenType");
+            }
+        } else if (_token.tokenType == TokenType.ERC20) {
+            if (_token.assetContract != CurrencyTransferLib.NATIVE_TOKEN) {
+                // 0x36372b07
+                try IERC165(_token.assetContract).supportsInterface(0x80ac58cd) returns (bool supported721) {
+                    require(!supported721, "!TokenType");
+
+                    try IERC165(_token.assetContract).supportsInterface(0xd9b67a26) returns (bool supported1155) {
+                        require(!supported1155, "!TokenType");
+                    } catch Error(string memory) {} catch {}
+                } catch Error(string memory) {} catch {}
+            }
+        }
+    }
+
+    /// @dev Lets the calling contract set/update the uri of a particular bundle.
+    function _setUriOfBundle(string memory _uri, uint256 _bundleId) internal {
+        bundle[_bundleId].uri = _uri;
+    }
+
+    /// @dev Lets the calling contract delete a particular bundle.
+    function _deleteBundle(uint256 _bundleId) internal {
+        for (uint256 i = 0; i < bundle[_bundleId].count; i += 1) {
+            delete bundle[_bundleId].tokens[i];
+        }
+        bundle[_bundleId].count = 0;
+    }
+}

package/contracts/extension/TokenStore.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+//  ==========  External imports    ==========
+
+import "../eip/interface/IERC1155.sol";
+import "../eip/interface/IERC721.sol";
+
+import "../external-deps/openzeppelin/utils/ERC1155/ERC1155Holder.sol";
+import "../external-deps/openzeppelin/utils/ERC721/ERC721Holder.sol";
+
+//  ==========  Internal imports    ==========
+
+import { TokenBundle, ITokenBundle } from "./TokenBundle.sol";
+import { CurrencyTransferLib } from "../lib/CurrencyTransferLib.sol";
+
+/**
+ *  @title   Token Store
+ *  @notice  `TokenStore` contract extension allows bundling-up of ERC20/ERC721/ERC1155 and native-tokan assets
+ *           and provides logic for storing, releasing, and transferring them from the extending contract.
+ *  @dev     See {CurrencyTransferLib}
+ */
+
+contract TokenStore is TokenBundle, ERC721Holder, ERC1155Holder {
+    /// @dev The address of the native token wrapper contract.
+    address internal immutable nativeTokenWrapper;
+
+    constructor(address _nativeTokenWrapper) {
+        nativeTokenWrapper = _nativeTokenWrapper;
+    }
+
+    /// @dev Store / escrow multiple ERC1155, ERC721, ERC20 tokens.
+    function _storeTokens(
+        address _tokenOwner,
+        Token[] calldata _tokens,
+        string memory _uriForTokens,
+        uint256 _idForTokens
+    ) internal {
+        _createBundle(_tokens, _idForTokens);
+        _setUriOfBundle(_uriForTokens, _idForTokens);
+        _transferTokenBatch(_tokenOwner, address(this), _tokens);
+    }
+
+    /// @dev Release stored / escrowed ERC1155, ERC721, ERC20 tokens.
+    function _releaseTokens(address _recipient, uint256 _idForContent) internal {
+        uint256 count = getTokenCountOfBundle(_idForContent);
+        Token[] memory tokensToRelease = new Token[](count);
+
+        for (uint256 i = 0; i < count; i += 1) {
+            tokensToRelease[i] = getTokenOfBundle(_idForContent, i);
+        }
+
+        _deleteBundle(_idForContent);
+
+        _transferTokenBatch(address(this), _recipient, tokensToRelease);
+    }
+
+    /// @dev Transfers an arbitrary ERC20 / ERC721 / ERC1155 token.
+    function _transferToken(address _from, address _to, Token memory _token) internal {
+        if (_token.tokenType == TokenType.ERC20) {
+            CurrencyTransferLib.transferCurrencyWithWrapper(
+                _token.assetContract,
+                _from,
+                _to,
+                _token.totalAmount,
+                nativeTokenWrapper
+            );
+        } else if (_token.tokenType == TokenType.ERC721) {
+            IERC721(_token.assetContract).safeTransferFrom(_from, _to, _token.tokenId);
+        } else if (_token.tokenType == TokenType.ERC1155) {
+            IERC1155(_token.assetContract).safeTransferFrom(_from, _to, _token.tokenId, _token.totalAmount, "");
+        }
+    }
+
+    /// @dev Transfers multiple arbitrary ERC20 / ERC721 / ERC1155 tokens.
+    function _transferTokenBatch(address _from, address _to, Token[] memory _tokens) internal {
+        uint256 nativeTokenValue;
+        for (uint256 i = 0; i < _tokens.length; i += 1) {
+            if (_tokens[i].assetContract == CurrencyTransferLib.NATIVE_TOKEN && _to == address(this)) {
+                nativeTokenValue += _tokens[i].totalAmount;
+            } else {
+                _transferToken(_from, _to, _tokens[i]);
+            }
+        }
+        if (nativeTokenValue != 0) {
+            Token memory _nativeToken = Token({
+                assetContract: CurrencyTransferLib.NATIVE_TOKEN,
+                tokenType: ITokenBundle.TokenType.ERC20,
+                tokenId: 0,
+                totalAmount: nativeTokenValue
+            });
+            _transferToken(_from, _to, _nativeToken);
+        }
+    }
+}

package/contracts/extension/Upgradeable.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../external-deps/openzeppelin/proxy/IERC1822Proxiable.sol";
+import "../external-deps/openzeppelin/proxy/ERC1967/ERC1967Upgrade.sol";
+
+/**
+ * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
+ * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
+ *
+ * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
+ * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
+ * `UUPSUpgradeable` with a custom implementation of upgrades.
+ *
+ * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
+ *
+ * _Available since v4.1._
+ */
+abstract contract Upgradeable is IERC1822Proxiable, ERC1967Upgrade {
+    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
+    address private immutable __self = address(this);
+
+    /**
+     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
+     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
+     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
+     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
+     * fail.
+     */
+    modifier onlyProxy() {
+        require(address(this) != __self, "Function must be called through delegatecall");
+        require(_getImplementation() == __self, "Function must be called through active proxy");
+        _;
+    }
+
+    /**
+     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
+     * callable on the implementing contract but not through proxies.
+     */
+    modifier notDelegated() {
+        require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
+        _;
+    }
+
+    /**
+     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
+     * implementation. It is used to validate that the this implementation remains valid after an upgrade.
+     *
+     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
+     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
+     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
+     */
+    function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
+        return _IMPLEMENTATION_SLOT;
+    }
+
+    /**
+     * @dev Upgrade the implementation of the proxy to `newImplementation`.
+     *
+     * Calls {_authorizeUpgrade}.
+     *
+     * Emits an {Upgraded} event.
+     */
+    function upgradeTo(address newImplementation) external virtual onlyProxy {
+        _authorizeUpgrade(newImplementation);
+        _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
+    }
+
+    /**
+     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
+     * encoded in `data`.
+     *
+     * Calls {_authorizeUpgrade}.
+     *
+     * Emits an {Upgraded} event.
+     */
+    function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
+        _authorizeUpgrade(newImplementation);
+        _upgradeToAndCallUUPS(newImplementation, data, true);
+    }
+
+    /**
+     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
+     * {upgradeTo} and {upgradeToAndCall}.
+     *
+     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
+     *
+     * ```solidity
+     * function _authorizeUpgrade(address) internal override onlyOwner {}
+     * ```
+     */
+    function _authorizeUpgrade(address newImplementation) internal virtual;
+}