@etherisc/gif-next 0.0.2-f0d86c2-077 → 0.0.2-f1fe735-758

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

@@ -1,7 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-
-import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+pragma solidity ^0.8.20;
 
 /// @dev UFixed is a fixed point number with 18 decimals precision.
 type UFixed is uint256;
@@ -16,9 +14,16 @@ using {
     ltUFixed as <,
     lteUFixed as <=,
     eqUFixed as ==,
-    UFixedMathLib.toInt
+    neUFixed as !=,
+    UFixedLib.toInt,
+    UFixedLib.gtz
 } for UFixed global;
 
+// TODO move to UFixedLib and rename to zero()
+function zeroUFixed() pure returns (UFixed zero) {
+    return UFixed.wrap(0);
+}
+
 function addUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return UFixed.wrap(UFixed.unwrap(a) + UFixed.unwrap(b));
 }
@@ -30,14 +35,14 @@ function subUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 
 function mulUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return
-        UFixed.wrap(Math.mulDiv(UFixed.unwrap(a), UFixed.unwrap(b), 10 ** 18));
+        UFixed.wrap(MathLib.mulDiv(UFixed.unwrap(a), UFixed.unwrap(b), 10 ** 18));
 }
 
 function divUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     require(UFixed.unwrap(b) > 0, "ERROR:UFM-020:DIVISOR_ZERO");
 
     return
-        UFixed.wrap(Math.mulDiv(UFixed.unwrap(a), 10 ** 18, UFixed.unwrap(b)));
+        UFixed.wrap(MathLib.mulDiv(UFixed.unwrap(a), 10 ** 18, UFixed.unwrap(b)));
 }
 
 function gtUFixed(UFixed a, UFixed b) pure returns (bool isGreaterThan) {
@@ -60,6 +65,10 @@ function eqUFixed(UFixed a, UFixed b) pure returns (bool isEqual) {
     return UFixed.unwrap(a) == UFixed.unwrap(b);
 }
 
+function neUFixed(UFixed a, UFixed b) pure returns (bool isEqual) {
+    return UFixed.unwrap(a) != UFixed.unwrap(b);
+}
+
 function gtzUFixed(UFixed a) pure returns (bool isZero) {
     return UFixed.unwrap(a) > 0;
 }
@@ -76,7 +85,115 @@ function deltaUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return b - a;
 }
 
-library UFixedMathLib {
+/// @dev copied from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.3/contracts/utils/math/Math.sol
+library MathLib {
+
+    enum Rounding {
+        Down, // Toward negative infinity
+        Up, // Toward infinity
+        Zero // Toward zero
+    }
+
+    /**
+     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
+     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
+     * with further edits by Uniswap Labs also under MIT license.
+     */
+    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
+        unchecked {
+            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
+            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
+            // variables such that product = prod1 * 2^256 + prod0.
+            uint256 prod0; // Least significant 256 bits of the product
+            uint256 prod1; // Most significant 256 bits of the product
+            assembly {
+                let mm := mulmod(x, y, not(0))
+                prod0 := mul(x, y)
+                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
+            }
+
+            // Handle non-overflow cases, 256 by 256 division.
+            if (prod1 == 0) {
+                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
+                // The surrounding unchecked block does not change this fact.
+                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
+                return prod0 / denominator;
+            }
+
+            // Make sure the result is less than 2^256. Also prevents denominator == 0.
+            require(denominator > prod1, "Math: mulDiv overflow");
+
+            ///////////////////////////////////////////////
+            // 512 by 256 division.
+            ///////////////////////////////////////////////
+
+            // Make division exact by subtracting the remainder from [prod1 prod0].
+            uint256 remainder;
+            assembly {
+                // Compute remainder using mulmod.
+                remainder := mulmod(x, y, denominator)
+
+                // Subtract 256 bit number from 512 bit number.
+                prod1 := sub(prod1, gt(remainder, prod0))
+                prod0 := sub(prod0, remainder)
+            }
+
+            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
+            // See https://cs.stackexchange.com/q/138556/92363.
+
+            // Does not overflow because the denominator cannot be zero at this stage in the function.
+            uint256 twos = denominator & (~denominator + 1);
+            assembly {
+                // Divide denominator by twos.
+                denominator := div(denominator, twos)
+
+                // Divide [prod1 prod0] by twos.
+                prod0 := div(prod0, twos)
+
+                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
+                twos := add(div(sub(0, twos), twos), 1)
+            }
+
+            // Shift in bits from prod1 into prod0.
+            prod0 |= prod1 * twos;
+
+            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
+            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
+            // four bits. That is, denominator * inv = 1 mod 2^4.
+            uint256 inverse = (3 * denominator) ^ 2;
+
+            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
+            // in modular arithmetic, doubling the correct bits in each step.
+            inverse *= 2 - denominator * inverse; // inverse mod 2^8
+            inverse *= 2 - denominator * inverse; // inverse mod 2^16
+            inverse *= 2 - denominator * inverse; // inverse mod 2^32
+            inverse *= 2 - denominator * inverse; // inverse mod 2^64
+            inverse *= 2 - denominator * inverse; // inverse mod 2^128
+            inverse *= 2 - denominator * inverse; // inverse mod 2^256
+
+            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
+            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
+            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
+            // is no longer required.
+            result = prod0 * inverse;
+            return result;
+        }
+    }
+
+    /**
+     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
+     */
+    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
+        uint256 result = mulDiv(x, y, denominator);
+        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
+            result += 1;
+        }
+        return result;
+    }
+
+}
+
+library UFixedLib {
     int8 public constant EXP = 18;
     uint256 public constant MULTIPLIER = 10 ** uint256(int256(EXP));
     uint256 public constant MULTIPLIER_HALF = MULTIPLIER / 2;
@@ -123,23 +240,23 @@ library UFixedMathLib {
     function toIntWithRounding(UFixed a, uint8 rounding) public pure returns (uint256) {
         if (rounding == ROUNDING_HALF_UP()) {
             return
-                Math.mulDiv(
+                MathLib.mulDiv(
                     UFixed.unwrap(a) + MULTIPLIER_HALF,
                     1,
                     MULTIPLIER,
-                    Math.Rounding.Down
+                    MathLib.Rounding.Down
                 );
         } else if (rounding == ROUNDING_DOWN()) {
             return
-                Math.mulDiv(
+                MathLib.mulDiv(
                     UFixed.unwrap(a),
                     1,
                     MULTIPLIER,
-                    Math.Rounding.Down
+                    MathLib.Rounding.Down
                 );
         } else {
             return
-                Math.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, Math.Rounding.Up);
+                MathLib.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, MathLib.Rounding.Up);
         }
     }
 

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

@@ -1,20 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 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
@@ -23,6 +26,7 @@ using {
     versionGt as >,
     versionEq as ==,
     VersionLib.toInt,
+    VersionLib.toUint64,
     VersionLib.toMajorPart,
     VersionLib.toVersionParts
 }
@@ -34,6 +38,8 @@ function versionEq(Version a, Version b) pure returns(bool isSame) { return Vers
 library VersionLib {
     function toInt(Version version) external pure returns(uint) { return Version.unwrap(version); }
 
+    function toUint64(Version version) external pure returns(uint64) { return Version.unwrap(version); }
+
     function toMajorPart(Version version)
         external    
         pure 
@@ -89,6 +95,13 @@ library VersionLib {
                 (major << 16) + (minor << 8) + patch));
     }
 
+    // TODO check for overflow?
+    function toVersion(uint64 versionNumber) external pure returns(Version) {
+        //assert(versionNumber <= type(Version).max);
+        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-f0d86c2-077",
+  "version": "0.0.2-f1fe735-758",
   "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,10 +43,13 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@openzeppelin/contracts": "^4.9.3",
-    "@openzeppelin/contracts-upgradeable": "^4.9.3",
+    "@openzeppelin/contracts": "5.0.0",
+    "@openzeppelin/contracts-upgradeable": "5.0.0",
+    "@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/ac8b1a0ba35c3a8a508882d70043ad3f.json"
-}

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

@@ -1,174 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "BaseComponent",
-  "sourceName": "contracts/components/BaseComponent.sol",
-  "abi": [
-    {
-      "inputs": [],
-      "name": "getData",
-      "outputs": [
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getInstance",
-      "outputs": [
-        {
-          "internalType": "contract IInstance",
-          "name": "instance",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getNftId",
-      "outputs": [
-        {
-          "internalType": "NftId",
-          "name": "nftId",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getOwner",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "owner",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getParentNftId",
-      "outputs": [
-        {
-          "internalType": "NftId",
-          "name": "nftId",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getRegistry",
-      "outputs": [
-        {
-          "internalType": "contract IRegistry",
-          "name": "registry",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getToken",
-      "outputs": [
-        {
-          "internalType": "contract IERC20Metadata",
-          "name": "token",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getType",
-      "outputs": [
-        {
-          "internalType": "ObjectType",
-          "name": "objectType",
-          "type": "uint8"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getWallet",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "walletAddress",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "lock",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "register",
-      "outputs": [
-        {
-          "internalType": "NftId",
-          "name": "componentId",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes4",
-          "name": "interfaceId",
-          "type": "bytes4"
-        }
-      ],
-      "name": "supportsInterface",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "unlock",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    }
-  ],
-  "bytecode": "0x",
-  "deployedBytecode": "0x",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}

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

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

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

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