@etherisc/gif-next 0.0.2-ce8407f-016 → 0.0.2-cf68d0c-530

package/contracts/shared/ERC165.sol

@@ -1,20 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {IERC165} from "@openzeppelin5/contracts/utils/introspection/IERC165.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 contract ERC165 is IERC165 {
     mapping(bytes4 => bool) private _isSupported;
 
     constructor() {
-        // register support for ERC165
-        _registerInterface(type(IERC165).interfaceId);
+        _initializeERC165();
     }
 
     function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
         return _isSupported[interfaceId];
     }
 
+    // @dev register support for ERC165 itself
+    function _initializeERC165() internal {
+        _isSupported[type(IERC165).interfaceId] = true;
+    }
+
     function _registerInterface(bytes4 interfaceId) internal {
         _isSupported[interfaceId] = true;
     }

package/contracts/shared/IRegisterable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC165} from "@openzeppelin5/contracts/utils/introspection/IERC165.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 import {INftOwnable} from "./INftOwnable.sol";
 import {IRegistry} from "../registry/IRegistry.sol";

package/contracts/{instance/base → shared}/IService.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {VersionPart} from "../../types/Version.sol";
+import {VersionPart} from "../types/Version.sol";
 
-import {IRegisterable} from "../../shared/IRegisterable.sol";
-import {IVersionable} from "../../shared/IVersionable.sol";
+import {IRegisterable} from "./IRegisterable.sol";
+import {IVersionable} from "./IVersionable.sol";
 
 interface IService is 
     IRegisterable,

package/contracts/shared/ProxyManager.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Ownable} from "@openzeppelin5/contracts/access/Ownable.sol";
-import {ProxyAdmin} from "@openzeppelin5/contracts/proxy/transparent/ProxyAdmin.sol";
-import {ITransparentUpgradeableProxy} from "@openzeppelin5/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+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 {IVersionable} from "./IVersionable.sol";
 import {NftOwnable} from "./NftOwnable.sol";

package/contracts/shared/Registerable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Initializable} from "@openzeppelin5/contracts/proxy/utils/Initializable.sol"; 
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
 import {NftId, zeroNftId} from "../types/NftId.sol";
 import {NftOwnable} from "../shared/NftOwnable.sol";
@@ -49,6 +49,7 @@ contract Registerable is
         //onlyInitializing//TODO uncomment when "fully" upgradeable
         virtual
     {
+        _initializeERC165();
         _initializeNftOwnable(
             initialOwner,
             registryAddress);
@@ -75,7 +76,7 @@ contract Registerable is
         RegisterableStorage storage $ = _getRegisterableStorage();
         return (
             IRegistry.ObjectInfo(
-                zeroNftId(),
+                getNftId(),
                 $._parentNftId,
                 $._objectType,
                 $._isInterceptor,

package/contracts/shared/RegisterableUpgradable.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Registerable} from "./Registerable.sol";
+import {Versionable} from "./Versionable.sol";
+
+/// @dev base contract for upgradable objects like services and upgradable components
+/// deriving contracs need to call _initializeRegisterable
+/// TODO internalizes versionable here, a non-registerable versionalbe might itself have some value but is outside the scope of the gif
+/// after this merge versionable will no longer exist on its own in gif
+/// only registerable and upgradable (which is a registerable too) will remain
+abstract contract RegisterableUpgradable is 
+    Registerable,
+    Versionable
+{
+}

package/contracts/shared/Service.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IService} from "./IService.sol";
+import {IVersionable} from "./IVersionable.sol";
+import {NftId, zeroNftId} from "../types/NftId.sol";
+import {RegisterableUpgradable} from "./RegisterableUpgradable.sol";
+import {SERVICE} from "../types/ObjectType.sol";
+import {Version, VersionPart, VersionLib} from "../types/Version.sol";
+import {Versionable} from "./Versionable.sol";
+
+/// @dev service base contract
+abstract contract Service is 
+    RegisterableUpgradable,
+    IService
+{
+    function getName() public pure virtual override returns(string memory name);
+
+    function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
+        return getVersion().toMajorPart(); 
+    }
+
+    // from Versionable
+    function getVersion()
+        public 
+        pure 
+        virtual override (IVersionable, Versionable)
+        returns(Version)
+    {
+        return VersionLib.toVersion(3,0,0);
+    }
+
+    function _initializeService(
+        address registry, 
+        address initialOwner
+    )
+        internal
+        //onlyInitializing //TODO uncomment when "fully" upgradeable
+    {
+        // service must provide its name and version upon registration
+        bytes memory data = abi.encode(getName(), getMajorVersion());
+        NftId registryNftId = _getRegistryNftId(registry); 
+        bool isInterceptor = false;
+
+        _initializeRegisterable(registry, registryNftId, SERVICE(), isInterceptor, initialOwner, data);
+        _registerInterface(type(IService).interfaceId);
+    }
+
+    // this is just a conveniene function, actual validation will be done upon registration
+    function _getRegistryNftId(address registryAddress) internal view returns (NftId) {
+        return IRegistry(registryAddress).getNftId(registryAddress);
+    }
+}

package/contracts/shared/TokenHandler.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC20Metadata} from "@openzeppelin5/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import {SafeERC20} from "@openzeppelin5/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 contract TokenHandler {
     IERC20Metadata private _token;

package/contracts/shared/UpgradableProxyWithAdmin.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {ProxyAdmin} from "@openzeppelin5/contracts/proxy/transparent/ProxyAdmin.sol";
-import {TransparentUpgradeableProxy, ITransparentUpgradeableProxy} from "@openzeppelin5/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import {TransparentUpgradeableProxy, ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
 import {IVersionable} from "./IVersionable.sol";
 

package/contracts/shared/Versionable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Initializable} from "@openzeppelin5/contracts/proxy/utils/Initializable.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 import {Blocknumber, blockNumber} from "../types/Blocknumber.sol";
 import {Timestamp, TimestampLib} from "../types/Timestamp.sol";

package/contracts/test/TestFee.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {UFixed, UFixedMathLib} from "../types/UFixed.sol";
+import {UFixed, UFixedLib} from "../types/UFixed.sol";
 import {Fee, FeeLib} from "../types/Fee.sol";
 
 contract TestFee {
@@ -15,7 +15,7 @@ contract TestFee {
         pure 
         returns(Fee memory fee)
     {
-        return FeeLib.toFee(UFixedMathLib.toUFixed(fractionalValue, exponent), fixedValue);
+        return FeeLib.toFee(UFixedLib.toUFixed(fractionalValue, exponent), fixedValue);
     }
 
     function getZeroFee() external pure returns(Fee memory fee) {

package/contracts/test/TestRoleId.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {RoleId, RoleIdLib} from "../../contracts/types/RoleId.sol";
+import {RoleId, RoleIdLib, PRODUCT_OWNER_ROLE_NAME, PRODUCT_OWNER_ROLE, POOL_OWNER_ROLE_NAME, POOL_OWNER_ROLE} from "../../contracts/types/RoleId.sol";
 
 contract TestRoleId {
-    // function getRole(string memory roleName) external pure returns (RoleId) { return RoleIdLib.toRoleId(roleName); }
+    function getRole(uint256 roleNum) external pure returns (RoleId) { return RoleIdLib.toRoleId(roleNum); }
 
-    // function getProductOwnerRoleName() external pure returns (string memory) { return PRODUCT_OWNER_ROLE_NAME(); }
-    // function getProductOwnerRole() external pure returns (RoleId) { return PRODUCT_OWNER_ROLE(); } 
+    function getProductOwnerRoleName() external pure returns (string memory) { return PRODUCT_OWNER_ROLE_NAME(); }
+    function getProductOwnerRole() external pure returns (RoleId) { return PRODUCT_OWNER_ROLE(); } 
 
-    // function getPoolOwnerRoleName() external pure returns (string memory) { return POOL_OWNER_ROLE_NAME(); }
-    // function getPoolOwnerRole() external pure returns (RoleId) { return POOL_OWNER_ROLE(); } 
+    function getPoolOwnerRoleName() external pure returns (string memory) { return POOL_OWNER_ROLE_NAME(); }
+    function getPoolOwnerRole() external pure returns (RoleId) { return POOL_OWNER_ROLE(); } 
 }

package/contracts/test/TestService.sol

@@ -3,21 +3,19 @@ pragma solidity ^0.8.19;
 
 import {NftId} from "../../contracts/types/NftId.sol";
 import {Version, VersionLib} from "../../contracts/types/Version.sol";
-import {ServiceBase} from "../../contracts/instance/base/ServiceBase.sol";
+import {Service} from "../../contracts/shared/Service.sol";
 
 import {IVersionable} from "../../contracts/shared/IVersionable.sol";
 import {Versionable} from "../../contracts/shared/Versionable.sol";
 
-//import {IService} from "../../contracts/instance/base/IService.sol";
-
-contract TestService is ServiceBase {
+contract TestService is Service {
 
     string public constant NAME = "TestService";
 
     constructor(address registry, NftId registryNftId, address initialOwner)
     // solhint-disable-next-line no-empty-blocks
     {
-        _initializeServiceBase(registry, registryNftId, initialOwner);
+        _initializeService(registry, initialOwner);
     }
 
     function getName() public pure override returns(string memory name) {

package/contracts/types/Fee.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {UFixed, UFixedMathLib} from "./UFixed.sol";
+import {UFixed, UFixedLib} from "./UFixed.sol";
 
 struct Fee {
     UFixed fractionalFee;
@@ -21,7 +21,7 @@ library FeeLib {
             uint256 netAmount
         )
     {
-        UFixed fractionalAmount = UFixedMathLib.toUFixed(amount) *
+        UFixed fractionalAmount = UFixedLib.toUFixed(amount) *
             fee.fractionalFee;
         feeAmount = fractionalAmount.toInt() + fee.fixedFee;
         netAmount = amount - feeAmount;
@@ -37,7 +37,7 @@ library FeeLib {
 
     /// @dev Return the percent fee struct (x%, 0)
     function percentageFee(uint8 percent) public pure returns (Fee memory fee) {
-        return Fee(UFixedMathLib.toUFixed(percent, -2), 0);
+        return Fee(UFixedLib.toUFixed(percent, -2), 0);
     }
 
     /// @dev Return a zero fee struct (0, 0)

package/contracts/types/RoleId.sol

@@ -22,10 +22,23 @@ function ORACLE_OWNER_ROLE_NAME() pure returns (string memory) { return "OracleO
 function POOL_OWNER_ROLE_NAME() pure returns (string memory) { return "PoolOwnerRole"; }
 function PRODUCT_OWNER_ROLE_NAME() pure returns (string memory) { return "ProductOwnerRole"; }
 
-// function DISTRIBUTION_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("DistributionOwnerRole"); }
-// function ORACLE_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("OracleOwnerRole"); }
-// function POOL_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("PoolOwnerRole"); }
-// function PRODUCT_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("ProductOwnerRole"); }
+function ADMIN_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(0); }
+
+// TODO correct numbers (maybe they are already defined in RegistryService)
+function DISTRIBUTION_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(100); }
+function ORACLE_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(200); }
+function POOL_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(300); }
+function PRODUCT_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(400); }
+
+function DISTRIBUTION_REGISTRAR_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1000); }
+function POLICY_REGISTRAR_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1100); }
+function BUNDLE_REGISTRAR_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1200); }
+function POOL_REGISTRAR_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1300); }
+function PRODUCT_REGISTRAR_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1400); }
+
+function DISTRIBUTION_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(10000); }
+
+function INSTANCE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(11000); }
 
 // @dev Returns true iff role ids a and b are identical
 function eqRoleId(RoleId a, RoleId b) pure returns (bool isSame) {

package/contracts/types/StateId.sol

@@ -58,6 +58,10 @@ function PAID() pure returns (StateId) {
     return toStateId(220);
 }
 
+function KEEP_STATE() pure returns (StateId) {
+    return toStateId(type(uint8).max);
+}
+
 /// @dev Converts the uint8 to a StateId.
 function toStateId(uint256 id) pure returns (StateId) {
     return StateId.wrap(uint8(id));

package/contracts/types/UFixed.sol

@@ -1,7 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-
-import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+pragma solidity ^0.8.20;
 
 /// @dev UFixed is a fixed point number with 18 decimals precision.
 type UFixed is uint256;
@@ -16,9 +14,15 @@ using {
     ltUFixed as <,
     lteUFixed as <=,
     eqUFixed as ==,
-    UFixedMathLib.toInt
+    neUFixed as !=,
+    UFixedLib.toInt,
+    UFixedLib.gtz
 } for UFixed global;
 
+function zeroUFixed() pure returns (UFixed zero) {
+    return UFixed.wrap(0);
+}
+
 function addUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return UFixed.wrap(UFixed.unwrap(a) + UFixed.unwrap(b));
 }
@@ -30,14 +34,14 @@ function subUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 
 function mulUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return
-        UFixed.wrap(Math.mulDiv(UFixed.unwrap(a), UFixed.unwrap(b), 10 ** 18));
+        UFixed.wrap(MathLib.mulDiv(UFixed.unwrap(a), UFixed.unwrap(b), 10 ** 18));
 }
 
 function divUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     require(UFixed.unwrap(b) > 0, "ERROR:UFM-020:DIVISOR_ZERO");
 
     return
-        UFixed.wrap(Math.mulDiv(UFixed.unwrap(a), 10 ** 18, UFixed.unwrap(b)));
+        UFixed.wrap(MathLib.mulDiv(UFixed.unwrap(a), 10 ** 18, UFixed.unwrap(b)));
 }
 
 function gtUFixed(UFixed a, UFixed b) pure returns (bool isGreaterThan) {
@@ -60,6 +64,10 @@ function eqUFixed(UFixed a, UFixed b) pure returns (bool isEqual) {
     return UFixed.unwrap(a) == UFixed.unwrap(b);
 }
 
+function neUFixed(UFixed a, UFixed b) pure returns (bool isEqual) {
+    return UFixed.unwrap(a) != UFixed.unwrap(b);
+}
+
 function gtzUFixed(UFixed a) pure returns (bool isZero) {
     return UFixed.unwrap(a) > 0;
 }
@@ -76,7 +84,115 @@ function deltaUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return b - a;
 }
 
-library UFixedMathLib {
+/// @dev copied from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.3/contracts/utils/math/Math.sol
+library MathLib {
+
+    enum Rounding {
+        Down, // Toward negative infinity
+        Up, // Toward infinity
+        Zero // Toward zero
+    }
+
+    /**
+     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
+     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
+     * with further edits by Uniswap Labs also under MIT license.
+     */
+    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
+        unchecked {
+            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
+            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
+            // variables such that product = prod1 * 2^256 + prod0.
+            uint256 prod0; // Least significant 256 bits of the product
+            uint256 prod1; // Most significant 256 bits of the product
+            assembly {
+                let mm := mulmod(x, y, not(0))
+                prod0 := mul(x, y)
+                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
+            }
+
+            // Handle non-overflow cases, 256 by 256 division.
+            if (prod1 == 0) {
+                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
+                // The surrounding unchecked block does not change this fact.
+                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
+                return prod0 / denominator;
+            }
+
+            // Make sure the result is less than 2^256. Also prevents denominator == 0.
+            require(denominator > prod1, "Math: mulDiv overflow");
+
+            ///////////////////////////////////////////////
+            // 512 by 256 division.
+            ///////////////////////////////////////////////
+
+            // Make division exact by subtracting the remainder from [prod1 prod0].
+            uint256 remainder;
+            assembly {
+                // Compute remainder using mulmod.
+                remainder := mulmod(x, y, denominator)
+
+                // Subtract 256 bit number from 512 bit number.
+                prod1 := sub(prod1, gt(remainder, prod0))
+                prod0 := sub(prod0, remainder)
+            }
+
+            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
+            // See https://cs.stackexchange.com/q/138556/92363.
+
+            // Does not overflow because the denominator cannot be zero at this stage in the function.
+            uint256 twos = denominator & (~denominator + 1);
+            assembly {
+                // Divide denominator by twos.
+                denominator := div(denominator, twos)
+
+                // Divide [prod1 prod0] by twos.
+                prod0 := div(prod0, twos)
+
+                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
+                twos := add(div(sub(0, twos), twos), 1)
+            }
+
+            // Shift in bits from prod1 into prod0.
+            prod0 |= prod1 * twos;
+
+            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
+            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
+            // four bits. That is, denominator * inv = 1 mod 2^4.
+            uint256 inverse = (3 * denominator) ^ 2;
+
+            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
+            // in modular arithmetic, doubling the correct bits in each step.
+            inverse *= 2 - denominator * inverse; // inverse mod 2^8
+            inverse *= 2 - denominator * inverse; // inverse mod 2^16
+            inverse *= 2 - denominator * inverse; // inverse mod 2^32
+            inverse *= 2 - denominator * inverse; // inverse mod 2^64
+            inverse *= 2 - denominator * inverse; // inverse mod 2^128
+            inverse *= 2 - denominator * inverse; // inverse mod 2^256
+
+            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
+            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
+            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
+            // is no longer required.
+            result = prod0 * inverse;
+            return result;
+        }
+    }
+
+    /**
+     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
+     */
+    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
+        uint256 result = mulDiv(x, y, denominator);
+        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
+            result += 1;
+        }
+        return result;
+    }
+
+}
+
+library UFixedLib {
     int8 public constant EXP = 18;
     uint256 public constant MULTIPLIER = 10 ** uint256(int256(EXP));
     uint256 public constant MULTIPLIER_HALF = MULTIPLIER / 2;
@@ -123,23 +239,23 @@ library UFixedMathLib {
     function toIntWithRounding(UFixed a, uint8 rounding) public pure returns (uint256) {
         if (rounding == ROUNDING_HALF_UP()) {
             return
-                Math.mulDiv(
+                MathLib.mulDiv(
                     UFixed.unwrap(a) + MULTIPLIER_HALF,
                     1,
                     MULTIPLIER,
-                    Math.Rounding.Down
+                    MathLib.Rounding.Down
                 );
         } else if (rounding == ROUNDING_DOWN()) {
             return
-                Math.mulDiv(
+                MathLib.mulDiv(
                     UFixed.unwrap(a),
                     1,
                     MULTIPLIER,
-                    Math.Rounding.Down
+                    MathLib.Rounding.Down
                 );
         } else {
             return
-                Math.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, Math.Rounding.Up);
+                MathLib.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, MathLib.Rounding.Up);
         }
     }
 

package/contracts/types/Version.sol

@@ -6,15 +6,18 @@ type VersionPart is uint8;
 using {
     versionPartGt as >,
     versionPartEq as ==,
+    versionPartNe as !=,
     VersionPartLib.toInt
 }
     for VersionPart global;
 
 function versionPartGt(VersionPart a, VersionPart b) pure returns(bool isGreaterThan) { 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); }
 
 library VersionPartLib {
-    function toInt(VersionPart x) external pure returns(uint) { return VersionPart.unwrap(x); }
+    function toInt(VersionPart a) external pure returns(uint) { return VersionPart.unwrap(a); }
+    function toVersionPart(uint256 a) external pure returns(VersionPart) { return VersionPart.wrap(uint8(a)); }
 }
 
 type Version is uint24; // contains major,minor,patch version parts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-ce8407f-016",
+  "version": "0.0.2-cf68d0c-530",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {
@@ -42,10 +42,11 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@openzeppelin/contracts": "^4.9.3",
-    "@openzeppelin/contracts-upgradeable": "^4.9.3",
+    "@openzeppelin/contracts": "5.0.0",
+    "@openzeppelin/contracts-upgradeable": "5.0.0",
     "abi-coder": "^5.0.0",
     "ethers": "^6.7.1",
+    "solidity-docgen": "^0.6.0-beta.36",
     "winston": "^3.10.0"
   }
 }

package/artifacts/contracts/instance/base/IService.sol/IService.dbg.json

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

package/artifacts/contracts/instance/base/ServiceBase.sol/ServiceBase.dbg.json

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

package/artifacts/contracts/registry/IChainNft.sol/IChainNft.dbg.json

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