@etherisc/gif-next 0.0.2-bca36d7-613 → 0.0.2-bdcb44f-543

package/contracts/shared/Service.sol

@@ -1,24 +1,30 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {IRegistry} from "../registry/IRegistry.sol";
+import {ObjectType, SERVICE} from "../types/ObjectType.sol";
+import {NftId, zeroNftId} from "../types/NftId.sol";
+import {Version, VersionPart, VersionLib, VersionPartLib} from "../types/Version.sol";
+
+import {Versionable} from "./Versionable.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";
+import {Registerable} from "./Registerable.sol";
+
+import {IRegistry} from "../registry/IRegistry.sol";
+
 
 /// @dev service base contract
 abstract contract Service is 
-    RegisterableUpgradable,
+    Registerable,
+    Versionable,
     IService
 {
-    function getName() public pure virtual override returns(string memory name);
+    function getDomain() public pure virtual override returns(ObjectType);
 
+    // version major version MUST be consistent with major version of getVersion()
     function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
-        return getVersion().toMajorPart(); 
+        return VersionPartLib.toVersionPart(3); 
     }
 
     // from Versionable
@@ -31,24 +37,22 @@ abstract contract Service is
         return VersionLib.toVersion(3,0,0);
     }
 
-    function _initializeService(
+    function initializeService(
         address registry, 
         address initialOwner
     )
-        internal
-        //onlyInitializing //TODO uncomment when "fully" upgradeable
+        public
+        virtual
+        onlyInitializing()
     {
-        // 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);
-    }
+        initializeRegisterable(
+            registry, 
+            IRegistry(registry).getNftId(), 
+            SERVICE(), 
+            false, // is interceptor
+            initialOwner, 
+            ""); // data
 
-    // 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);
+        registerInterface(type(IService).interfaceId);
     }
 }

package/contracts/shared/Versionable.sol

@@ -3,83 +3,39 @@ pragma solidity ^0.8.20;
 
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-import {Blocknumber, blockNumber} from "../types/Blocknumber.sol";
-import {Timestamp, TimestampLib} from "../types/Timestamp.sol";
-import {Version, VersionPart, VersionLib} from "../types/Version.sol";
-
 import {IVersionable} from "./IVersionable.sol";
-
+import {Version, VersionLib} from "../types/Version.sol";
 
 
 abstract contract Versionable is 
     Initializable,
     IVersionable 
 {
-    // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.shared.Versionable.sol")) - 1)) & ~bytes32(uint256(0xff))
-    bytes32 private constant VERSIONABLE_LOCATION_V1 = 0x4f61291a8ac3d020d0a7d919a76b8592aa88385744dee3f8b4f3873b969ed900;
-
-
-    /// @custom:storage-location erc7201:gif-next.contracts.shared.Versionable.sol
-    struct VersionableStorage {
-        mapping(Version version => VersionInfo info) _versionHistory;
-        Version [] _versions;
-        Version _v1;
-    }
-
-
     constructor() {
         _disableInitializers();
     }
-    // TODO write test where new version of private _updateVersionHistory is added and used... 
-    function initialize(
-        address implementation,
+
+    function initializeVersionable(
         address activatedBy,
         bytes memory data
     )
         public
         initializer
     {
-        _updateVersionHistory(implementation, activatedBy);
         _initialize(activatedBy, data);
     }
 
-    // TODO activatedBy MUST ALWAYS be an owner?
-    function upgrade(
-        address implementation,
-        address activatedBy,
+    function upgradeVersionable(
         bytes memory data
     )
         external
         reinitializer(VersionLib.toUint64(getVersion()))
     {
-        _updateVersionHistory(implementation, activatedBy);
         _upgrade(data);
     }
 
-    function isInitialized(Version _version) public override view returns(bool) {
-        return _getVersionableStorage()._versionHistory[_version].activatedIn.toInt() > 0;
-    }
-
     function getVersion() public pure virtual returns(Version);
 
-    function getVersionCount() public view override returns(uint256) {
-        return _getVersionableStorage()._versions.length;
-    }
-
-    function getVersion(uint256 idx) public view override returns(Version) {
-        return _getVersionableStorage()._versions[idx];
-    }
-
-    function getVersionInfo(Version _version) public override view returns(VersionInfo memory) {
-        return _getVersionableStorage()._versionHistory[_version];
-    }
-
-    function getInitializedVersion() public view returns(uint64) {
-        return _getInitializedVersion();
-    }
-
-
-
     // IMPORTANT each version must implement this function 
     // each implementation MUST use onlyInitialising modifier
     // each implementation MUST call intializers of all base contracts...
@@ -91,7 +47,6 @@ abstract contract Versionable is
         revert();
     }
 
-
     // IMPORTANT each version except version "1" must implement this function 
     // each implementation MUST use onlyInitialising modifier
     function _upgrade(bytes memory data)
@@ -101,47 +56,4 @@ abstract contract Versionable is
     {
         revert();
     }
-
-    function _getVersionableStorage() private pure returns (VersionableStorage storage $) {
-        assembly {
-            $.slot := VERSIONABLE_LOCATION_V1
-        }
-    }
-
-    // can only be called once per contract
-    // needs to be called inside the proxy upgrade tx
-    // TODO run reinitializer(version().toUint64()) modifier after "version()" is checked, 
-    function _updateVersionHistory(
-        address implementation,
-        address activatedBy
-    )
-        private
-        onlyInitializing
-    {
-        VersionableStorage storage $ = _getVersionableStorage();
-
-        uint64 version = _getInitializedVersion();
-
-        Version thisVersion = getVersion();
-
-        if(version == 1) {
-            // thisVersion is alias to version "1"
-            $._v1 = thisVersion;
-        }
-        else {
-            require(thisVersion > $._v1, "INVALID VERSION");
-        }
-
-        // update version history
-        $._versions.push(thisVersion);
-        $._versionHistory[thisVersion] = VersionInfo(
-            thisVersion,
-            implementation,
-            activatedBy,
-            TimestampLib.blockTimestamp(),
-            blockNumber()
-        );
-
-        emit LogVersionableInitialized(thisVersion, implementation, activatedBy);
-    }
 }

package/contracts/test/TestRegisterable.sol

@@ -13,6 +13,6 @@ contract TestRegisterable is Registerable {
     // solhint-disable-next-line no-empty-blocks
     {
         bytes memory data = "";
-        _initializeRegisterable(registry, registryNftId, objectType, isInterceptor, initialOwner, data);
+        initializeRegisterable(registry, registryNftId, objectType, isInterceptor, initialOwner, data);
     }
 }

package/contracts/test/TestService.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
+import {ObjectType, PRODUCT} from "../../contracts/types/ObjectType.sol";
 import {NftId} from "../../contracts/types/NftId.sol";
 import {Version, VersionLib} from "../../contracts/types/Version.sol";
 import {Service} from "../../contracts/shared/Service.sol";
@@ -15,10 +16,10 @@ contract TestService is Service {
     constructor(address registry, NftId registryNftId, address initialOwner)
     // solhint-disable-next-line no-empty-blocks
     {
-        _initializeService(registry, initialOwner);
+        initializeService(registry, initialOwner);
     }
 
-    function getName() public pure override returns(string memory name) {
-        return NAME;
+    function getDomain() public pure override returns(ObjectType) {
+        return PRODUCT();
     }
 }

package/contracts/types/ClaimId.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+// uint16 allows for 65'535 claims per policy
+type ClaimId is uint16;
+
+// type bindings
+using {
+    eqClaimId as ==, 
+    neClaimId as !=, 
+    ClaimIdLib.eqz,
+    ClaimIdLib.gtz,
+    ClaimIdLib.toInt
+} for ClaimId global;
+
+
+// pure free functions for operators
+function eqClaimId(ClaimId a, ClaimId b) pure returns (bool isSame) {
+    return ClaimId.unwrap(a) == ClaimId.unwrap(b);
+}
+
+function neClaimId(ClaimId a, ClaimId b) pure returns (bool isDifferent) {
+    return ClaimId.unwrap(a) != ClaimId.unwrap(b);
+}
+
+// library functions that operate on user defined type
+library ClaimIdLib {
+    /// @dev Converts the ClaimId to a uint.
+    function zero() public pure returns (ClaimId) {
+        return ClaimId.wrap(0);
+    }
+
+    /// @dev Converts an uint into a ClaimId.
+    function toClaimId(uint256 a) public pure returns (ClaimId) {
+        return ClaimId.wrap(uint16(a));
+    }
+
+    /// @dev Converts the ClaimId to a uint.
+    function toInt(ClaimId a) public pure returns (uint16) {
+        return uint16(ClaimId.unwrap(a));
+    }
+
+    /// @dev Returns true if the value is non-zero (> 0).
+    function gtz(ClaimId a) public pure returns (bool) {
+        return ClaimId.unwrap(a) > 0;
+    }
+
+    /// @dev Returns true if the value is zero (== 0).
+    function eqz(ClaimId a) public pure returns (bool) {
+        return ClaimId.unwrap(a) == 0;
+    }
+}

package/contracts/types/DistributorType.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.20;
 
 import {Key32, KeyId, Key32Lib} from "./Key32.sol";
 import {NftId} from "./NftId.sol";
-import {DISTRIBUTION_TYPE} from "./ObjectType.sol";
+import {DISTRIBUTOR_TYPE} from "./ObjectType.sol";
 
 type DistributorType is bytes8;
 
@@ -45,7 +45,7 @@ library DistributorTypeLib {
 
     /// @dev Returns the key32 value for the specified nft id and object type.
     function toKey32(DistributorType id) public pure returns (Key32 key) {
-        return Key32Lib.toKey32(DISTRIBUTION_TYPE(), toKeyId(id));
+        return Key32Lib.toKey32(DISTRIBUTOR_TYPE(), toKeyId(id));
     }
 
     /// @dev Returns the key id value for the specified nft id

package/contracts/types/NftIdSet.sol

@@ -11,35 +11,37 @@ library LibNftIdSet {
         mapping(NftId nftid => uint256 index) at;
     }
 
-    function add(Set storage set, NftId nftId) external returns(bool added) {
-        if (set.at[nftId] == 0) {
-            set.ids.push(nftId);
-            set.at[nftId] = set.ids.length;
-            return true;
-        } else {
-            return false;
+    error ErrorNftIdSetAlreadyAdded(NftId nftId);
+    error ErrorNftIdSetNotInSet(NftId nftId);
+
+
+    function add(Set storage set, NftId nftId) external {
+        if (set.at[nftId] > 0) {
+            revert ErrorNftIdSetAlreadyAdded(nftId);
         }
+
+        set.ids.push(nftId);
+        set.at[nftId] = set.ids.length;
     }
 
-    function remove(Set storage set, NftId nftId) external returns(bool removed) {
+    function remove(Set storage set, NftId nftId) external {
         uint256 nftIdIndex = set.at[nftId];
 
-        if (nftIdIndex > 0) {
-            uint256 toDeleteIndex = nftIdIndex - 1;
-            uint256 lastIndex = set.ids.length - 1;
-
-            if (lastIndex != toDeleteIndex) {
-                NftId lastId = set.ids[lastIndex];
-                set.ids[toDeleteIndex] = lastId;
-                set.at[lastId] = nftIdIndex; // Replace lastValue's index to valueIndex
-            }
-
-            set.ids.pop();
-            delete set.at[nftId];
-            return true;
-        } else {
-            return false;
+        if (nftIdIndex == 0) {
+            revert ErrorNftIdSetNotInSet(nftId);
         }
+
+        uint256 toDeleteIndex = nftIdIndex - 1;
+        uint256 lastIndex = set.ids.length - 1;
+
+        if (lastIndex != toDeleteIndex) {
+            NftId lastId = set.ids[lastIndex];
+            set.ids[toDeleteIndex] = lastId;
+            set.at[lastId] = nftIdIndex; // Replace lastValue's index to valueIndex
+        }
+
+        set.ids.pop();
+        delete set.at[nftId];
     }
 
     function isEmpty(Set storage set) external view returns(bool empty) {
@@ -50,7 +52,7 @@ library LibNftIdSet {
         return set.at[nftId] > 0;
     }
 
-    function getLength(Set storage set) external view returns(uint256 length) {
+    function size(Set storage set) external view returns(uint256 length) {
         return set.ids.length;
     }
 

package/contracts/types/ObjectType.sol

@@ -66,7 +66,7 @@ function DISTRIBUTION() pure returns (ObjectType) {
     return toObjectType(120);
 }
 
-function DISTRIBUTION_TYPE() pure returns (ObjectType) {
+function DISTRIBUTOR_TYPE() pure returns (ObjectType) {
     return toObjectType(121);
 }
 
@@ -90,16 +90,20 @@ function RISK() pure returns (ObjectType) {
     return toObjectType(200);
 }
 
-function POLICY() pure returns (ObjectType) {
+function APPLICATION() pure returns (ObjectType) {
     return toObjectType(210);
 }
 
-function BUNDLE() pure returns (ObjectType) {
-    return toObjectType(220);
+function POLICY() pure returns (ObjectType) {
+    return toObjectType(211);
 }
 
 function CLAIM() pure returns (ObjectType) {
-    return toObjectType(211);
+    return toObjectType(212);
+}
+
+function BUNDLE() pure returns (ObjectType) {
+    return toObjectType(220);
 }
 
 function PAYOUT() pure returns (ObjectType) {

package/contracts/types/PayoutId.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+// uint24 allows for 65'535 claims with 255 payouts each per policy
+type PayoutId is uint24;
+
+// type bindings
+using {
+    eqPayoutId as ==, 
+    nePayoutId as !=, 
+    PayoutIdLib.eqz,
+    PayoutIdLib.gtz,
+    PayoutIdLib.toInt
+} for PayoutId global;
+
+
+// pure free functions for operators
+function eqPayoutId(PayoutId a, PayoutId b) pure returns (bool isSame) {
+    return PayoutId.unwrap(a) == PayoutId.unwrap(b);
+}
+
+function nePayoutId(PayoutId a, PayoutId b) pure returns (bool isDifferent) {
+    return PayoutId.unwrap(a) != PayoutId.unwrap(b);
+}
+
+// TODO come up with a way to code claim id into payout id
+// eg payoutId.getClaimId(), payoutId.getPayoutNo()
+// library functions that operate on user defined type
+library PayoutIdLib {
+    /// @dev Converts the PayoutId to a uint.
+    function zero() public pure returns (PayoutId) {
+        return PayoutId.wrap(0);
+    }
+
+    /// @dev Converts an uint into a PayoutId.
+    function toPayoutId(uint256 a) public pure returns (PayoutId) {
+        return PayoutId.wrap(uint24(a));
+    }
+
+    /// @dev Converts the PayoutId to a uint.
+    function toInt(PayoutId a) public pure returns (uint24) {
+        return uint24(PayoutId.unwrap(a));
+    }
+
+    /// @dev Returns true if the value is non-zero (> 0).
+    function gtz(PayoutId a) public pure returns (bool) {
+        return PayoutId.unwrap(a) > 0;
+    }
+
+    /// @dev Returns true if the value is zero (== 0).
+    function eqz(PayoutId a) public pure returns (bool) {
+        return PayoutId.unwrap(a) == 0;
+    }
+}

package/contracts/types/RoleId.sol

@@ -16,23 +16,36 @@ using {
     RoleIdLib.toKey32
 } for RoleId global;
 
+
+/// @dev role id needs to match with oz AccessManager.ADMIN_ROLE
+function ADMIN_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(type(uint64).min); }
+
+/// @dev role id needs to match with oz AccessManager.PUBLIC_ROLE
+function PUBLIC_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(type(uint64).max); }
+
 // general pure free functions
 function DISTRIBUTION_OWNER_ROLE_NAME() pure returns (string memory) { return "DistributionOwnerRole"; }
 function ORACLE_OWNER_ROLE_NAME() pure returns (string memory) { return "OracleOwnerRole"; }
 function POOL_OWNER_ROLE_NAME() pure returns (string memory) { return "PoolOwnerRole"; }
 function PRODUCT_OWNER_ROLE_NAME() pure returns (string memory) { return "ProductOwnerRole"; }
 
-// 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 INSTANCE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2000); }
+function DISTRIBUTION_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2100); }
+function POOL_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2200); }
+function PRODUCT_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2300); }
+function APPLICATION_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2400); }
+function POLICY_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2410); }
+function CLAIM_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2420); }
+function BUNDLE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2500); }
+
+function GIF_ADMIN_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1500); } 
+function GIF_MANAGER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1600); } 
+function RELEASE_MANAGER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1700); } 
 
 // @dev Returns true iff role ids a and b are identical
 function eqRoleId(RoleId a, RoleId b) pure returns (bool isSame) {

package/contracts/types/Seconds.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+type Seconds is uint40;
+
+using {
+    SecondsLib.eqz,
+    SecondsLib.gtz,
+    SecondsLib.toInt
+} for Seconds global;
+
+
+library SecondsLib {
+
+    error ErrorSecondsLibDurationTooBig(uint256 duration);
+
+    function zero() public pure returns (Seconds) {
+        return Seconds.wrap(0);
+    }
+
+    function max() public pure returns (Seconds) {
+        return Seconds.wrap(_max());
+    }
+
+    /// @dev converts the uint duration into Seconds
+    /// function reverts if duration is exceeding max Seconds value
+    function toSeconds(uint256 duration) public pure returns (Seconds) {
+        // if(duration > type(uint40).max) {
+        if(duration > _max()) {
+            revert ErrorSecondsLibDurationTooBig(duration);
+        }
+
+        return Seconds.wrap(uint40(duration));
+    }
+
+    /// @dev return true if duration equals 0
+    function eqz(Seconds duration) public pure returns (bool) {
+        return Seconds.unwrap(duration) == 0;
+    }
+
+    /// @dev return true if duration is larger than 0
+    function gtz(Seconds duration) public pure returns (bool) {
+        return Seconds.unwrap(duration) > 0;
+    }
+
+    function toInt(Seconds duration) public pure returns (uint256) {
+        return uint256(uint40(Seconds.unwrap(duration)));
+    }
+
+    function _max() internal pure returns (uint40) {
+        // IMPORTANT: type nees to match with actual definition for Seconds
+        return type(uint40).max;
+    }
+}

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/Timestamp.sol

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
+
+import {Seconds} from "./Seconds.sol";
 
 type Timestamp is uint40;
 
@@ -12,7 +14,8 @@ using {
     neTimestamp as !=,
     TimestampLib.gtz,
     TimestampLib.eqz,
-    TimestampLib.addSeconds
+    TimestampLib.addSeconds,
+    TimestampLib.toInt
 } for Timestamp global;
 
 /// @dev return true if Timestamp a is after Timestamp b
@@ -50,10 +53,6 @@ function toTimestamp(uint256 timestamp) pure returns (Timestamp) {
     return Timestamp.wrap(uint40(timestamp));
 }
 
-// function blockTimestamp() view returns (Timestamp) {
-//     return toTimestamp(block.timestamp);
-// }
-
 /// @dev Return the Timestamp zero (0)
 function zeroTimestamp() pure returns (Timestamp) {
     return toTimestamp(0);
@@ -103,22 +102,22 @@ library TimestampLib {
         return neTimestamp(a, b);
     }
 
-    /// @dev return true if Timestamp is larger than 0
-    function gtz(Timestamp timestamp) public pure returns (bool) {
-        return Timestamp.unwrap(timestamp) > 0;
-    }
-
     /// @dev return true if Timestamp equals 0
     function eqz(Timestamp timestamp) public pure returns (bool) {
         return Timestamp.unwrap(timestamp) == 0;
     }
 
+    /// @dev return true if Timestamp is larger than 0
+    function gtz(Timestamp timestamp) public pure returns (bool) {
+        return Timestamp.unwrap(timestamp) > 0;
+    }
+
     /// @dev return true if Timestamp a is not equal to Timestamp b
     function addSeconds(
         Timestamp timestamp,
-        uint256 timeDelta
+        Seconds duration
     ) public pure returns (Timestamp) {
-        return toTimestamp(Timestamp.unwrap(timestamp) + uint40(timeDelta));
+        return toTimestamp(Timestamp.unwrap(timestamp) + duration.toInt());
     }
 
     function toInt(Timestamp timestamp) public pure returns (uint256) {

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