@etherisc/gif-next 0.0.2-cff6256-424 → 0.0.2-d086e6d-456

package/contracts/shared/Service.sol

@@ -1,24 +1,34 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {IRegistry} from "../registry/IRegistry.sol";
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.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,
+    AccessManagedUpgradeable,
     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 +41,23 @@ 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(IAccessManaged).interfaceId);
+        registerInterface(type(IService).interfaceId);
     }
 }

package/contracts/shared/TokenHandler.sol

@@ -4,6 +4,8 @@ pragma solidity ^0.8.20;
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
+/// @dev token specific transfer helper
+/// relies internally on oz SafeERC20.safeTransferFrom
 contract TokenHandler {
     IERC20Metadata private _token;
 
@@ -11,17 +13,21 @@ contract TokenHandler {
         _token = IERC20Metadata(token);
     }
 
-    // TODO add logging
     function transfer(
         address from,
         address to,
-        uint256 amount // TODO add authz (only treasury/instance/product/pool/ service)
-    ) external {
+        uint256 amount
+    )
+        external
+    {
         SafeERC20.safeTransferFrom(_token, from, to, amount);
-        // _token.transferFrom(from, to, amount);
     }
 
-    function getToken() external view returns (IERC20Metadata) {
+    function getToken()
+        external
+        view 
+        returns (IERC20Metadata)
+    {
         return _token;
     }
 }

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

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {UFixed, UFixedLib} from "./UFixed.sol";
+
+type Amount is uint96;
+
+using {
+    AmountLib.eqz,
+    AmountLib.gtz,
+    AmountLib.toInt,
+    AmountLib.toUFixed
+} for Amount global;
+
+
+library AmountLib {
+
+    error ErrorAmountLibValueTooBig(uint256 amount);
+
+    function zero() public pure returns (Amount) {
+        return Amount.wrap(0);
+    }
+
+    function max() public pure returns (Amount) {
+        return Amount.wrap(_max());
+    }
+
+    /// @dev converts the uint amount into Amount
+    /// function reverts if value is exceeding max Amount value
+    function toAmount(uint256 amount) public pure returns (Amount) {
+        if(amount > _max()) {
+            revert ErrorAmountLibValueTooBig(amount);
+        }
+
+        return Amount.wrap(uint96(amount));
+    }
+
+    /// @dev return true if amount equals 0
+    function eqz(Amount amount) public pure returns (bool) {
+        return Amount.unwrap(amount) == 0;
+    }
+
+    /// @dev return true if amount is larger than 0
+    function gtz(Amount amount) public pure returns (bool) {
+        return Amount.unwrap(amount) > 0;
+    }
+
+    function toInt(Amount amount) public pure returns (uint256) {
+        return uint256(uint96(Amount.unwrap(amount)));
+    }
+
+    function toUFixed(Amount amount) public pure returns (UFixed) {
+        return UFixedLib.toUFixed(Amount.unwrap(amount));
+    }
+
+    function _max() internal pure returns (uint96) {
+        // IMPORTANT: type nees to match with actual definition for Amount
+        return type(uint96).max;
+    }
+}

package/contracts/types/Blocknumber.sol

@@ -52,6 +52,7 @@ function blockBlocknumber() view returns (Blocknumber) {
     return toBlocknumber(block.number);
 }
 
+// TODO move to BlocknumberLib and rename to zero()
 /// @dev Return the Blocknumber zero (0)
 function zeroBlocknumber() pure returns (Blocknumber) {
     return toBlocknumber(0);

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

@@ -21,10 +21,13 @@ library FeeLib {
             uint256 netAmount
         )
     {
-        UFixed fractionalAmount = UFixedLib.toUFixed(amount) *
-            fee.fractionalFee;
-        feeAmount = fractionalAmount.toInt() + fee.fixedFee;
-        netAmount = amount - feeAmount;
+        netAmount = amount;
+        if(gtz(fee)) {
+            UFixed fractionalAmount = 
+                UFixedLib.toUFixed(amount) * fee.fractionalFee;
+            feeAmount = fractionalAmount.toInt() + fee.fixedFee;
+            netAmount -= feeAmount;
+        }
     }
 
     /// @dev Converts the uint256 to a fee struct.
@@ -40,6 +43,7 @@ library FeeLib {
         return Fee(UFixedLib.toUFixed(percent, -2), 0);
     }
 
+    // TODO rename to zero
     /// @dev Return a zero fee struct (0, 0)
     function zeroFee() public pure returns (Fee memory fee) {
         return Fee(UFixed.wrap(0), 0);
@@ -50,7 +54,11 @@ library FeeLib {
         return a.fixedFee == b.fixedFee && a.fractionalFee == b.fractionalFee;
     }
 
-    function feeIsZero(Fee memory fee) public pure returns (bool) {
+    function gtz(Fee memory fee) public pure returns (bool) {
+        return UFixed.unwrap(fee.fractionalFee) > 0 || fee.fixedFee > 0;
+    }
+
+    function eqz(Fee memory fee) public pure returns (bool) {
         return fee.fixedFee == 0 && UFixed.unwrap(fee.fractionalFee) == 0;
     }
 }

package/contracts/types/NftId.sol

@@ -24,6 +24,7 @@ function toNftId(uint256 id) pure returns (NftId) {
     return NftId.wrap(uint96(id));
 }
 
+// TODO move to NftIdLib and rename to zero()
 /// @dev Return the NftId zero (0)
 function zeroNftId() pure returns (NftId) {
     return NftId.wrap(0);
@@ -40,6 +41,13 @@ function neNftId(NftId a, NftId b) pure returns (bool isDifferent) {
 
 // library functions that operate on user defined type
 library NftIdLib {
+
+    /// @dev the zero nft id
+    /// is never a valid nft id and implies a non-initialized value
+    function zero() public pure returns (NftId) {
+        return NftId.wrap(0);
+    }
+
     /// @dev Converts the NftId to a uint256.
     function toInt(NftId nftId) public pure returns (uint96) {
         return uint96(NftId.unwrap(nftId));

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) {
@@ -111,6 +115,7 @@ function toObjectType(uint256 objectType) pure returns (ObjectType) {
     return ObjectType.wrap(uint8(objectType));
 }
 
+// TODO move to ObjecTypeLib and rename to zero()
 /// @dev Return the ObjectType zero (0)
 function zeroObjectType() pure returns (ObjectType) {
     return ObjectType.wrap(0);

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

@@ -82,4 +82,8 @@ library ReferralLib {
     function toKeyId(ReferralId id) public pure returns (KeyId keyId) {
         return KeyId.wrap(bytes31(ReferralId.unwrap(id)));
     }
+
+    function eqz(ReferralId id) public pure returns (bool) {
+        return eqReferralId(id, zero());
+    }
 }