@etherisc/gif-next 0.0.2-d64ea51-772 → 0.0.2-d696c44-627

package/contracts/type/Seconds.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+type Seconds is uint40;
+
+using {
+    SecondsEq as ==,
+    SecondsGt as >,
+    SecondsLib.eqz,
+    SecondsLib.gtz,
+    SecondsLib.toInt
+} for Seconds global;
+
+function SecondsEq(Seconds duration1, Seconds duration2) pure returns (bool) {
+    return SecondsLib.eq(duration1, duration2);
+}
+
+function SecondsGt(Seconds duration1, Seconds duration2) pure returns (bool) {
+    return SecondsLib.gt(duration1, duration2);
+}
+
+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());
+    }
+
+    function oneDay() public pure returns (Seconds duration) {
+        return Seconds.wrap(24 * 3600);
+    }
+
+    function oneYear() public pure returns (Seconds duration) {
+        return Seconds.wrap(365 * 24 * 3600);
+    }
+
+    /// @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;
+    }
+
+    /// @dev return true iff duration1 and duration2 are the same
+    function eq(Seconds duration1, Seconds duration2) public pure returns (bool) {
+        return Seconds.unwrap(duration1) == Seconds.unwrap(duration2);
+    }
+
+    /// @dev return true if duration1 is larger than duration2
+    function gt(Seconds duration1, Seconds duration2) public pure returns (bool) {
+        return Seconds.unwrap(duration1) > Seconds.unwrap(duration2);
+    }
+
+    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/type/Selector.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+type Selector is bytes4;
+
+// type bindings
+using {
+    eqSelector as ==, 
+    neSelector as !=, 
+    SelectorLib.toBytes4,
+    SelectorLib.eqz
+} for Selector global;
+
+// pure free functions for operators
+function eqSelector(Selector s1, Selector s2) pure returns (bool isSame) {
+    return SelectorLib.eq(s1, s2);
+}
+
+function neSelector(Selector s1, Selector s2) pure returns (bool isDifferent) {
+    return SelectorLib.ne(s1, s2);
+}
+
+// library functions that operate on user defined type
+library SelectorLib {
+
+    function zero() public pure returns (Selector) {
+        return Selector.wrap("");
+    }
+
+    function eqz(Selector s) public pure returns (bool) {
+        return Selector.unwrap(s) == "";
+    }
+
+    function eq(Selector s1, Selector s2) public pure returns (bool isSame) {
+        return Selector.unwrap(s1) == Selector.unwrap(s2);
+    }
+
+    function ne(Selector s1, Selector s2) public pure returns (bool isDifferent) {
+        return Selector.unwrap(s1) != Selector.unwrap(s2);
+    }
+
+    function toSelector(bytes4 selector) public pure returns (Selector) {
+        return Selector.wrap(selector);
+    }
+
+    function toBytes4(Selector s) public pure returns (bytes4) {
+        return Selector.unwrap(s);
+    }
+}
+
+// selector specific set library
+// based on https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/structs/EnumerableSet.sol
+library SelectorSetLib {
+
+    struct Set {
+        Selector[] selectors;
+        mapping(Selector selector => uint256 index) at;
+    }
+
+    function add(Set storage set, Selector selector) external {
+        // selector already in set
+        if (set.at[selector] > 0) { return; }
+
+        set.selectors.push(selector);
+        set.at[selector] = set.selectors.length;
+    }
+
+    function remove(Set storage set, Selector selector) external {
+        uint256 selectorIndex = set.at[selector];
+
+        // selector not in set
+        if (selectorIndex == 0) {return; }
+
+        uint256 toDeleteIndex = selectorIndex - 1;
+        uint256 lastIndex = set.selectors.length - 1;
+
+        if (lastIndex != toDeleteIndex) {
+            Selector lastSelector = set.selectors[lastIndex];
+            set.selectors[toDeleteIndex] = lastSelector;
+            set.at[lastSelector] = selectorIndex; // Replace lastValue's index to valueIndex
+        }
+
+        set.selectors.pop();
+        delete set.at[selector];
+    }
+
+    function isEmpty(Set storage set) external view returns(bool empty) {
+        return set.selectors.length == 0;
+    }
+
+    function contains(Set storage set, Selector selector) external view returns(bool inSet) {
+        return set.at[selector] > 0;
+    }
+
+    function size(Set storage set) external view returns(uint256 length) {
+        return set.selectors.length;
+    }
+
+    function at(Set storage set, uint256 index) external view returns(Selector selector) {
+        return set.selectors[index];
+    }
+}

package/contracts/{types → type}/StateId.sol

@@ -14,6 +14,23 @@ using {
 } for StateId global;
 
 // general pure free functions
+
+function INITIAL() pure returns (StateId) {
+    return toStateId(1);
+}
+
+function SCHEDULED() pure returns (StateId) {
+    return toStateId(2);
+}
+
+function DEPLOYING() pure returns (StateId) {
+    return toStateId(3);
+}
+
+function ACTIVE() pure returns (StateId) {
+    return toStateId(4);
+}
+
 function APPLIED() pure returns (StateId) {
     return toStateId(10);
 }
@@ -26,20 +43,32 @@ function DECLINED() pure returns (StateId) {
     return toStateId(30);
 }
 
-function UNDERWRITTEN() pure returns (StateId) {
+function COLLATERALIZED() pure returns (StateId) {
     return toStateId(40);
 }
 
-function CONFIRMED() pure returns (StateId) {
+function SUBMITTED() pure returns (StateId) {
     return toStateId(50);
 }
 
+function CONFIRMED() pure returns (StateId) {
+    return toStateId(51);
+}
+
 function EXPECTED() pure returns (StateId) {
     return toStateId(60);
 }
 
-function ACTIVE() pure returns (StateId) {
-    return toStateId(100);
+function FULFILLED() pure returns (StateId) {
+    return toStateId(70);
+}
+
+function FAILED() pure returns (StateId) {
+    return toStateId(7);
+}
+
+function CANCELLED() pure returns (StateId) {
+    return toStateId(72);
 }
 
 function PAUSED() pure returns (StateId) {
@@ -67,6 +96,7 @@ function toStateId(uint256 id) pure returns (StateId) {
     return StateId.wrap(uint8(id));
 }
 
+// TODO move to StateIdLib and rename to zero()
 /// @dev Return the StateId zero (0)
 function zeroStateId() pure returns (StateId) {
     return StateId.wrap(0);

package/contracts/type/String.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ShortString, ShortStrings} from "@openzeppelin/contracts/utils/ShortStrings.sol";
+
+type Str is bytes32;
+
+using {
+    StrEq as ==,
+    StrNe as !=,
+    StrLib.toString,
+    StrLib.length
+} for Str global;
+
+function StrEq(Str s1, Str s2) pure returns (bool) {
+    return StrLib.eq(s1, s2);
+}
+
+function StrNe(Str s1, Str s2) pure returns (bool) {
+    return StrLib.ne(s1, s2);
+}
+
+library StrLib {
+
+
+    /// @dev converts the provided string into a short string.
+    /// uses ShortStrings.toShortString
+    function toStr(string memory str) public pure returns (Str) {
+        return Str.wrap(ShortString.unwrap(ShortStrings.toShortString(str)));
+    }
+
+    /// @dev return true iff s1 equals s2
+    function eq(Str s1, Str s2) public pure returns (bool) {
+        return Str.unwrap(s1) == Str.unwrap(s2);
+    }
+
+    /// @dev return true iff s1 differs from s2
+    function ne(Str s1, Str s2) public pure returns (bool) {
+        return Str.unwrap(s1) != Str.unwrap(s2);
+    }
+
+    /// @dev converts the provided short string into a string.
+    /// uses ShortStrings.toString
+    function toString(Str str) public pure returns (string memory) {
+        return ShortStrings.toString(ShortString.wrap(Str.unwrap(str)));
+    }
+
+    /// @dev converts the provided short string into a string.
+    /// uses ShortStrings.byteLength
+    function length(Str str) public pure returns (uint256 byteLength) {
+        return ShortStrings.byteLength(ShortString.wrap(Str.unwrap(str)));
+    }
+}

package/contracts/{types → type}/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,16 +53,22 @@ function toTimestamp(uint256 timestamp) pure returns (Timestamp) {
     return Timestamp.wrap(uint40(timestamp));
 }
 
-// function blockTimestamp() view returns (Timestamp) {
-//     return toTimestamp(block.timestamp);
-// }
-
+// TODO move to TimestampLib and rename to zero()
 /// @dev Return the Timestamp zero (0)
 function zeroTimestamp() pure returns (Timestamp) {
-    return toTimestamp(0);
+    return Timestamp.wrap(0);
 }
 
 library TimestampLib {
+
+    function zero() public pure returns (Timestamp) {
+        return Timestamp.wrap(0);
+    }
+
+    function max() public pure returns (Timestamp) {
+        return Timestamp.wrap(type(uint40).max);
+    }
+    
     function blockTimestamp() public view returns (Timestamp) {
         return Timestamp.wrap(uint40(block.timestamp));
     }
@@ -103,22 +112,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 → type}/UFixed.sol

@@ -16,9 +16,11 @@ using {
     eqUFixed as ==,
     neUFixed as !=,
     UFixedLib.toInt,
+    UFixedLib.toInt1000,
     UFixedLib.gtz
 } for UFixed global;
 
+// TODO move to UFixedLib and rename to zero()
 function zeroUFixed() pure returns (UFixed zero) {
     return UFixed.wrap(0);
 }
@@ -235,6 +237,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()) {

package/contracts/{types → type}/Version.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 type VersionPart is uint8;
 
@@ -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)); }
 }
 
@@ -101,6 +103,7 @@ library VersionLib {
         return Version.wrap(uint24(versionNumber));
     }
 
+    // TODO rename to zero()
     function zeroVersion() external pure returns(Version) {
         return Version.wrap(0);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-d64ea51-772",
+  "version": "0.0.2-d696c44-627",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {
@@ -30,10 +30,11 @@
   "homepage": "https://github.com/etherisc/gif-next#readme",
   "devDependencies": {
     "@nomicfoundation/hardhat-foundry": "^1.1.1",
-    "@nomicfoundation/hardhat-toolbox": "^3.0.0",
-    "@nomicfoundation/hardhat-verify": "^1.1.1",
-    "@typescript-eslint/eslint-plugin": "^6.7.2",
-    "@typescript-eslint/parser": "^6.7.2",
+    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
+    "@nomicfoundation/hardhat-verify": "^2.0.1",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@typescript-eslint/parser": "^7.1.0",
+    "antlr4ng-cli": "^2.0.0",
     "dotenv": "^16.3.1",
     "eslint": "^8.50.0",
     "hardhat": "^2.17.2",
@@ -42,9 +43,11 @@
     "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",
     "ethers": "^6.7.1",
     "solidity-docgen": "^0.6.0-beta.36",
     "winston": "^3.10.0"

package/artifacts/contracts/components/BaseComponent.sol/BaseComponent.dbg.json

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