@etherisc/gif-next 0.0.2-92c50c2-136 → 0.0.2-9306579-093

package/contracts/type/RoleId.sol

@@ -19,6 +19,16 @@ using {
 
 // general pure free functions
 
+// @dev Returns true iff role ids a and b are identical
+function eqRoleId(RoleId a, RoleId b) pure returns (bool isSame) {
+    return RoleId.unwrap(a) == RoleId.unwrap(b);
+}
+
+// @dev Returns true iff role ids a and b are different
+function neRoleId(RoleId a, RoleId b) pure returns (bool isDifferent) {
+    return RoleId.unwrap(a) != RoleId.unwrap(b);
+}
+
 //--- OpenZeppelin provided roles -------------------------------------------//
 
 /// @dev Role ID needs to match with oz AccessManager.ADMIN_ROLE
@@ -27,30 +37,22 @@ function ADMIN_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(type(uin
 /// @dev Role ID needs to match with oz AccessManager.PUBLIC_ROLE
 function PUBLIC_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(type(uint64).max); }
 
-/// @dev Default access admin (registry admin, instance admin) role with rights to manage roles
-function MANAGER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1); } 
-
-//--- Core GIF roles (range: 1-99) ------------------------------------------//
+//--- GIF roles (range: 1-99) ----------------------------------------------//
 
 /// @dev cental role for gif release management.
 /// this role is necessary to call ReleaseManager.createNextRelease/activateNextRelease
 /// the actual deployment of a release requires the GIF_MANAGER_ROLE.
 /// GIF_ADMIN_ROLE is the admin of the GIF_MANAGER_ROLE.
 /// only a single holder may hold this role at any time
-function GIF_ADMIN_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2); } 
+function GIF_ADMIN_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1); } 
 
 /// @dev role for token whith/blacklisting, deploying and registering the services for a new major release
 /// registering services for a new major release is only possible after a new initial release has been created by the GIF_ADMIN_ROLE
 /// token white/blacklisting is possible for any active release
-function GIF_MANAGER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(3); } 
+function GIF_MANAGER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2); } 
 
 /// @dev role for registering remote staking targets and reporting remote total value locked amounts.
-function GIF_REMOTE_MANAGER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(4); } 
-
-/// @dev required role to own an instance.
-/// Role is granted by instance service when cloning a new instance.
-/// allows instance specific target, role and access management 
-function INSTANCE_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(10); }
+function GIF_REMOTE_MANAGER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(3); } 
 
 /// @dev instance specific  role to register/own a product component
 function PRODUCT_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(11); }
@@ -64,119 +66,90 @@ function DISTRIBUTION_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRo
 /// @dev instance specific  role to register/own a pool component
 function POOL_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(14); }
 
-//--- GIF contract roles (range: 200 - 9900) --------------------------------//
+//--- GIF core contract roles (range: 200 - 9'900) --------------------------//
 // created and assigned during initial deployment for registry and staking
 // granting for instances and components in instance service
 // object type * 100 + 0, examples:
 // - registry contract role: 200 
 // - staking contract role: 300 
 // - instance contract role: 1000
-// - product contract role: 1200
 
-//--- GIF service roles (range 201 - 99xx) ----------------------------------//
+//--- GIF service roles (range 201 - 9'9xx) ---------------------------------//
 // created and assigned by release manager contract
 // object type * 100 + 1/major version, examples:
-// - registry service role (any version): 201
+// - registry service role (any version): 299
 // - registry service role (version 3): 203
-// - registry service role (any version): 301
+// - registry service role (any version): 399
 // - staking service role: (version 3): 303
 // - application service role (version 3): 2003
 
-//--- Custom roles (range > 10000) ------------------------------------------//
-
-/// @dev role associated with the staking contract
-/// this role is the admin role for the INSTANCE_OWNER_ROLE
-function STAKING_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1313); }
-
-/// @dev role associated with an instance contract
-/// this role is the admin role for the INSTANCE_OWNER_ROLE
-function INSTANCE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2600); }
-
-function REGISTRY_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1800); }
-
-/// @dev instance specific role for instance service
-function INSTANCE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2000); }
-
-/// @dev role for creating gif target on instance service
-function CAN_CREATE_GIF_TARGET__ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1700); }
-
-/// @dev role for registering gif components
-function COMPONENT_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2001); }
-
-/// @dev instance specific role for distribution service
-function DISTRIBUTION_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2100); }
-
-/// @dev instance specific role for oracle service
-function ORACLE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2150); }
-
-/// @dev instance specific role for pool service
-function POOL_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2200); }
-
-/// @dev instance specific role for product service
-function PRODUCT_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2300); }
+//--- GIF component contract roles (range 12'001 - 19'099) ------------------//
+// assigned at component registration time
+// object type * 1000 + instane specific component counter
+// on any instance a maximum number of 999 components may be deployed
+// examples:
+// - 1st pool on instance: 15001
+// - 1st distribution on instance: 14002
+// - 1st product on instance: 12003
+// - 2nd pool on instance: 15004
+// - 2nd distribution on instance: 14005
+// - 2nd product on instance: 12006
 
-/// @dev instance specific role for application service
-function APPLICATION_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2400); }
 
-/// @dev instance specific role for policy service
-function POLICY_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2410); }
+//--- Custom roles (range >= 1'000'000) -------------------------------------//
 
-/// @dev instance specific role for claim service
-function CLAIM_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2420); }
+function CUSTOM_ROLE_MIN() pure returns (RoleId) { return RoleIdLib.toRoleId(1000000); }
 
-/// @dev instance specific role for bundle service
-function BUNDLE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2500); }
-
-/// @dev instance specific role for pricing service
-function PRICING_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2800); }
+library RoleIdLib {
 
-/// @dev instance specific role for staking service
-function STAKING_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2900); }
+    uint64 public constant ALL_VERSIONS = 99;
+    uint64 public constant SERVICE_DOMAIN_ROLE_FACTOR = 100;
+    uint64 public constant COMPONENT_ROLE_FACTOR = 100;
+    uint64 public constant CUSTOM_ROLE_MIN = 1000000;
 
-// @dev Returns true iff role ids a and b are identical
-function eqRoleId(RoleId a, RoleId b) pure returns (bool isSame) {
-    return RoleId.unwrap(a) == RoleId.unwrap(b);
-}
-
-// @dev Returns true iff role ids a and b are different
-function neRoleId(RoleId a, RoleId b) pure returns (bool isDifferent) {
-    return RoleId.unwrap(a) != RoleId.unwrap(b);
-}
-
-library RoleIdLib {
-/// @dev Converts the RoleId to a uint.
+    /// @dev Converts the RoleId to a uint.
     function zero() public pure returns (RoleId) {
         return RoleId.wrap(0);
     }
 
-    /// @dev Converts an uint into a RoleId.
-    function toRoleId(uint256 a) public pure returns (RoleId) {
-        return RoleId.wrap(uint64(a));
+    /// @dev Converts an uint into a role id.
+    function toRoleId(uint64 a) public pure returns (RoleId) {
+        return RoleId.wrap(a);
     }
 
-    /// @dev Converts the RoleId to a uint.
+    /// @dev Converts an uint into a component role id.
+    function toComponentRoleId(ObjectType objectType, uint64 index) public pure returns (RoleId) {
+        return toRoleId(COMPONENT_ROLE_FACTOR * uint64(objectType.toInt()) + index);
+    }
+
+    /// @dev Converts an uint into a custom role id.
+    function toCustomRoleId(uint64 index) public pure returns (RoleId) {
+        return toRoleId(CUSTOM_ROLE_MIN + index);
+    }
+
+    /// @dev Converts the role id to a uint.
     function toInt(RoleId a) public pure returns (uint64) {
         return uint64(RoleId.unwrap(a));
     }
 
-    /// @dev Converts an uint into a RoleId.
+    /// @dev Converts an uint into a role id.
     /// Used for GIF core contracts.
     function roleForType(ObjectType objectType) public pure returns (RoleId) {
-        return RoleId.wrap(100 * uint64(objectType.toInt()));
+        return RoleId.wrap(SERVICE_DOMAIN_ROLE_FACTOR * uint64(objectType.toInt()));
     }
 
     /// @dev Converts an uint into a RoleId.
     /// Used for GIF core contracts.
     function roleForTypeAndVersion(ObjectType objectType, VersionPart majorVersion) public pure returns (RoleId) {
         return RoleId.wrap(
-            uint64(100 * objectType.toInt() + majorVersion.toInt()));
+            uint64(SERVICE_DOMAIN_ROLE_FACTOR * objectType.toInt() + majorVersion.toInt()));
     }
 
     /// @dev Converts an uint into a RoleId.
     /// Used for GIF core contracts.
     function roleForTypeAndAllVersions(ObjectType objectType) public pure returns (RoleId) {
         return RoleId.wrap(
-            uint64(100 * objectType.toInt() + 99));
+            uint64(SERVICE_DOMAIN_ROLE_FACTOR * objectType.toInt() + ALL_VERSIONS));
     }
 
     /// @dev Returns true if the value is non-zero (> 0).

package/contracts/type/Seconds.sol

@@ -6,9 +6,14 @@ type Seconds is uint40;
 using {
     SecondsEq as ==,
     SecondsGt as >,
+    SecondsAdd as +,
     SecondsLib.eqz,
     SecondsLib.gtz,
-    SecondsLib.toInt
+    SecondsLib.eq,
+    SecondsLib.gt,
+    SecondsLib.lt,
+    SecondsLib.toInt,
+    SecondsLib.add
 } for Seconds global;
 
 function SecondsEq(Seconds duration1, Seconds duration2) pure returns (bool) {
@@ -19,6 +24,11 @@ function SecondsGt(Seconds duration1, Seconds duration2) pure returns (bool) {
     return SecondsLib.gt(duration1, duration2);
 }
 
+function SecondsAdd(Seconds duration1, Seconds duration2) pure returns (Seconds) {
+    return SecondsLib.add(duration1, duration2);
+}
+
+
 library SecondsLib {
 
     error ErrorSecondsLibDurationTooBig(uint256 duration);
@@ -70,6 +80,16 @@ library SecondsLib {
         return Seconds.unwrap(duration1) > Seconds.unwrap(duration2);
     }
 
+    /// @dev return true if duration1 is smaller than duration2
+    function lt(Seconds duration1, Seconds duration2) public pure returns (bool) {
+        return Seconds.unwrap(duration1) < Seconds.unwrap(duration2);
+    }
+
+    /// @dev return add duration1 and duration2
+    function add(Seconds duration1, Seconds duration2) public pure returns (Seconds) {
+        return Seconds.wrap(Seconds.unwrap(duration1) + Seconds.unwrap(duration2));
+    }
+
     function toInt(Seconds duration) public pure returns (uint256) {
         return uint256(uint40(Seconds.unwrap(duration)));
     }

package/contracts/type/StateId.sol

@@ -9,6 +9,7 @@ using {
     eqStateId as ==, 
     neStateId as !=, 
     StateIdLib.eqz,
+    StateIdLib.eq,
     StateIdLib.gtz,
     StateIdLib.toInt
 } for StateId global;

package/contracts/type/Timestamp.sol

@@ -12,6 +12,12 @@ using {
     lteTimestamp as <=,
     eqTimestamp as ==,
     neTimestamp as !=,
+    TimestampLib.eq,
+    TimestampLib.ne,
+    TimestampLib.gt,
+    TimestampLib.gte,
+    TimestampLib.lt,
+    TimestampLib.lte,
     TimestampLib.gtz,
     TimestampLib.eqz,
     TimestampLib.addSeconds,
@@ -50,7 +56,7 @@ function neTimestamp(Timestamp a, Timestamp b) pure returns (bool) {
 
 /// @dev Converts the uint256 to a Timestamp.
 function toTimestamp(uint256 timestamp) pure returns (Timestamp) {
-    return Timestamp.wrap(uint40(timestamp));
+    return TimestampLib.toTimestamp(timestamp);
 }
 
 // TODO move to TimestampLib and rename to zero()
@@ -72,6 +78,10 @@ library TimestampLib {
     function blockTimestamp() public view returns (Timestamp) {
         return Timestamp.wrap(uint40(block.timestamp));
     }
+
+    function toTimestamp(uint256 timestamp) public pure returns (Timestamp) {
+        return Timestamp.wrap(uint40(timestamp));
+    }
     
     /// @dev return true if Timestamp a is after Timestamp b
     function gt(Timestamp a, Timestamp b) public pure returns (bool isAfter) {

package/contracts/type/UFixed.sol

@@ -15,8 +15,10 @@ using {
     lteUFixed as <=,
     eqUFixed as ==,
     neUFixed as !=,
+    UFixedLib.gt,
+    UFixedLib.gtz,
     UFixedLib.toInt,
-    UFixedLib.gtz
+    UFixedLib.toInt1000
 } for UFixed global;
 
 // TODO move to UFixedLib and rename to zero()
@@ -29,7 +31,9 @@ function addUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 }
 
 function subUFixed(UFixed a, UFixed b) pure returns (UFixed) {
-    require(a >= b, "ERROR:UFM-010:NEGATIVE_RESULT");
+    if (a < b) {
+        revert UFixedLib.UFixedLibNegativeResult();
+    }
     return UFixed.wrap(UFixed.unwrap(a) - UFixed.unwrap(b));
 }
 
@@ -39,8 +43,10 @@ function mulUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 }
 
 function divUFixed(UFixed a, UFixed b) pure returns (UFixed) {
-    require(UFixed.unwrap(b) > 0, "ERROR:UFM-020:DIVISOR_ZERO");
-
+    if (UFixed.unwrap(b) == 0) {
+        revert UFixedLib.UFixedLibDivisionByZero();
+    }
+    
     return
         UFixed.wrap(MathLib.mulDiv(UFixed.unwrap(a), 10 ** 18, UFixed.unwrap(b)));
 }
@@ -88,6 +94,8 @@ function deltaUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 /// @dev copied from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.3/contracts/utils/math/Math.sol
 library MathLib {
 
+    error MathLigMulDivOverflow();
+
     enum Rounding {
         Down, // Toward negative infinity
         Up, // Toward infinity
@@ -121,8 +129,10 @@ library MathLib {
             }
 
             // Make sure the result is less than 2^256. Also prevents denominator == 0.
-            require(denominator > prod1, "Math: mulDiv overflow");
-
+            if (denominator <= prod1) {
+                revert MathLigMulDivOverflow();
+            }
+            
             ///////////////////////////////////////////////
             // 512 by 256 division.
             ///////////////////////////////////////////////
@@ -194,6 +204,12 @@ library MathLib {
 }
 
 library UFixedLib {
+    error UFixedLibNegativeResult();
+    error UFixedLibDivisionByZero();
+
+    error UFixedLibExponentTooSmall(int8 exp);
+    error UFixedLibExponentTooLarge(int8 exp);
+
     int8 public constant EXP = 18;
     uint256 public constant MULTIPLIER = 10 ** uint256(int256(EXP));
     uint256 public constant MULTIPLIER_HALF = MULTIPLIER / 2;
@@ -220,9 +236,13 @@ library UFixedLib {
 
     /// @dev Converts the uint256 to a UFixed with given exponent.
     function toUFixed(uint256 a, int8 exp) public pure returns (UFixed) {
-        require(EXP + exp >= 0, "ERROR:FM-010:EXPONENT_TOO_SMALL");
-        require(EXP + exp <= 64, "ERROR:FM-011:EXPONENT_TOO_LARGE");
-
+        if (EXP + exp < 0) {
+            revert UFixedLibExponentTooSmall(exp);
+        }
+        if (EXP + exp > 64) {
+            revert UFixedLibExponentTooLarge(exp);
+        }
+        
         return UFixed.wrap(a * 10 ** uint8(EXP + exp));
     }
 
@@ -236,6 +256,11 @@ library UFixedLib {
         return toIntWithRounding(a, ROUNDING_HALF_UP());
     }
 
+    /// @dev Converts a UFixed to a uint256.
+    function toInt1000(UFixed a) public pure returns (uint256) {
+        return toIntWithRounding(toUFixed(1000) * a, ROUNDING_HALF_UP());
+    }
+
     /// @dev Converts a UFixed to a uint256 with given rounding mode.
     function toIntWithRounding(UFixed a, uint8 rounding) public pure returns (uint256) {
         if (rounding == ROUNDING_HALF_UP()) {
@@ -319,6 +344,10 @@ library UFixedLib {
         return UFixed.wrap(0);
     }
 
+    function one() public pure returns (UFixed) {
+        return UFixed.wrap(MULTIPLIER);
+    }
+
     /// @dev return the absolute delta between two UFixed numbers
     function delta(UFixed a, UFixed b) public pure returns (UFixed) {
         return deltaUFixed(a, b);

package/contracts/type/Version.sol

@@ -7,6 +7,7 @@ using {
     versionPartGt as >,
     versionPartEq as ==,
     versionPartNe as !=,
+    VersionPartLib.eqz,
     VersionPartLib.toInt
 }
     for VersionPart global;
@@ -16,7 +17,8 @@ function versionPartEq(VersionPart a, VersionPart b) pure returns(bool isSame) {
 function versionPartNe(VersionPart a, VersionPart b) pure returns(bool isSame) { return VersionPart.unwrap(a) != VersionPart.unwrap(b); }
 
 library VersionPartLib {
-    function toInt(VersionPart a) external pure returns(uint) { return VersionPart.unwrap(a); }
+    function eqz(VersionPart a) external pure returns(bool) { return VersionPart.unwrap(a) == 0; }
+    function toInt(VersionPart a) external pure returns(uint256) { return VersionPart.unwrap(a); }
     function toVersionPart(uint256 a) external pure returns(VersionPart) { return VersionPart.wrap(uint8(a)); }
 }
 

package/contracts/{shared → upgradeability}/ProxyManager.sol

@@ -1,17 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
 import {ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
 import {Blocknumber, blockNumber} from "../type/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 {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, VersionLib} from "../type/Version.sol";
-import {NftId} from "../type/NftId.sol";
 
 /// @dev manages proxy deployments for upgradable contracs of type IVersionable
 contract ProxyManager is
@@ -41,57 +40,68 @@ contract ProxyManager is
     mapping(Version version => VersionInfo info) _versionHistory;
     Version [] _versions;
 
-    /// @dev only used to capture proxy owner
-    constructor(address registry)
-    { 
-        initializeProxyManager(registry);
-    }
-
-    function initializeProxyManager(address registry)
+    /// @dev convencience initializer
+    function initialize(
+        address registry,
+        address implementation,
+        bytes memory data,
+        bytes32 salt
+    )
         public
         initializer()
+        returns (IVersionable versionable)
     {
-        initializeNftOwnable(msg.sender, registry);
+        versionable = deployDetermenistic(
+            registry,
+            implementation, 
+            data,
+            salt);
     }
 
     /// @dev deploy initial contract
-    function deploy(address initialImplementation, bytes memory initializationData)
+    function deploy(
+        address registry, 
+        address initialImplementation, 
+        bytes memory initializationData
+    )
         public
         virtual
-        onlyOwner()
+        onlyInitializing()
         returns (IVersionable versionable)
     {
-        if (_versions.length > 0) {
-            revert ErrorProxyManagerAlreadyDeployed();
-        }
+        (
+            address currentProxyOwner, 
+            address initialProxyAdminOwner
+        ) = _preDeployChecksAndSetup(registry);
 
-        address currentProxyOwner = getOwner(); // used by implementation
-        address initialProxyAdminOwner = address(this); // used by proxy
-        
         _proxy = new UpgradableProxyWithAdmin(
             initialImplementation,
             initialProxyAdminOwner,
             getDeployData(currentProxyOwner, initializationData)
         );
 
-        versionable = IVersionable(address(_proxy));
-        _updateVersionHistory(versionable.getVersion(), initialImplementation, currentProxyOwner);
+        versionable = _updateVersionHistory(
+            initialImplementation, 
+            currentProxyOwner);
 
-        emit LogProxyManagerVersionableDeployed(address(_proxy), initialImplementation);
+        emit LogProxyManagerVersionableDeployed(address(versionable), initialImplementation);
     }
 
-    function deployDetermenistic(address initialImplementation, bytes memory initializationData, bytes32 salt)
+    function deployDetermenistic(
+        address registry, 
+        address initialImplementation, 
+        bytes memory initializationData, 
+        bytes32 salt
+    )
         public
         virtual
-        onlyOwner()
+        onlyInitializing()
         returns (IVersionable versionable)
     {
-        if (_versions.length > 0) {
-            revert ErrorProxyManagerAlreadyDeployed();
-        }
-
-        address currentProxyOwner = getOwner();
-        address initialProxyAdminOwner = address(this);
+        (
+            address currentProxyOwner, 
+            address initialProxyAdminOwner
+        ) = _preDeployChecksAndSetup(registry);
 
         _proxy = new UpgradableProxyWithAdmin{salt: salt}(
             initialImplementation,
@@ -99,10 +109,11 @@ contract ProxyManager is
             getDeployData(currentProxyOwner, initializationData)
         );
 
-        versionable = IVersionable(address(_proxy));
-        _updateVersionHistory(versionable.getVersion(), initialImplementation, currentProxyOwner);
+        versionable = _updateVersionHistory(
+            initialImplementation, 
+            currentProxyOwner);
 
-        emit LogProxyManagerVersionableDeployed(address(_proxy), initialImplementation);
+        emit LogProxyManagerVersionableDeployed(address(versionable), initialImplementation);
     }
 
     /// @dev upgrade existing contract
@@ -125,10 +136,11 @@ contract ProxyManager is
             newImplementation, 
             getUpgradeData(upgradeData));
 
-        versionable = IVersionable(address(_proxy));
-        _updateVersionHistory(versionable.getVersion(), newImplementation, currentProxyOwner);
+        versionable = _updateVersionHistory(
+            newImplementation, 
+            currentProxyOwner);
 
-        emit LogProxyManagerVersionableUpgraded(address(_proxy), newImplementation);
+        emit LogProxyManagerVersionableUpgraded(address(versionable), newImplementation);
 
     }
 
@@ -169,13 +181,33 @@ contract ProxyManager is
         return _versionHistory[_version];
     }
 
+    function _preDeployChecksAndSetup(address registry)
+        private
+        returns (
+            address currentProxyOwner,
+            address initialProxyAdminOwner
+        )
+    {
+        if (_versions.length > 0) {
+            revert ErrorProxyManagerAlreadyDeployed();
+        }
+
+        _initializeNftOwnable(msg.sender, registry);
+
+        currentProxyOwner = getOwner(); // used by implementation
+        initialProxyAdminOwner = address(this); // used by proxy
+    }
+
     function _updateVersionHistory(
-        Version newVersion,
         address implementation,
         address activatedBy
     )
         private
+        returns (IVersionable versionable)
     {
+        versionable = IVersionable(address(_proxy));
+        Version newVersion = versionable.getVersion();
+
         if(newVersion == VersionLib.zeroVersion()) {
             revert ErrorProxyManagerZeroVersion();
         }

package/contracts/{shared → upgradeability}/UpgradableProxyWithAdmin.sol

@@ -2,9 +2,7 @@
 pragma solidity ^0.8.20;
 
 import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
-import {TransparentUpgradeableProxy, ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
-
-import {IVersionable} from "./IVersionable.sol";
+import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
 contract UpgradableProxyWithAdmin is TransparentUpgradeableProxy {
 

package/contracts/{shared → upgradeability}/Versionable.sol

@@ -20,7 +20,7 @@ abstract contract Versionable is
         bytes memory data
     )
         public
-        initializer
+        initializer()
     {
         _initialize(activatedBy, data);
     }
@@ -41,7 +41,7 @@ abstract contract Versionable is
     // each implementation MUST call intializers of all base contracts...
     function _initialize(address owner, bytes memory data) 
         internal
-        onlyInitializing
+        onlyInitializing()
         virtual 
     {
         revert();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-92c50c2-136",
+  "version": "0.0.2-9306579-093",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {
@@ -43,8 +43,8 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@openzeppelin/contracts": "5.0.0",
-    "@openzeppelin/contracts-upgradeable": "5.0.0",
+    "@openzeppelin/contracts": "5.0.2",
+    "@openzeppelin/contracts-upgradeable": "5.0.2",
     "@openzeppelin/upgrades-core": "^1.34.1",
     "abi-coder": "^5.0.0",
     "antlr4ng": "^3.0.4",

package/artifacts/contracts/instance/BundleManager.sol/BundleManager.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/9691244123a7bb449d69784e882fa0f3.json"
-}