@etherisc/gif-next 0.0.2-f1b01e0-214 → 0.0.2-f1e6957-384

package/contracts/type/RoleId.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.20;
 
 import {Key32, KeyId, Key32Lib} from "./Key32.sol";
 import {ObjectType, ROLE} from "./ObjectType.sol";
-import {VersionPart} from "./Version.sol";
+import {VersionPart, VersionPartLib} from "./Version.sol";
 
 type RoleId is uint64;
 
@@ -12,11 +12,9 @@ using {
     eqRoleId as ==, 
     neRoleId as !=,
     RoleIdLib.toInt,
+    RoleIdLib.isServiceRole,
     RoleIdLib.eqz,
-    RoleIdLib.gtz,
-    RoleIdLib.isComponentRole,
-    RoleIdLib.isCustomRole
-    // RoleIdLib.toKey32
+    RoleIdLib.gtz
 } for RoleId global;
 
 // general pure free functions
@@ -56,9 +54,14 @@ 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(3); } 
 
+// TODO check if/where this is really needed
 /// @dev role assigned to release registry, release specfic to lock/unlock a release
 function RELEASE_REGISTRY_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(4); }
 
+/// @dev role assigned to every instance owner
+function INSTANCE_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(5); }  
+
+// TODO upate role id ranges
 //--- 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
@@ -97,56 +100,72 @@ function CUSTOM_ROLE_MIN() pure returns (RoleId) { return RoleIdLib.toRoleId(100
 
 library RoleIdLib {
 
-    uint64 public constant ALL_VERSIONS = 99;
-    uint64 public constant SERVICE_DOMAIN_ROLE_FACTOR = 100;
-    uint64 public constant COMPONENT_ROLE_FACTOR = 1000;
-    uint64 public constant COMPONENT_ROLE_MIN_INT = 12000;
-    uint64 public constant COMPONENT_ROLE_MAX_INT = 19000;
-    uint64 public constant CUSTOM_ROLE_MIN_INT = 1000000;
+    error ErrorRoleIdTooBig(uint256 roleId);
+
+    // constant values need to match with AccessAdminLib.SERVICE_ROLE_*
+    uint64 public constant SERVICE_ROLE_MIN =  1000;
+    uint64 public constant SERVICE_ROLE_MAX = 99099; // 99 (max object type) * 1000 + 99
+
+    uint64 public constant SERVICE_ROLE_FACTOR = 1000;
 
     /// @dev Converts the RoleId to a uint.
     function zero() public pure returns (RoleId) {
         return RoleId.wrap(0);
     }
 
+
     /// @dev Converts an uint into a role id.
-    function toRoleId(uint64 a) public pure returns (RoleId) {
-        return RoleId.wrap(a);
-    }
+    function toRoleId(uint256 a) public pure returns (RoleId) {
+        if (a > type(uint64).max) {
+            revert ErrorRoleIdTooBig(a);
+        }
 
-    /// @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);
+        return RoleId.wrap(uint64(a));
     }
 
-    /// @dev Converts an uint into a custom role id.
-    function toCustomRoleId(uint64 index) public pure returns (RoleId) {
-        return toRoleId(CUSTOM_ROLE_MIN_INT + index);
-    }
 
-    /// @dev Converts the role id to a uint.
-    function toInt(RoleId a) public pure returns (uint64) {
-        return uint64(RoleId.unwrap(a));
+    function isServiceRole(RoleId roleId)
+        public
+        pure
+        returns (bool)
+    {
+        uint256 roleIdInt = RoleId.unwrap(roleId);
+        return roleIdInt >= SERVICE_ROLE_MIN && roleIdInt <= SERVICE_ROLE_MAX;
     }
 
-    /// @dev Converts an uint into a role id.
-    /// Used for GIF core contracts.
-    function roleForType(ObjectType objectType) public pure returns (RoleId) {
-        return RoleId.wrap(SERVICE_DOMAIN_ROLE_FACTOR * uint64(objectType.toInt()));
+
+    function toGenericServiceRoleId(
+        ObjectType objectType
+    )
+        public 
+        pure 
+        returns (RoleId)
+    {
+        return toServiceRoleId(
+            objectType, 
+            VersionPartLib.releaseMax());
     }
 
-    /// @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(SERVICE_DOMAIN_ROLE_FACTOR * objectType.toInt() + majorVersion.toInt()));
+
+    function toServiceRoleId(
+        ObjectType serviceDomain, 
+        VersionPart release
+    )
+        public 
+        pure 
+        returns (RoleId serviceRoleId)
+    {
+        uint256 serviceRoleIdInt = 
+            SERVICE_ROLE_MIN 
+            + SERVICE_ROLE_FACTOR * (serviceDomain.toInt() - 1)
+            + release.toInt();
+
+        return toRoleId(serviceRoleIdInt);
     }
 
-    /// @dev Converts an uint into a RoleId.
-    /// Used for GIF core contracts.
-    function roleForTypeAndAllVersions(ObjectType objectType) public pure returns (RoleId) {
-        return RoleId.wrap(
-            uint64(SERVICE_DOMAIN_ROLE_FACTOR * objectType.toInt() + ALL_VERSIONS));
+    /// @dev Converts the role id to a uint.
+    function toInt(RoleId a) public pure returns (uint64) {
+        return uint64(RoleId.unwrap(a));
     }
 
     /// @dev Returns true if the value is non-zero (> 0).
@@ -158,25 +177,4 @@ library RoleIdLib {
     function eqz(RoleId a) public pure returns (bool) {
         return RoleId.unwrap(a) == 0;
     }
-
-    /// @dev Returns true iff the role id is a component role.
-    function isComponentRole(RoleId roleId) public pure returns (bool) {
-        uint64 roleIdInt = RoleId.unwrap(roleId);
-        return roleIdInt >= COMPONENT_ROLE_MIN_INT && roleIdInt <= COMPONENT_ROLE_MAX_INT;
-    }
-
-    /// @dev Returns true iff the role id is a custom role.
-    function isCustomRole(RoleId roleId) public pure returns (bool) {
-        return RoleId.unwrap(roleId) >= CUSTOM_ROLE_MIN_INT;
-    }
-
-    /// @dev Returns the key32 value for the specified id and object type.
-    function toKey32(RoleId a) public pure returns (Key32 key) {
-        return Key32Lib.toKey32(ROLE(), toKeyId(a));
-    }
-
-    /// @dev Returns the key id value for the specified id
-    function toKeyId(RoleId a) public pure returns (KeyId keyId) {
-        return KeyId.wrap(bytes31(uint248(RoleId.unwrap(a))));
-    }
 }

package/contracts/type/Seconds.sol

@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+/// @dev Target: Cover durations of 1000 years.
 type Seconds is uint40;
 
 using {
     SecondsEq as ==,
+    SecondsLt as <,
     SecondsGt as >,
     SecondsAdd as +,
     SecondsLib.eqz,
@@ -20,6 +22,10 @@ function SecondsEq(Seconds duration1, Seconds duration2) pure returns (bool) {
     return SecondsLib.eq(duration1, duration2);
 }
 
+function SecondsLt(Seconds duration1, Seconds duration2) pure returns (bool) {
+    return SecondsLib.lt(duration1, duration2);
+}
+
 function SecondsGt(Seconds duration1, Seconds duration2) pure returns (bool) {
     return SecondsLib.gt(duration1, duration2);
 }
@@ -45,6 +51,10 @@ library SecondsLib {
         return Seconds.wrap(24 * 3600);
     }
 
+    function fromDays(uint32 numberOfDays) public pure returns (Seconds duration) {
+        return Seconds.wrap(numberOfDays * 24 * 3600);
+    }
+
     function oneYear() public pure returns (Seconds duration) {
         return Seconds.wrap(365 * 24 * 3600);
     }
@@ -85,6 +95,15 @@ library SecondsLib {
         return Seconds.unwrap(duration1) < Seconds.unwrap(duration2);
     }
 
+    /// @dev returns the smaller of the duration
+    function min(Seconds duration1, Seconds duration2) public pure returns (Seconds) {
+        if (Seconds.unwrap(duration1) < Seconds.unwrap(duration2)) {
+            return duration1;
+        } 
+        
+        return 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));

package/contracts/type/String.sol

@@ -12,10 +12,12 @@ using {
     StrLib.length
 } for Str global;
 
+// pure free function needed for the operator overloading
 function StrEq(Str s1, Str s2) pure returns (bool) {
     return StrLib.eq(s1, s2);
 }
 
+// pure free function needed for the operator overloading
 function StrNe(Str s1, Str s2) pure returns (bool) {
     return StrLib.ne(s1, s2);
 }
@@ -39,6 +41,16 @@ library StrLib {
         return Str.unwrap(s1) != Str.unwrap(s2);
     }
 
+    /// @dev return true iff s1 equals from s2
+    function eq(string memory s1, string memory s2) public pure returns (bool) {
+        return keccak256(bytes(s1)) == keccak256(bytes(s2));
+    }
+
+    /// @dev return true iff s1 differs s2
+    function ne(string memory s1, string memory s2) public pure returns (bool) {
+        return !eq(s1, s2);
+    }
+
     /// @dev converts the provided short string into a string.
     /// uses ShortStrings.toString
     function toString(Str str) public pure returns (string memory) {

package/contracts/type/Timestamp.sol

@@ -3,6 +3,8 @@ pragma solidity ^0.8.20;
 
 import {Seconds} from "./Seconds.sol";
 
+/// @dev Target: Cover 10 years with 1 ms block time resolution.
+/// Typical block time resolution is 1s.
 type Timestamp is uint40;
 
 using {
@@ -69,8 +71,8 @@ library TimestampLib {
     function max() public pure returns (Timestamp) {
         return Timestamp.wrap(type(uint40).max);
     }
-    
-    function blockTimestamp() public view returns (Timestamp) {
+
+    function current() public view returns (Timestamp) {
         return Timestamp.wrap(uint40(block.timestamp));
     }
 

package/contracts/type/UFixed.sol

@@ -18,6 +18,7 @@ using {
     eqUFixed as ==,
     neUFixed as !=,
     UFixedLib.gt,
+    UFixedLib.eqz,
     UFixedLib.gtz,
     UFixedLib.toInt,
     UFixedLib.toInt1000

package/contracts/upgradeability/IVersionable.sol

@@ -28,6 +28,9 @@ import {Version} from "../type/Version.sol";
 
 interface IVersionable {
 
+    error ErrorVersionableInitializeNotImplemented();
+    error ErrorVersionableUpgradeNotImplemented();
+
     /**
      * @dev IMPORTANT
      * implementation MUST be guarded by initializer modifier

package/contracts/upgradeability/ProxyManager.sol

@@ -4,7 +4,7 @@ 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 {Blocknumber, BlocknumberLib} from "../type/Blocknumber.sol";
 import {IVersionable} from "./IVersionable.sol";
 import {NftId} from "../type/NftId.sol";
 import {NftOwnable} from "../shared/NftOwnable.sol";
@@ -18,11 +18,13 @@ contract ProxyManager is
 {
 
     struct VersionInfo {
-        Version version;
+        // slot 0
         address implementation;
-        address activatedBy;
         Timestamp activatedAt;
         Blocknumber activatedIn;
+        Version version;
+        // slot 1
+        address activatedBy;
     }
 
     event LogProxyManagerVersionableDeployed(address indexed proxy, address initialImplementation);
@@ -37,8 +39,8 @@ contract ProxyManager is
     UpgradableProxyWithAdmin internal _proxy;
 
     // state to keep version history
-    mapping(Version version => VersionInfo info) _versionHistory;
-    Version [] _versions;
+    mapping(Version version => VersionInfo info) internal _versionHistory;
+    Version [] internal _versions;
 
     /// @dev convencience initializer
     function initialize(
@@ -116,6 +118,18 @@ contract ProxyManager is
         emit LogProxyManagerVersionableDeployed(address(versionable), initialImplementation);
     }
 
+    /// @dev upgrade existing contract.
+    /// convenience method using empty data
+    function upgrade(address newImplementation) 
+        public
+        virtual
+        onlyOwner()
+        returns (IVersionable versionable)
+    {
+        bytes memory emptyUpgradeData;
+        return upgrade(newImplementation, emptyUpgradeData);
+    }
+
     /// @dev upgrade existing contract
     function upgrade(address newImplementation, bytes memory upgradeData)
         public
@@ -221,12 +235,12 @@ contract ProxyManager is
 
         // update version history
         _versions.push(newVersion);
-        _versionHistory[newVersion] = VersionInfo(
-            newVersion,
-            implementation,
-            activatedBy,
-            TimestampLib.blockTimestamp(),
-            blockNumber()
-        );
+        _versionHistory[newVersion] = VersionInfo({
+            version: newVersion,
+            implementation: implementation,
+            activatedBy: activatedBy,
+            activatedAt: TimestampLib.current(),
+            activatedIn: BlocknumberLib.current()
+        });
     }
 }

package/contracts/upgradeability/UpgradableProxyWithAdmin.sol

@@ -6,9 +6,19 @@ import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transpa
 
 contract UpgradableProxyWithAdmin is TransparentUpgradeableProxy {
 
+    bytes internal _initializationData;
+    
     constructor(address implementation, address initialProxyAdminOwner, bytes memory data)
         TransparentUpgradeableProxy(implementation, initialProxyAdminOwner, data)
-    {}
+    {
+        _initializationData = data;
+    }
 
-    function getProxyAdmin() external returns (ProxyAdmin) { return ProxyAdmin(_proxyAdmin()); }
+    function getProxyAdmin() external returns (ProxyAdmin) { 
+        return ProxyAdmin(_proxyAdmin()); 
+    }
+
+    function getInitializationData() external view returns (bytes memory) { 
+        return _initializationData; 
+    }
 }

package/contracts/upgradeability/Versionable.sol

@@ -39,12 +39,15 @@ abstract contract Versionable is
     // IMPORTANT each version must implement this function 
     // each implementation MUST use onlyInitialising modifier
     // each implementation MUST call intializers of all base contracts...
-    function _initialize(address owner, bytes memory data) 
+    function _initialize(
+        address, // owner
+        bytes memory // data
+    ) 
         internal
         onlyInitializing()
         virtual 
     {
-        revert();
+        revert ErrorVersionableInitializeNotImplemented();
     }
 
     // IMPORTANT each version except version "1" must implement this function 
@@ -54,6 +57,6 @@ abstract contract Versionable is
         onlyInitializing
         virtual
     {
-        revert();
+        revert ErrorVersionableUpgradeNotImplemented();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-f1b01e0-214",
+  "version": "0.0.2-f1e6957-384",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {

package/artifacts/contracts/authorization/AccessAdmin.sol/IAccessManagedChecker.dbg.json

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

package/artifacts/contracts/authorization/AccessAdmin.sol/IAccessManagedChecker.json

@@ -1,24 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "IAccessManagedChecker",
-  "sourceName": "contracts/authorization/AccessAdmin.sol",
-  "abi": [
-    {
-      "inputs": [],
-      "name": "authority",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    }
-  ],
-  "bytecode": "0x",
-  "deployedBytecode": "0x",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}

package/artifacts/contracts/shared/ComponentVerifyingService.sol/ComponentVerifyingService.dbg.json

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