@etherisc/gif-next 3.0.0-ab0fcb2-112 → 3.0.0-ab43904-022

package/contracts/staking/StakingService.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.20;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
+import {IRegisterable} from "../shared/IRegisterable.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IStaking} from "./IStaking.sol";
 import {IStakingService} from "./IStakingService.sol";
@@ -58,7 +59,7 @@ contract StakingService is
             initialLockingPeriod,
             initialRewardRate);
 
-        emit LogStakingServiceInstanceTargetRegistered(targetNftId, chainId);
+        emit LogStakingServiceInstanceTargetRegistered(targetNftId, initialLockingPeriod, initialRewardRate);
     }
 
 
@@ -113,7 +114,7 @@ contract StakingService is
 
         // update reward reserve book keeping
         StakingServiceStorage storage $ = _getStakingServiceStorage();
-        address instanceOwner = _getRegistry().ownerOf(instanceNftId);
+        address instanceOwner = getRegistry().ownerOf(instanceNftId);
         newBalance = $._staking.refillRewardReservesByService(instanceNftId, dipAmount, instanceOwner);
 
         emit LogStakingServiceRewardReservesIncreased(instanceNftId, rewardProvider, dipAmount, newBalance);
@@ -130,7 +131,7 @@ contract StakingService is
         _checkNftType(instanceNftId, INSTANCE());
         // update reward reserve book keeping
         StakingServiceStorage storage $ = _getStakingServiceStorage();
-        address instanceOwner = _getRegistry().ownerOf(instanceNftId);
+        address instanceOwner = getRegistry().ownerOf(instanceNftId);
         newBalance = $._staking.withdrawRewardReservesByService(instanceNftId, dipAmount, instanceOwner);
 
         emit LogStakingServiceRewardReservesDecreased(instanceNftId, instanceOwner, dipAmount, newBalance);
@@ -157,14 +158,13 @@ contract StakingService is
                 nftId: NftIdLib.zero(),
                 parentNftId: targetNftId,
                 objectType: STAKE(),
-                release: getRelease(),
                 isInterceptor: false,
-                objectAddress: address(0)}),
-            stakeOwner, // initialOwner
-            "" // data
-        );
+                objectAddress: address(0),
+                initialOwner: stakeOwner,
+                data: ""
+            }));
 
-        emit LogStakingServiceStakeObjectCreated(stakeNftId, targetNftId, stakeOwner);
+        emit LogStakingServiceStakeCreated(stakeNftId, targetNftId, stakeOwner);
     }
 
 
@@ -255,18 +255,18 @@ contract StakingService is
     )
         internal
         virtual override
-        onlyInitializing()
+        initializer()
     {
         (
             address authority,
+            address registry,
             address staking
-        ) = abi.decode(data, (address, address));
+        ) = abi.decode(data, (address, address, address));
 
-        __Service_init(authority, owner);
+        __Service_init(authority, registry, owner);
 
         StakingServiceStorage storage $ = _getStakingServiceStorage();
         $._registryService = RegistryService(_getServiceAddress(REGISTRY()));
-        // TODO staking is registered in registry.initialize(), just check if address is registered staking
         $._staking = _registerStaking(staking);
         $._dip = $._staking.getToken();
         $._tokenHandler = $._staking.getTokenHandler();
@@ -283,7 +283,7 @@ contract StakingService is
     {
         // check if provided staking contract is already registred
         // staking contract may have been already registered by a previous major relase
-        IRegistry.ObjectInfo memory stakingInfo = _getRegistry().getObjectInfo(stakingAddress);
+        IRegistry.ObjectInfo memory stakingInfo = getRegistry().getObjectInfo(stakingAddress);
         if (stakingInfo.nftId.gtz()) {
             // registered object but wrong type
             if (stakingInfo.objectType != STAKING()) {
@@ -294,9 +294,6 @@ contract StakingService is
             return IStaking(stakingAddress);
         }
 
-        // TODO staking is registered in registry.initialize()
-        // consider deleting the rest of the function
-
         // check that contract implements IStaking
         if(!IStaking(stakingAddress).supportsInterface(type(IStaking).interfaceId)) {
             revert ErrorStakingServiceNotSupportingIStaking(stakingAddress);
@@ -304,7 +301,7 @@ contract StakingService is
 
         address owner = msg.sender;
         _getStakingServiceStorage()._registryService.registerStaking(
-            IStaking(stakingAddress),
+            IRegisterable(stakingAddress),
             owner);
 
         return IStaking(stakingAddress);

package/contracts/staking/StakingServiceManager.sol

@@ -2,7 +2,8 @@
 pragma solidity ^0.8.20;
 
 import {IRegistry} from "../registry/IRegistry.sol";
-import {IUpgradeable} from "../upgradeability/IUpgradeable.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+
 import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {StakingService} from "./StakingService.sol";
 
@@ -15,20 +16,23 @@ contract StakingServiceManager is
     /// @dev initializes proxy manager with service implementation 
     constructor(
         address authority,
+        address registry,
         bytes32 salt
     )
     {
         StakingService svc = new StakingService();
         bytes memory data = abi.encode(
             authority, 
-            _getRegistry().getStakingAddress());
+            registry, 
+            IRegistry(registry).getStakingAddress());
 
-        IUpgradeable upgradeable = initialize(
+        IVersionable versionable = initialize(
+            registry,
             address(svc), 
             data,
             salt);
 
-        _stakingService = StakingService(address(upgradeable));
+        _stakingService = StakingService(address(versionable));
     }
 
     //--- view functions ----------------------------------------------------//

package/contracts/staking/StakingStore.sol

@@ -18,7 +18,6 @@ import {PROTOCOL, INSTANCE} from "../type/ObjectType.sol";
 import {Seconds, SecondsLib} from "../type/Seconds.sol";
 import {StakingLib} from "./StakingLib.sol";
 import {StakingReader} from "./StakingReader.sol";
-import {RegistryLinked} from "../shared/RegistryLinked.sol";
 import {TargetManagerLib} from "./TargetManagerLib.sol";
 import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
 import {UFixed, UFixedLib} from "../type/UFixed.sol";
@@ -26,8 +25,7 @@ import {UFixed, UFixedLib} from "../type/UFixed.sol";
 
 contract StakingStore is 
     Initializable,
-    AccessManaged,
-    RegistryLinked
+    AccessManaged
 {
 
     // token
@@ -55,6 +53,7 @@ contract StakingStore is
     error ErrorStakingStoreTvlBalanceAlreadyInitialized(NftId nftId, address token);
     error ErrorStakingStoreTvlBalanceNotInitialized(NftId nftId, address token);
 
+    IRegistry private _registry;
     ITargetLimitHandler private _targetLimitHandler;
     StakingReader private _reader;
     NftIdSet private _targetNftIdSet;
@@ -76,15 +75,16 @@ contract StakingStore is
 
 
     constructor(
+        IRegistry registry, 
         StakingReader reader
     )
         AccessManaged(msg.sender)
     {
-
         // set final authority
-        setAuthority(_getRegistry().getAuthority());
+        setAuthority(registry.getAuthority());
 
         // set internal variables
+        _registry = registry;
         _reader = reader;
         _targetNftIdSet = new NftIdSet();
 
@@ -151,7 +151,7 @@ contract StakingStore is
         address oldReader = address(_reader);
         _reader = StakingReader(reader);
 
-        emit IStaking.LogStakingStakingReaderSet(reader, oldReader);
+        emit IStaking.LogStakingStakingReaderSet(oldReader, reader);
     }
 
 
@@ -162,7 +162,7 @@ contract StakingStore is
         address oldTargetHandler = address(_targetLimitHandler);
         _targetLimitHandler = ITargetLimitHandler(targetLimitHandler );
 
-        emit IStaking.LogStakingTargetHandlerSet(targetLimitHandler , oldTargetHandler);
+        emit IStaking.LogStakingTargetHandlerSet(oldTargetHandler, targetLimitHandler);
     }
 
     //--- target support management -----------------------------------------//
@@ -387,7 +387,7 @@ contract StakingStore is
         targetInfo.lastUpdateIn = BlocknumberLib.current();
 
         // logging
-        emit IStaking.LogStakingTargetRewardRateSet(targetNftId, rewardRate, oldRewardRate, lastUpdateIn);
+        emit IStaking.LogStakingTargetRewardRateSet(targetNftId, oldRewardRate, rewardRate, lastUpdateIn);
     }
 
 
@@ -495,7 +495,7 @@ contract StakingStore is
         emit IStaking.LogStakingRewardReservesRefilled(
             targetNftId,
             dipAmount,
-            _getRegistry().ownerOf(targetNftId),
+            _registry.ownerOf(targetNftId),
             newReserveBalance,
             lastUpdateIn);
     }
@@ -520,7 +520,7 @@ contract StakingStore is
         emit IStaking.LogStakingRewardReservesWithdrawn(
             targetNftId,
             dipAmount,
-            _getRegistry().ownerOf(targetNftId),
+            _registry.ownerOf(targetNftId),
             newReserveBalance,
             lastUpdateIn);
     }
@@ -929,7 +929,7 @@ contract StakingStore is
         // checks
         if (checkParameters) {
             TargetManagerLib.checkTargetParameters(
-                _getRegistry(), 
+                _registry, 
                 _reader, 
                 targetNftId, 
                 objectType, 

package/contracts/staking/TargetHandler.sol

@@ -10,7 +10,6 @@ import {ITargetLimitHandler} from "./ITargetLimitHandler.sol";
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {Blocknumber, BlocknumberLib} from "../type/Blocknumber.sol";
 import {NftId} from "../type/NftId.sol";
-import {RegistryLinked} from "../shared/RegistryLinked.sol";
 import {StakingStore} from "./StakingStore.sol";
 import {UFixed, UFixedLib} from "../type/UFixed.sol";
 
@@ -18,12 +17,12 @@ import {UFixed, UFixedLib} from "../type/UFixed.sol";
 contract TargetHandler is
     Initializable,
     AccessManaged,
-    ITargetLimitHandler,
-    RegistryLinked
+    ITargetLimitHandler
 {
 
-    event LogTargetHandlerUpdateTriggersSet(uint16 tvlUpdatesTrigger, UFixed minTvlRatioTrigger, Blocknumber lastUpdateIn);
+    event LogTargetHandlerUpdateTriggersSet(uint16 indexed tvlUpdatesTrigger, UFixed indexed minTvlRatioTrigger, Blocknumber indexed lastUpdateIn);
 
+    IRegistry private _registry;
     StakingStore private _store;
 
     /// @dev Update trigger value: Number of TVL updates below which limit updates are suppressed
@@ -34,12 +33,14 @@ contract TargetHandler is
 
 
     constructor (
+        IRegistry registry,
         StakingStore stakingStore
     )
         AccessManaged(msg.sender)
     {
         // set final authority and registry
-        setAuthority(_getRegistry().getAuthority());
+        setAuthority(registry.getAuthority());
+        _registry = registry;
         _store = stakingStore;
 
         // set default trigger values

package/contracts/type/Version.sol

@@ -5,9 +5,6 @@ type VersionPart is uint8;
 
 using {
     versionPartGt as >,
-    versionPartGte as >=,
-    versionPartLt as <,
-    versionPartLte as <=,
     versionPartEq as ==,
     versionPartNe as !=,
     VersionPartLib.eqz,
@@ -19,9 +16,6 @@ using {
     for VersionPart global;
 
 function versionPartGt(VersionPart a, VersionPart b) pure returns(bool isGreaterThan) { return VersionPart.unwrap(a) > VersionPart.unwrap(b); }
-function versionPartGte(VersionPart a, VersionPart b) pure returns(bool isGreaterThan) { return VersionPart.unwrap(a) >= VersionPart.unwrap(b); }
-function versionPartLt(VersionPart a, VersionPart b) pure returns(bool isLessThan) { return VersionPart.unwrap(a) < VersionPart.unwrap(b); }
-function versionPartLte(VersionPart a, VersionPart b) pure returns(bool isLessThan) { return VersionPart.unwrap(a) <= VersionPart.unwrap(b); }
 function versionPartEq(VersionPart a, VersionPart b) pure returns(bool isSame) { return VersionPart.unwrap(a) == VersionPart.unwrap(b); }
 function versionPartNe(VersionPart a, VersionPart b) pure returns(bool isSame) { return VersionPart.unwrap(a) != VersionPart.unwrap(b); }
 
@@ -33,7 +27,8 @@ library VersionPartLib {
     function releaseMax() public pure returns (VersionPart) { return toVersionPart(99); }
 
     function isValidRelease(VersionPart release) external pure returns(bool) { 
-        return releaseMin() <= release && release <= releaseMax(); 
+        uint256 releaseInt = VersionPart.unwrap(release);
+        return 3 <= releaseInt && releaseInt <= 99; 
     } 
 
     function toString(VersionPart a) external pure returns (string memory) {
@@ -71,9 +66,8 @@ library VersionPartLib {
 
     function eqz(VersionPart a) external pure returns(bool) { return VersionPart.unwrap(a) == 0; }
     function gtz(VersionPart a) external pure returns(bool) { return VersionPart.unwrap(a) > 0; }
-    function toInt(VersionPart a) external pure returns(uint8) { return VersionPart.unwrap(a); }
-    function toVersionPart(uint8 a) public pure returns(VersionPart) { return VersionPart.wrap(uint8(a)); }
-    function zero() external pure returns(VersionPart) { return VersionPart.wrap(0); }
+    function toInt(VersionPart a) external pure returns(uint256) { return VersionPart.unwrap(a); }
+    function toVersionPart(uint256 a) public pure returns(VersionPart) { return VersionPart.wrap(uint8(a)); }
 }
 
 type Version is uint24; // contains major,minor,patch version parts
@@ -93,7 +87,7 @@ function versionEq(Version a, Version b) pure returns(bool isSame) { return Vers
 
 library VersionLib {
 
-    function toInt(Version version) external pure returns(uint24) { return Version.unwrap(version); }
+    function toInt(Version version) external pure returns(uint) { return Version.unwrap(version); }
 
     function toUint64(Version version) external pure returns(uint64) { return Version.unwrap(version); }
 
@@ -130,19 +124,26 @@ library VersionLib {
         );
     }
 
+    // function toVersionPart(uint256 versionPart) public pure returns(VersionPart) { 
+    //     return VersionPart.wrap(uint8(versionPart)); 
+    // }
+
     function toVersion(
-        uint8 major,
-        uint8 minor,
-        uint8 patch
+        uint256 major,
+        uint256 minor,
+        uint256 patch
     )
         external
         pure
         returns(Version)
     {
+        require(
+            major < 256 && minor < 256 && patch < 256,
+            "ERROR:VRS-010:VERSION_PART_TOO_BIG");
 
         return Version.wrap(
             uint24(
-                (uint24(major) << 16) + (uint24(minor) << 8) + patch));
+                (major << 16) + (minor << 8) + patch));
     }
 
     // TODO check for overflow?

package/contracts/upgradeability/{IUpgradeable.sol → IVersionable.sol}

@@ -1,21 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IVersionable} from "../shared/IVersionable.sol";
+import {Version} from "../type/Version.sol";
 
 /// IMPORTANT
 // Upgradeable contract MUST:
-// 1) inherit Upgradeable
-// 2) implement getVersion() function
+// 1) inherit from Versionable
+// 2) implement version() function
 // 3) implement internal _initialize() function with onlyInitializing modifier 
 // 4) implement internal _upgrade() function with onlyInitializing modifier (1st version MUST revert)
-// 5) have onlyInitialising modifier for each function callable inside _initialize()/_upgrade() 
-// 6) use different functions for initialization, upgrade and normal operations
-// 7) use default empty constructor -> _disableInitializer() is called from Upgradeable contructor
-// 8) use namespace storage (should storage be needed)
+// 5) have onlyInitialising modifier for each function callable inside _initialize()/_upgrade() (MUST use different functions for initialization/upgrade and normal operations)
+// 6) use default empty constructor -> _disableInitializer() is called from Versionable contructor
+// 7) use namespace storage (should this be needed)
+// 8) since now inheritance is used for upgradability, contract MUST BE inherited ONLY by the next version 
 // Upgradeable contract SHOULD:
 // 9) define all non private methods as virtual (in order to be able to upgrade them latter)
-//    otherwise, it is still possible to upgrade contract, but everyone who is using it will have to switch to a new functions
+//    otherwise, it is still possible to upgrade contract, but everyone who is using it will have to switch to a new fucntions
 //    in some cases this ok but not in the others...
 //
 // IMPORTANT
@@ -26,25 +26,31 @@ import {IVersionable} from "../shared/IVersionable.sol";
 // 2) ALWAYS define private getter if accessing storage
 //      - MUST use default implementation, CAN change ONLY return type
 
-interface IUpgradeable is IVersionable {
+interface IVersionable {
 
     error ErrorVersionableInitializeNotImplemented();
     error ErrorVersionableUpgradeNotImplemented();
 
     /**
      * @dev IMPORTANT
-     * top level initializer for each upgradeable
      * implementation MUST be guarded by initializer modifier
      * new version MUST inherit from previous version
      */
-    function initialize(address activatedBy, bytes memory activationData) external;
+    function initializeVersionable(address activatedBy, bytes memory activationData) external;
 
     /**
      * @dev
-     * top level reinitializer for each upgradeable
      * implementation MUST be guarded by reinitializer(version().toUint64()) modifier
      * new version MUST inherit from previous version
      * the first verion MUST revert 
      */
-    function upgrade(bytes memory upgradeData) external;
+    function upgradeVersionable(bytes memory upgradeData) external;
+
+    /**
+     * @dev returns version of this contract
+     * each new implementation MUST implement this function
+     * version number MUST increase 
+     */
+    function getVersion() external pure returns(Version);
+
 }

package/contracts/upgradeability/ProxyManager.sol

@@ -5,14 +5,14 @@ import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.s
 import {ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
 import {Blocknumber, BlocknumberLib} from "../type/Blocknumber.sol";
-import {IUpgradeable} from "./IUpgradeable.sol";
+import {IVersionable} from "./IVersionable.sol";
 import {NftId} from "../type/NftId.sol";
 import {NftOwnable} from "../shared/NftOwnable.sol";
 import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
 import {UpgradableProxyWithAdmin} from "./UpgradableProxyWithAdmin.sol";
-import {Version, VersionPart, VersionLib} from "../type/Version.sol";
+import {Version, VersionLib} from "../type/Version.sol";
 
-/// @dev manages proxy deployments for upgradable contracs of type IUpgradeable
+/// @dev manages proxy deployments for upgradable contracs of type IVersionable
 contract ProxyManager is
     NftOwnable
 {
@@ -27,15 +27,14 @@ contract ProxyManager is
         address activatedBy;
     }
 
-    event LogProxyManagerProxyDeployed(address indexed proxy, address initialImplementation);
-    event LogProxyManagerProxyUpgraded(address indexed proxy, address upgradedImplementation);
+    event LogProxyManagerVersionableDeployed(address indexed proxy, address indexed initialImplementation);
+    event LogProxyManagerVersionableUpgraded(address indexed proxy, address indexed upgradedImplementation);
 
     error ErrorProxyManagerAlreadyDeployed();
     error ErrorProxyManagerNotYetDeployed();
 
     error ErrorProxyManagerZeroVersion();
     error ErrorProxyManagerNextVersionNotIncreasing(Version nextVersion);
-    error ErrorProxyManagerNextVersionReleaseInvalid(Version nextVersion);
 
     UpgradableProxyWithAdmin internal _proxy;
 
@@ -45,19 +44,17 @@ contract ProxyManager is
 
     /// @dev convencience initializer
     function initialize(
+        address registry,
         address implementation,
         bytes memory data,
         bytes32 salt
     )
         public
         initializer()
-        returns (IUpgradeable upgradeable)
+        returns (IVersionable versionable)
     {
-        address initialOwner = msg.sender;
-
-        __NftOwnable_init(initialOwner);
-
-        upgradeable = deployDetermenistic(
+        versionable = deployDetermenistic(
+            registry,
             implementation, 
             data,
             salt);
@@ -65,20 +62,19 @@ contract ProxyManager is
 
     /// @dev deploy initial contract
     function deploy(
+        address registry, 
         address initialImplementation, 
         bytes memory initializationData
     )
         public
         virtual
         onlyInitializing()
-        returns (IUpgradeable upgradeable)
+        returns (IVersionable versionable)
     {
-        if (_versions.length > 0) {
-            revert ErrorProxyManagerAlreadyDeployed();
-        }
-
-        address currentProxyOwner = getOwner(); // used by implementation
-        address initialProxyAdminOwner = address(this); // used by proxy
+        (
+            address currentProxyOwner, 
+            address initialProxyAdminOwner
+        ) = _preDeployChecksAndSetup(registry);
 
         _proxy = new UpgradableProxyWithAdmin(
             initialImplementation,
@@ -86,14 +82,15 @@ contract ProxyManager is
             getDeployData(currentProxyOwner, initializationData)
         );
 
-        upgradeable = _updateVersionHistory(
+        versionable = _updateVersionHistory(
             initialImplementation, 
             currentProxyOwner);
 
-        emit LogProxyManagerProxyDeployed(address(upgradeable), initialImplementation);
+        emit LogProxyManagerVersionableDeployed(address(versionable), initialImplementation);
     }
 
     function deployDetermenistic(
+        address registry, 
         address initialImplementation, 
         bytes memory initializationData, 
         bytes32 salt
@@ -101,14 +98,12 @@ contract ProxyManager is
         public
         virtual
         onlyInitializing()
-        returns (IUpgradeable upgradeable)
+        returns (IVersionable versionable)
     {
-        if (_versions.length > 0) {
-            revert ErrorProxyManagerAlreadyDeployed();
-        }
-
-        address currentProxyOwner = getOwner(); // used by implementation
-        address initialProxyAdminOwner = address(this); // used by proxy
+        (
+            address currentProxyOwner, 
+            address initialProxyAdminOwner
+        ) = _preDeployChecksAndSetup(registry);
 
         _proxy = new UpgradableProxyWithAdmin{salt: salt}(
             initialImplementation,
@@ -116,11 +111,11 @@ contract ProxyManager is
             getDeployData(currentProxyOwner, initializationData)
         );
 
-        upgradeable = _updateVersionHistory(
+        versionable = _updateVersionHistory(
             initialImplementation, 
             currentProxyOwner);
 
-        emit LogProxyManagerProxyDeployed(address(upgradeable), initialImplementation);
+        emit LogProxyManagerVersionableDeployed(address(versionable), initialImplementation);
     }
 
     /// @dev upgrade existing contract.
@@ -129,7 +124,7 @@ contract ProxyManager is
         public
         virtual
         onlyOwner()
-        returns (IUpgradeable upgradeable)
+        returns (IVersionable versionable)
     {
         bytes memory emptyUpgradeData;
         return upgrade(newImplementation, emptyUpgradeData);
@@ -140,7 +135,7 @@ contract ProxyManager is
         public
         virtual
         onlyOwner()
-        returns (IUpgradeable upgradeable)
+        returns (IVersionable versionable)
     {
         if (_versions.length == 0) { 
             revert ErrorProxyManagerNotYetDeployed();
@@ -155,11 +150,11 @@ contract ProxyManager is
             newImplementation, 
             getUpgradeData(upgradeData));
 
-        upgradeable = _updateVersionHistory(
+        versionable = _updateVersionHistory(
             newImplementation, 
             currentProxyOwner);
 
-        emit LogProxyManagerProxyUpgraded(address(upgradeable), newImplementation);
+        emit LogProxyManagerVersionableUpgraded(address(versionable), newImplementation);
 
     }
 
@@ -169,14 +164,14 @@ contract ProxyManager is
 
     function getDeployData(address proxyOwner, bytes memory deployData) public pure returns (bytes memory data) {
         return abi.encodeWithSelector(
-            IUpgradeable.initialize.selector, 
+            IVersionable.initializeVersionable.selector, 
             proxyOwner, 
             deployData);
     }
 
     function getUpgradeData(bytes memory upgradeData) public pure returns (bytes memory data) {
         return abi.encodeWithSelector(
-            IUpgradeable.upgrade.selector, 
+            IVersionable.upgradeVersionable.selector, 
             upgradeData);
     }
 
@@ -185,7 +180,7 @@ contract ProxyManager is
     }
 
     function getVersion() external view virtual returns(Version) {
-        return _versionHistory[_versions[_versions.length]].version;
+        return IVersionable(address(_proxy)).getVersion();
     }
 
     function getVersionCount() external view returns(uint256) {
@@ -200,29 +195,42 @@ contract ProxyManager is
         return _versionHistory[_version];
     }
 
+    function _preDeployChecksAndSetup(address registry)
+        private
+        returns (
+            address currentProxyOwner,
+            address initialProxyAdminOwner
+        )
+    {
+        if (_versions.length > 0) {
+            revert ErrorProxyManagerAlreadyDeployed();
+        }
+
+        address initialOwner = msg.sender;
+        __NftOwnable_init(registry, initialOwner);
+
+        currentProxyOwner = getOwner(); // used by implementation
+        initialProxyAdminOwner = address(this); // used by proxy
+    }
+
     function _updateVersionHistory(
         address implementation,
         address activatedBy
     )
         private
-        returns (IUpgradeable upgradeable)
+        returns (IVersionable versionable)
     {
-        upgradeable = IUpgradeable(address(_proxy));
-        Version newVersion = upgradeable.getVersion();
+        versionable = IVersionable(address(_proxy));
+        Version newVersion = versionable.getVersion();
 
         if(newVersion == VersionLib.zeroVersion()) {
             revert ErrorProxyManagerZeroVersion();
         }
 
         if(_versions.length > 0) {
-            Version version = _versions[_versions.length-1];
-            if(newVersion.toInt() <= version.toInt()) {
+            if(newVersion.toInt() <= _versions[_versions.length-1].toInt()) {
                 revert ErrorProxyManagerNextVersionNotIncreasing(newVersion);
             }
-
-            if(newVersion.toMajorPart() != version.toMajorPart()) {
-                revert ErrorProxyManagerNextVersionReleaseInvalid(newVersion);
-            }
         }
 
         // update version history