@etherisc/gif-next 0.0.2-770fd3b-604 → 0.0.2-77a1ccf-469

package/contracts/registry/ReleaseManager.sol

@@ -41,7 +41,7 @@ contract ReleaseManager is AccessManaged
     error SelfRegistration();
     error RegisterableOwnerIsRegistered();
 
-    // _verifyServiceInfo
+    // _verifyService
     error UnexpectedServiceVersion(VersionPart expected, VersionPart found);
     error UnexpectedServiceDomain(ObjectType expected, ObjectType found);
     
@@ -61,7 +61,7 @@ contract ReleaseManager is AccessManaged
 
     mapping(VersionPart version => IRegistry.ReleaseInfo info) _release;
 
-    mapping(VersionPart version => mapping(ObjectType serviceDomain => bytes4)) _selector; // registry service function selector assigned to domain 
+    mapping(VersionPart version => mapping(ObjectType serviceDomain => bytes4[])) _selectors; // registry service function selector assigned to domain 
 
     uint _awaitingRegistration; // "services left to register" counter
 
@@ -148,12 +148,8 @@ contract ReleaseManager is AccessManaged
 
         VersionPart version = _next;
         ObjectType domain = REGISTRY();
-        _verifyServiceInfo(info, version, domain);
-
-        // data: config bytes
+        _verifyService(service, version, domain);
         _createRelease(service.getFunctionConfigs());
-
-        //setTargetClosed(service, true);
         
         nftId = _registry.registerService(info, version, domain);
 
@@ -175,17 +171,16 @@ contract ReleaseManager is AccessManaged
         IRegistry.ObjectInfo memory info = _getAndVerifyContractInfo(service, SERVICE(), msg.sender);
         VersionPart version = getNextVersion();
         ObjectType domain = _release[version].domains[_awaitingRegistration];// reversed registration order of services specified in RegistryService config
-        _verifyServiceInfo(info, version, domain);
+        _verifyService(service, version, domain);
 
         // setup and grant unique role if service does registrations
-        bytes4[] memory selector = new bytes4[](1);
-        selector[0] = _selector[version][domain];
+        bytes4[] memory selectors = _selectors[version][domain];
         address registryService = _registry.getServiceAddress(REGISTRY(), version);
-        if(selector[0] != 0) {
+        if(selectors.length > 0) {
             _accessManager.setAndGrantUniqueRole(
                 address(service), 
                 registryService, 
-                selector);
+                selectors);
         }
         
         _awaitingRegistration--;
@@ -267,8 +262,8 @@ contract ReleaseManager is AccessManaged
         }
     }
 
-    function _verifyServiceInfo(
-        IRegistry.ObjectInfo memory info,
+    function _verifyService(
+        IService service,
         VersionPart expectedVersion,
         ObjectType expectedDomain
     )
@@ -276,20 +271,15 @@ contract ReleaseManager is AccessManaged
         view
         returns(ObjectType)
     {
-        (
-            ObjectType domain,
-            VersionPart version
-        ) = abi.decode(info.data, (ObjectType, VersionPart));
-
-        if(version != expectedVersion) {
-            revert UnexpectedServiceVersion(expectedVersion, version);
+        if(service.getMajorVersion() != expectedVersion) {
+            revert UnexpectedServiceVersion(expectedVersion, service.getMajorVersion());
         }
 
-        if(domain != expectedDomain) {
-            revert UnexpectedServiceDomain(expectedDomain, domain);
+        if(service.getDomain() != expectedDomain) {
+            revert UnexpectedServiceDomain(expectedDomain, service.getDomain());
         }
 
-        return domain;
+        return expectedDomain;
     }
 
     // TODO check if registry supports types specified in the config array
@@ -306,21 +296,21 @@ contract ReleaseManager is AccessManaged
         for(uint idx = 0; idx < config.length; idx++)
         {
             ObjectType domain = config[idx].serviceDomain;
-            bytes4 selector = config[idx].selector;
-
             // not "registry service" / zero domain
             if(
                 domain == REGISTRY() ||
                 domain.eqz()
             ) { revert ConfigServiceDomainInvalid(idx, domain); } 
 
+            bytes4[] memory selectors = config[idx].selectors;
+
             // TODO can be zero -> e.g. duplicate domain, first with zero selector, second with non zero selector -> need to check _release[version].domains.contains(domain) instead
             // no overwrite
-            if(_selector[version][domain] > 0) {
+            if(_selectors[version][domain].length > 0) {
                 revert SelectorAlreadyExists(version, domain); 
             }
             
-            _selector[version][domain] = selector;
+            _selectors[version][domain] = selectors;
             _release[version].domains.push(domain);
         }
         // TODO set when activated?

package/contracts/registry/TokenRegistry.sol

@@ -26,9 +26,18 @@ contract TokenRegistry is
     mapping(address token => bool registered) internal _registered;
     mapping(address token => mapping(VersionPart majorVersion => bool isActive)) internal _active;
 
-    constructor()
+    constructor(
+        address registry
+    )
     { 
-        initializeOwner(msg.sender);
+        initialize(registry);
+    }
+
+    function initialize(address registry)
+        public
+        initializer()
+    {
+        initializeNftOwnable(msg.sender, registry);
     }
 
 
@@ -41,9 +50,8 @@ contract TokenRegistry is
         IRegistry registry = IRegistry(registryAddress);
         // TODO use _latest instead of _initial -> but _latest is 0 before first release activation
         address registryServiceAddress = registry.getServiceAddress(REGISTRY(), registry.getNextVersion());
-        //address registryServiceAddress = registry.getServiceAddress(REGISTRY(), registry.getInitialVersion());
 
-        _linkToNftOwnable(registryAddress, registryServiceAddress);
+        _linkToNftOwnable(registryServiceAddress);
     }
 
     /// @dev token state is informative, registry have no clue about used tokens
@@ -94,12 +102,7 @@ contract TokenRegistry is
             revert NotContract(token);
         }
 
-        // MUST not be GIF registerable
-        if(ERC165Checker.supportsInterface(token, type(IRegisterable).interfaceId)) {
-            revert NotToken(token);
-        }
-
-        // MUST have decimals > 0
+        // MUST have decimals > 0 (indicator that this is in fact an erc20 token)
         IERC20Metadata erc20 = IERC20Metadata(token);
         if(erc20.decimals() == 0) {
             revert TokenDecimalsZero();

package/contracts/shared/ERC165.sol

@@ -10,12 +10,13 @@ contract ERC165 is
 {
     mapping(bytes4 => bool) private _isSupported;
 
-    // @dev register support for ERC165 itself
+    // @dev initializes with support for ERC165
     function initializeERC165() public onlyInitializing() {
         _isSupported[type(IERC165).interfaceId] = true;
     }
 
     // @dev register support for provided interfaceId
+    // includes initialization for ERC165_ID if not yet done
     function registerInterface(bytes4 interfaceId) public onlyInitializing() {
         _isSupported[interfaceId] = true;
     }

package/contracts/shared/INftOwnable.sol

@@ -3,7 +3,6 @@ pragma solidity ^0.8.20;
 
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
-import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryLinked} from "./IRegistryLinked.sol";
 import {NftId} from "../types/NftId.sol";
 
@@ -11,15 +10,11 @@ interface INftOwnable is
     IERC165,
     IRegistryLinked
 {
-    error ErrorInitialOwnerZero();
-    error ErrorNotOwner(address account);
+    error ErrorNftOwnableInitialOwnerZero();
+    error ErrorNftOwnableNotOwner(address account);
 
-    error ErrorAlreadyLinked(address registry, NftId nftId);
-    // error ErrorRegistryAlreadyInitialized(address registry);
-    // error ErrorRegistryNotInitialized();
-    // error ErrorRegistryAddressZero();
-    // error ErrorNotRegistry(address registryAddress);
-    error ErrorContractNotRegistered(address contractAddress);
+    error ErrorNftOwnableAlreadyLinked(NftId nftId);
+    error ErrorNftOwnableContractNotRegistered(address contractAddress);
 
     function linkToRegisteredNftId() external;
 

package/contracts/shared/IRegistryLinked.sol

@@ -5,9 +5,6 @@ import {IRegistry} from "../registry/IRegistry.sol";
 
 interface IRegistryLinked {
 
-    error ErrorRegistryAlreadyInitialized(address registry);
-    error ErrorRegistryNotInitialized();
-    error ErrorRegistryAddressZero();
     error ErrorNotRegistry(address registryAddress);
 
     function getRegistry() external view returns (IRegistry);

package/contracts/shared/IService.sol

@@ -11,6 +11,8 @@ interface IService is
     IRegisterable,
     IVersionable
 {
+    error ErrorIServiceCallerUnknown(address caller);
+    
     function getDomain() external pure returns(ObjectType serviceDomain);
     function getMajorVersion() external view returns(VersionPart majorVersion);
 }

package/contracts/shared/IVersionable.sol

@@ -1,11 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Blocknumber} from "../types/Blocknumber.sol";
-import {Timestamp} from "../types/Timestamp.sol";
 import {Version} from "../types/Version.sol";
 
-
 /// IMPORTANT
 // Upgradeable contract MUST:
 // 1) inherit from Versionable
@@ -14,7 +11,7 @@ import {Version} from "../types/Version.sol";
 // 4) implement internal _upgrade() function with onlyInitializing modifier (1st version MUST revert)
 // 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
+// 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)
@@ -22,48 +19,29 @@ import {Version} from "../types/Version.sol";
 //    in some cases this ok but not in the others...
 //
 // IMPORTANT
-// Each version MUST:
+// If introducting/amending storage related to Versionable version MUST:
 // 1) define namespace storage struct if accessing storage
 //      - DO NOT use structs inside, except
 //      - CAN use structs ONLY inside mappings
 // 2) ALWAYS define private getter if accessing storage
 //      - MUST use default implementation, CAN change ONLY return type
-//      - MUST use the same "LOCATION_V1"
 
 interface IVersionable {
 
-    struct VersionInfo {
-        Version version;
-        address implementation;
-        address activatedBy;
-        Timestamp activatedAt;
-        Blocknumber activatedIn;
-    }
-
-    event LogVersionableInitialized(Version version, address implementation, address activatedBy);
-
-    // TODO uncomment when all implementations are ready
     /**
      * @dev IMPORTANT
      * implementation MUST be guarded by initializer modifier
-     * implementation MUST call internal function Versionable._updateVersionHistory 
      * new version MUST inherit from previous version
      */
-    function initializeVersionable(address implementation, address activatedBy, bytes memory activationData) external;
+    function initializeVersionable(address activatedBy, bytes memory activationData) external;
 
     /**
      * @dev
      * implementation MUST be guarded by reinitializer(version().toUint64()) modifier
-     * implementation MUST call internal function Versionable._updateVersionHistory
      * new version MUST inherit from previous version
      * the first verion MUST revert 
      */
-    function upgradeVersionable(address implementation, address activatedBy, bytes memory upgradeData) external;
-
-    /**
-     * @dev returns true if the specified version has been activated for the current contract
-     */
-    function isInitialized(Version version) external view returns(bool);
+    function upgradeVersionable(bytes memory upgradeData) external;
 
     /**
      * @dev returns version of this contract
@@ -72,25 +50,4 @@ interface IVersionable {
      */
     function getVersion() external pure returns(Version);
 
-    /**
-     * @dev returns the number of all deployed versions of this contract
-     */
-    function getVersionCount() external view returns(uint256 numberOfVersions);
-
-    /**
-     * @dev returns the i-th (index) version of this contract
-     */
-    function getVersion(uint256 index) external view returns(Version version);
-
-    /**
-     * @dev returns the i-th (index) version info of this contract
-     */
-    function getVersionInfo(Version version) external view returns(VersionInfo memory versionInfo);
-
-    // TODO make sure it is needed here
-    /**
-     * @dev returns currently active version
-     */
-    function getInitializedVersion() external view returns(uint64);
-
 }

package/contracts/shared/NftOwnable.sol

@@ -5,8 +5,7 @@ pragma solidity ^0.8.20;
 
 import {ERC165} from "./ERC165.sol";
 import {INftOwnable} from "./INftOwnable.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId, zeroNftId} from "../types/NftId.sol";
+import {NftId} from "../types/NftId.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
 
 contract NftOwnable is
@@ -18,7 +17,6 @@ contract NftOwnable is
     bytes32 public constant NFT_OWNABLE_STORAGE_LOCATION_V1 = 0x07ebcf49758b6ed3af50fa146bec0abe157c0218fe65dc0874c286e9d5da4f00;
 
     struct NftOwnableStorage {
-        // IRegistry _registry;
         NftId _nftId;
         address _initialOwner; 
     }
@@ -26,7 +24,7 @@ contract NftOwnable is
     /// @dev enforces msg.sender is owner of nft (or initial owner of nft ownable)
     modifier onlyOwner() {
         if (msg.sender != getOwner()) {
-            revert ErrorNotOwner(msg.sender);
+            revert ErrorNftOwnableNotOwner(msg.sender);
         }
         _;
     }
@@ -42,21 +40,14 @@ contract NftOwnable is
         virtual
         onlyInitializing()
     {
-        _setInitialOwner(initialOwner);
-
         initializeRegistryLinked(registryAddress);
         initializeERC165();
-        registerInterface(type(INftOwnable).interfaceId);
-    }
 
+        if(initialOwner == address(0)) {
+            revert ErrorNftOwnableInitialOwnerZero();
+        }
 
-    function initializeOwner(address initialOwner)
-        public
-        initializer()
-    {
-        _setInitialOwner(initialOwner);
-        initializeERC165();
-        registerInterface(type(INftOwnable).interfaceId);
+        _getNftOwnableStorage()._initialOwner = initialOwner;
     }
 
 
@@ -71,35 +62,22 @@ contract NftOwnable is
         NftOwnableStorage storage $ = _getNftOwnableStorage();
 
         if ($._nftId.gtz()) {
-            revert ErrorAlreadyLinked(address(getRegistry()), $._nftId);
-        }
-
-        if (address(getRegistry()) == address(0)) {
-            revert ErrorRegistryNotInitialized();
+            revert ErrorNftOwnableAlreadyLinked($._nftId);
         }
 
         address contractAddress = address(this);
 
         if (!getRegistry().isRegistered(contractAddress)) {
-            revert ErrorContractNotRegistered(contractAddress);
+            revert ErrorNftOwnableContractNotRegistered(contractAddress);
         }
 
         $._nftId = getRegistry().getNftId(contractAddress);
     }
 
-
-    // function getRegistry() public view virtual override returns (IRegistry) {
-    //     return _getNftOwnableStorage()._registry;
-    // }
-
     function getNftId() public view virtual override returns (NftId) {
         return _getNftOwnableStorage()._nftId;
     }
 
-    function getInitialOwner() public view returns (address) {
-        return _getNftOwnableStorage()._initialOwner;
-    }
-
     function getOwner() public view virtual override returns (address) {
         NftOwnableStorage storage $ = _getNftOwnableStorage();
 
@@ -110,41 +88,22 @@ contract NftOwnable is
         return $._initialOwner;
     }
 
-    /// @dev set initialOwner
-    /// initial owner may only be set during initialization
-    function _setInitialOwner(address initialOwner)
-        internal
-        virtual
-        onlyInitializing()
-    {
-        if(initialOwner == address(0)) {
-            revert ErrorInitialOwnerZero();
-        }
-
-        _getNftOwnableStorage()._initialOwner = initialOwner;
-    }
-
-    // TODO check if function can be refactored to work with a registry address set in an initializer
     /// @dev used in constructor of registry service manager
     // links ownership of registry service manager ot nft owner of registry service
     function _linkToNftOwnable(
-        address registryAddress,
         address nftOwnableAddress
     )
         internal
-        onlyOwner()
         returns (NftId)
     {
         NftOwnableStorage storage $ = _getNftOwnableStorage();
 
         if ($._nftId.gtz()) {
-            revert ErrorAlreadyLinked(address(getRegistry()), $._nftId);
+            revert ErrorNftOwnableAlreadyLinked($._nftId);
         }
 
-        _setRegistry(registryAddress);
-
         if (!getRegistry().isRegistered(nftOwnableAddress)) {
-            revert ErrorContractNotRegistered(nftOwnableAddress);
+            revert ErrorNftOwnableContractNotRegistered(nftOwnableAddress);
         }
 
         $._nftId = getRegistry().getNftId(nftOwnableAddress);
@@ -153,35 +112,6 @@ contract NftOwnable is
     }
 
 
-    // function _setRegistry(address registryAddress)
-    //     private
-    // {
-    //     NftOwnableStorage storage $ = _getNftOwnableStorage();
-
-    //     if (address($._registry) != address(0)) {
-    //         revert ErrorRegistryAlreadyInitialized(address($._registry));
-    //     }
-
-    //     if (registryAddress == address(0)) {
-    //         revert ErrorRegistryAddressZero();
-    //     }
-
-    //     if (registryAddress.code.length == 0) {
-    //         revert ErrorNotRegistry(registryAddress);
-    //     }
-
-    //     $._registry = IRegistry(registryAddress);
-
-    //     try $._registry.supportsInterface(type(IRegistry).interfaceId) returns (bool isRegistry) {
-    //         if (!isRegistry) {
-    //             revert ErrorNotRegistry(registryAddress);
-    //         }
-    //     } catch {
-    //         revert ErrorNotRegistry(registryAddress);
-    //     }
-    // }
-
-
     function _getNftOwnableStorage() private pure returns (NftOwnableStorage storage $) {
         assembly {
             $.slot := NFT_OWNABLE_STORAGE_LOCATION_V1

package/contracts/shared/ProxyManager.sol

@@ -1,34 +1,56 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
-import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
 import {ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
+import {Blocknumber, blockNumber} from "../types/Blocknumber.sol";
 import {IVersionable} from "./IVersionable.sol";
 import {NftOwnable} from "./NftOwnable.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import {Timestamp, TimestampLib} from "../types/Timestamp.sol";
 import {UpgradableProxyWithAdmin} from "./UpgradableProxyWithAdmin.sol";
+import {Version, VersionLib} from "../types/Version.sol";
 
 /// @dev manages proxy deployments for upgradable contracs of type IVersionable
 contract ProxyManager is
     NftOwnable
 {
 
-    event LogProxyDeployed(address indexed proxy, address initialImplementation);
-    event LogProxyDeployedWithSalt(address indexed proxy, address initialImplementation);
-    event LogProxyUpgraded(address indexed proxy, address upgradedImplementation);
+    struct VersionInfo {
+        Version version;
+        address implementation;
+        address activatedBy;
+        Timestamp activatedAt;
+        Blocknumber activatedIn;
+    }
+
+    event LogProxyManagerVersionableDeployed(address indexed proxy, address initialImplementation);
+    event LogProxyManagerVersionableUpgraded(address indexed proxy, address upgradedImplementation);
 
-    error ErrorAlreadyDeployed();
-    error ErrorAlreadyDeployedWithSalt();
-    error ErrorNotYetDeployed();
+    error ErrorProxyManagerAlreadyDeployed();
+    error ErrorProxyManagerNotYetDeployed();
+
+    error ErrorProxyManagerZeroVersion();
+    error ErrorProxyManagerNextVersionNotIncreasing(Version nextVersion);
 
     UpgradableProxyWithAdmin internal _proxy;
-    bool internal _isDeployed;
+
+    // state to keep version history
+    mapping(Version version => VersionInfo info) _versionHistory;
+    Version [] _versions;
 
     /// @dev only used to capture proxy owner
-    constructor()
+    constructor(address registry)
     { 
-        initializeOwner(msg.sender);
+        initializeProxyManager(registry);
+    }
+
+    function initializeProxyManager(address registry)
+        public
+        initializer()
+    {
+        initializeNftOwnable(msg.sender, registry);
     }
 
     /// @dev deploy initial contract
@@ -38,22 +60,23 @@ contract ProxyManager is
         onlyOwner()
         returns (IVersionable versionable)
     {
-        if (_isDeployed) { revert ErrorAlreadyDeployed(); }
-        _isDeployed = true;
+        if (_versions.length > 0) {
+            revert ErrorProxyManagerAlreadyDeployed();
+        }
 
         address currentProxyOwner = getOwner(); // used by implementation
         address initialProxyAdminOwner = address(this); // used by proxy
-        bytes memory data = getDeployData(initialImplementation, currentProxyOwner, initializationData);
         
         _proxy = new UpgradableProxyWithAdmin(
             initialImplementation,
             initialProxyAdminOwner,
-            data
+            getDeployData(currentProxyOwner, initializationData)
         );
 
         versionable = IVersionable(address(_proxy));
+        _updateVersionHistory(versionable.getVersion(), initialImplementation, currentProxyOwner);
 
-        emit LogProxyDeployed(address(_proxy), initialImplementation);
+        emit LogProxyManagerVersionableDeployed(address(_proxy), initialImplementation);
     }
 
     /// @dev upgrade existing contract
@@ -63,33 +86,84 @@ contract ProxyManager is
         onlyOwner()
         returns (IVersionable versionable)
     {
-        if (!_isDeployed) { revert ErrorNotYetDeployed(); }
+        if (_versions.length == 0) { 
+            revert ErrorProxyManagerNotYetDeployed();
+        }
 
         address currentProxyOwner = getOwner();
         ProxyAdmin proxyAdmin = getProxy().getProxyAdmin();
         ITransparentUpgradeableProxy proxy = ITransparentUpgradeableProxy(address(_proxy));
-        bytes memory data = getUpgradeData(newImplementation, currentProxyOwner, upgradeData);
 
         proxyAdmin.upgradeAndCall(
             proxy,
             newImplementation, 
-            data);
+            getUpgradeData(upgradeData));
 
         versionable = IVersionable(address(_proxy));
+        _updateVersionHistory(versionable.getVersion(), newImplementation, currentProxyOwner);
 
-        emit LogProxyUpgraded(address(_proxy), newImplementation);
+        emit LogProxyManagerVersionableUpgraded(address(_proxy), newImplementation);
 
     }
 
-    function getDeployData(address implementation, address proxyOwner, bytes memory deployData) public pure returns (bytes memory data) {
-        return abi.encodeWithSelector(IVersionable.initializeVersionable.selector, implementation, proxyOwner, deployData);
+    function getDeployData(address proxyOwner, bytes memory deployData) public pure returns (bytes memory data) {
+        return abi.encodeWithSelector(
+            IVersionable.initializeVersionable.selector, 
+            proxyOwner, 
+            deployData);
     }
 
-    function getUpgradeData(address implementation, address proxyOwner, bytes memory upgradeData) public pure returns (bytes memory data) {
-        return abi.encodeWithSelector(IVersionable.upgradeVersionable.selector, implementation, proxyOwner, upgradeData);
+    function getUpgradeData(bytes memory upgradeData) public pure returns (bytes memory data) {
+        return abi.encodeWithSelector(
+            IVersionable.upgradeVersionable.selector, 
+            upgradeData);
     }
 
     function getProxy() public returns (UpgradableProxyWithAdmin) {
         return _proxy;
     }
+
+    function getVersion() external view virtual returns(Version) {
+        return IVersionable(address(_proxy)).getVersion();
+    }
+
+    function getVersionCount() external view returns(uint256) {
+        return _versions.length;
+    }
+
+    function getVersion(uint256 idx) external view returns(Version) {
+        return _versions[idx];
+    }
+
+    function getVersionInfo(Version _version) external view returns(VersionInfo memory) {
+        return _versionHistory[_version];
+    }
+
+    function _updateVersionHistory(
+        Version newVersion,
+        address implementation,
+        address activatedBy
+    )
+        private
+    {
+        if(newVersion == VersionLib.zeroVersion()) {
+            revert ErrorProxyManagerZeroVersion();
+        }
+
+        if(_versions.length > 0) {
+            if(newVersion.toInt() <= _versions[_versions.length-1].toInt()) {
+                revert ErrorProxyManagerNextVersionNotIncreasing(newVersion);
+            }
+        }
+
+        // update version history
+        _versions.push(newVersion);
+        _versionHistory[newVersion] = VersionInfo(
+            newVersion,
+            implementation,
+            activatedBy,
+            TimestampLib.blockTimestamp(),
+            blockNumber()
+        );
+    }
 }