@etherisc/gif-next 0.0.2-f7c17b4-297 → 0.0.2-f7d1200-068

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

@@ -12,6 +12,12 @@ using {
     lteTimestamp as <=,
     eqTimestamp as ==,
     neTimestamp as !=,
+    TimestampLib.eq,
+    TimestampLib.ne,
+    TimestampLib.gt,
+    TimestampLib.gte,
+    TimestampLib.lt,
+    TimestampLib.lte,
     TimestampLib.gtz,
     TimestampLib.eqz,
     TimestampLib.addSeconds,
@@ -50,18 +56,32 @@ function neTimestamp(Timestamp a, Timestamp b) pure returns (bool) {
 
 /// @dev Converts the uint256 to a Timestamp.
 function toTimestamp(uint256 timestamp) pure returns (Timestamp) {
-    return Timestamp.wrap(uint40(timestamp));
+    return TimestampLib.toTimestamp(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));
     }
+
+    function toTimestamp(uint256 timestamp) public pure returns (Timestamp) {
+        return Timestamp.wrap(uint40(timestamp));
+    }
     
     /// @dev return true if Timestamp a is after Timestamp b
     function gt(Timestamp a, Timestamp b) public pure returns (bool isAfter) {

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

@@ -15,10 +15,13 @@ using {
     lteUFixed as <=,
     eqUFixed as ==,
     neUFixed as !=,
+    UFixedLib.gt,
+    UFixedLib.gtz,
     UFixedLib.toInt,
-    UFixedLib.gtz
+    UFixedLib.toInt1000
 } for UFixed global;
 
+// TODO move to UFixedLib and rename to zero()
 function zeroUFixed() pure returns (UFixed zero) {
     return UFixed.wrap(0);
 }
@@ -28,7 +31,9 @@ function addUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 }
 
 function subUFixed(UFixed a, UFixed b) pure returns (UFixed) {
-    require(a >= b, "ERROR:UFM-010:NEGATIVE_RESULT");
+    if (a < b) {
+        revert UFixedLib.UFixedLibNegativeResult();
+    }
     return UFixed.wrap(UFixed.unwrap(a) - UFixed.unwrap(b));
 }
 
@@ -38,8 +43,10 @@ function mulUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 }
 
 function divUFixed(UFixed a, UFixed b) pure returns (UFixed) {
-    require(UFixed.unwrap(b) > 0, "ERROR:UFM-020:DIVISOR_ZERO");
-
+    if (UFixed.unwrap(b) == 0) {
+        revert UFixedLib.UFixedLibDivisionByZero();
+    }
+    
     return
         UFixed.wrap(MathLib.mulDiv(UFixed.unwrap(a), 10 ** 18, UFixed.unwrap(b)));
 }
@@ -87,6 +94,8 @@ function deltaUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 /// @dev copied from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.3/contracts/utils/math/Math.sol
 library MathLib {
 
+    error MathLigMulDivOverflow();
+
     enum Rounding {
         Down, // Toward negative infinity
         Up, // Toward infinity
@@ -120,8 +129,10 @@ library MathLib {
             }
 
             // Make sure the result is less than 2^256. Also prevents denominator == 0.
-            require(denominator > prod1, "Math: mulDiv overflow");
-
+            if (denominator <= prod1) {
+                revert MathLigMulDivOverflow();
+            }
+            
             ///////////////////////////////////////////////
             // 512 by 256 division.
             ///////////////////////////////////////////////
@@ -193,6 +204,12 @@ library MathLib {
 }
 
 library UFixedLib {
+    error UFixedLibNegativeResult();
+    error UFixedLibDivisionByZero();
+
+    error UFixedLibExponentTooSmall(int8 exp);
+    error UFixedLibExponentTooLarge(int8 exp);
+
     int8 public constant EXP = 18;
     uint256 public constant MULTIPLIER = 10 ** uint256(int256(EXP));
     uint256 public constant MULTIPLIER_HALF = MULTIPLIER / 2;
@@ -219,9 +236,13 @@ library UFixedLib {
 
     /// @dev Converts the uint256 to a UFixed with given exponent.
     function toUFixed(uint256 a, int8 exp) public pure returns (UFixed) {
-        require(EXP + exp >= 0, "ERROR:FM-010:EXPONENT_TOO_SMALL");
-        require(EXP + exp <= 64, "ERROR:FM-011:EXPONENT_TOO_LARGE");
-
+        if (EXP + exp < 0) {
+            revert UFixedLibExponentTooSmall(exp);
+        }
+        if (EXP + exp > 64) {
+            revert UFixedLibExponentTooLarge(exp);
+        }
+        
         return UFixed.wrap(a * 10 ** uint8(EXP + exp));
     }
 
@@ -235,6 +256,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/contracts/{shared → upgradeability}/IVersionable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Version} from "../types/Version.sol";
+import {Version} from "../type/Version.sol";
 
 /// IMPORTANT
 // Upgradeable contract MUST:

package/contracts/{shared → upgradeability}/ProxyManager.sol

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 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 "../types/Blocknumber.sol";
+import {Blocknumber, blockNumber} from "../type/Blocknumber.sol";
 import {IVersionable} from "./IVersionable.sol";
-import {NftOwnable} from "./NftOwnable.sol";
-import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
-import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
-import {Timestamp, TimestampLib} from "../types/Timestamp.sol";
+import {NftId} from "../type/NftId.sol";
+import {NftOwnable} from "../shared/NftOwnable.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
 import {UpgradableProxyWithAdmin} from "./UpgradableProxyWithAdmin.sol";
-import {Version, VersionLib} from "../types/Version.sol";
+import {Version, VersionLib} from "../type/Version.sol";
 
 /// @dev manages proxy deployments for upgradable contracs of type IVersionable
 contract ProxyManager is
@@ -79,6 +79,31 @@ contract ProxyManager is
         emit LogProxyManagerVersionableDeployed(address(_proxy), initialImplementation);
     }
 
+    function deployDetermenistic(address initialImplementation, bytes memory initializationData, bytes32 salt)
+        public
+        virtual
+        onlyOwner()
+        returns (IVersionable versionable)
+    {
+        if (_versions.length > 0) {
+            revert ErrorProxyManagerAlreadyDeployed();
+        }
+
+        address currentProxyOwner = getOwner();
+        address initialProxyAdminOwner = address(this);
+
+        _proxy = new UpgradableProxyWithAdmin{salt: salt}(
+            initialImplementation,
+            initialProxyAdminOwner,
+            getDeployData(currentProxyOwner, initializationData)
+        );
+
+        versionable = IVersionable(address(_proxy));
+        _updateVersionHistory(versionable.getVersion(), initialImplementation, currentProxyOwner);
+
+        emit LogProxyManagerVersionableDeployed(address(_proxy), initialImplementation);
+    }
+
     /// @dev upgrade existing contract
     function upgrade(address newImplementation, bytes memory upgradeData)
         public
@@ -106,6 +131,10 @@ contract ProxyManager is
 
     }
 
+    function linkToProxy() public returns (NftId) {
+        return _linkToNftOwnable(address(_proxy));
+    }
+
     function getDeployData(address proxyOwner, bytes memory deployData) public pure returns (bytes memory data) {
         return abi.encodeWithSelector(
             IVersionable.initializeVersionable.selector, 
@@ -119,7 +148,7 @@ contract ProxyManager is
             upgradeData);
     }
 
-    function getProxy() public returns (UpgradableProxyWithAdmin) {
+    function getProxy() public view returns (UpgradableProxyWithAdmin) {
         return _proxy;
     }
 

package/contracts/{shared → upgradeability}/UpgradableProxyWithAdmin.sol

@@ -2,9 +2,7 @@
 pragma solidity ^0.8.20;
 
 import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
-import {TransparentUpgradeableProxy, ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
-
-import {IVersionable} from "./IVersionable.sol";
+import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
 contract UpgradableProxyWithAdmin is TransparentUpgradeableProxy {
 

package/contracts/{shared → upgradeability}/Versionable.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.20;
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 import {IVersionable} from "./IVersionable.sol";
-import {Version, VersionLib} from "../types/Version.sol";
+import {Version, VersionLib} from "../type/Version.sol";
 
 
 abstract contract Versionable is 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-f7c17b4-297",
+  "version": "0.0.2-f7d1200-068",
   "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",
+    "@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/Component.sol/Component.dbg.json

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/artifacts/contracts/instance/BundleManager.sol/BundleManager.dbg.json

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