@etherisc/gif-next 0.0.2-de0a1d3-009 → 0.0.2-e1e92ab-754

package/contracts/shared/Versionable.sol

@@ -1,99 +1,147 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {Initializable} from "@openzeppelin5/contracts/proxy/utils/Initializable.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 import {Blocknumber, blockNumber} from "../types/Blocknumber.sol";
 import {Timestamp, blockTimestamp} from "../types/Timestamp.sol";
-import {Version, VersionPart} from "../types/Version.sol";
+import {Version, VersionPart, VersionLib} from "../types/Version.sol";
 
 import {IVersionable} from "./IVersionable.sol";
 
-abstract contract Versionable is Initializable, IVersionable {
 
-    mapping(Version version => VersionInfo info) private _versionHistory;
-    Version [] private _versions;
 
+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;
 
-    // controlled activation for controller contract
-    constructor() {
-        _activate(address(0), msg.sender);
-    }
 
-    // IMPORTANT this function needs to be implemented by each new version
-    // and needs to call internal function call _activate() 
-    function initialize(address implementation, address activatedBy, bytes memory initializationData)
-        external
-        virtual
-    { 
-        _activate(implementation, activatedBy);
+    /// @custom:storage-location erc7201:gif-next.contracts.shared.Versionable.sol
+    struct VersionableStorage {
+        mapping(Version version => VersionInfo info) _versionHistory;
+        Version [] _versions;
+        Version _v1;
     }
-    // TODO mock, delete when implementations are ready
-    function activate(address implementation, address activatedBy, bytes memory activatinData) public {}
-    function upgrade(address implementation, address activatedBy, bytes memory upgradeData) external {}
 
 
-    // can only be called once per contract
-    // needs bo be called inside the proxy upgrade tx
-    function _activate(
+    constructor() {
+        _disableInitializers();
+    }
+    // TODO write test where new version of private _updateVersionHistory is added and used... 
+    function initialize(
         address implementation,
-        address activatedBy
+        address activatedBy,
+        bytes memory data
     )
-        internal
+        public
+        initializer
     {
-        Version thisVersion = getVersion();
-        require(
-            !isActivated(thisVersion),
-            "ERROR:VRN-001:VERSION_ALREADY_ACTIVATED"
-        );
-        
-        // require increasing version number
-        if(_versions.length > 0) {
-            Version lastVersion = _versions[_versions.length - 1];
-            require(
-                thisVersion > lastVersion,
-                "ERROR:VRN-002:VERSION_NOT_INCREASING"
-            );
-        }
+        _updateVersionHistory(implementation, activatedBy);
+        _initialize(activatedBy, data);
+    }
 
-        // update version history
-        _versions.push(thisVersion);
-        _versionHistory[thisVersion] = VersionInfo(
-            thisVersion,
-            implementation,
-            activatedBy,
-            blockTimestamp(),
-            blockNumber()
-        );
+    // TODO activatedBy MUST ALWAYS be an owner?
+    function upgrade(
+        address implementation,
+        address activatedBy,
+        bytes memory data
+    )
+        external
+        reinitializer(VersionLib.toUint64(getVersion()))
+    {
+        _updateVersionHistory(implementation, activatedBy);
+        _upgrade(data);
+    }
 
-        emit LogVersionableActivated(thisVersion, implementation, activatedBy);
+    function isInitialized(Version _version) public override view returns(bool) {
+        return _getVersionableStorage()._versionHistory[_version].activatedIn.toInt() > 0;
     }
 
+    function getVersion() public pure virtual returns(Version);
 
-    function isActivated(Version _version) public override view returns(bool) {
-        return _versionHistory[_version].activatedIn.toInt() > 0;
+    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 getVersion() public pure virtual returns(Version);
-
+    function getVersionInfo(Version _version) public override view returns(VersionInfo memory) {
+        return _getVersionableStorage()._versionHistory[_version];
+    }
 
-    function getVersionCount() external view override returns(uint256) {
-        return _versions.length;
+    function getInitializedVersion() public view returns(uint64) {
+        return _getInitializedVersion();
     }
 
 
-    function getVersion(uint256 idx) external view override returns(Version) {
-        return _versions[idx];
+
+    // IMPORTANT each version must implement this function 
+    // each implementation MUST use onlyInitialising modifier
+    // each implementation MUST call intializers of all base contracts...
+    function _initialize(address owner, bytes memory data) 
+        internal
+        onlyInitializing
+        virtual 
+    {
+        revert();
     }
 
 
-    function getVersionInfo(Version _version) external override view returns(VersionInfo memory) {
-        return _versionHistory[_version];
+    // IMPORTANT each version except version "1" must implement this function 
+    // each implementation MUST use onlyInitialising modifier
+    function _upgrade(bytes memory data)
+        internal
+        onlyInitializing
+        virtual
+    {
+        revert();
     }
 
-    function getInitializedVersion() external view returns(uint64)
+    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
     {
-        return _getInitializedVersion();
+        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,
+            blockTimestamp(),
+            blockNumber()
+        );
+
+        emit LogVersionableInitialized(thisVersion, implementation, activatedBy);
     }
 }

package/contracts/test/TestDistribution.sol

@@ -13,9 +13,10 @@ contract TestDistribution is Distribution {
         NftId instanceNftid,
         address token,
         bool isVerifying,
-        Fee memory distributionFee
+        Fee memory distributionFee,
+        address initialOwner
     )
-        Distribution(registry, instanceNftid, token, isVerifying, distributionFee)
+        Distribution(registry, instanceNftid, token, isVerifying, distributionFee, initialOwner)
     // solhint-disable-next-line no-empty-blocks
     {}
 }

package/contracts/test/TestFee.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {UFixed, UFixedMathLib} from "../types/UFixed.sol";
+import {UFixed, UFixedLib} from "../types/UFixed.sol";
 import {Fee, FeeLib} from "../types/Fee.sol";
 
 contract TestFee {
@@ -15,7 +15,7 @@ contract TestFee {
         pure 
         returns(Fee memory fee)
     {
-        return FeeLib.toFee(UFixedMathLib.toUFixed(fractionalValue, exponent), fixedValue);
+        return FeeLib.toFee(UFixedLib.toUFixed(fractionalValue, exponent), fixedValue);
     }
 
     function getZeroFee() external pure returns(Fee memory fee) {

package/contracts/test/TestPool.sol

@@ -13,13 +13,15 @@ contract TestPool is Pool {
         address registry,
         NftId instanceNftid,
         address token,
+        bool isInterceptor,
         bool isVerifying,
         UFixed collateralizationLevel,
         Fee memory poolFee,
         Fee memory stakingFee,
-        Fee memory performanceFee
+        Fee memory performanceFee,
+        address initialOwner
     )
-        Pool(registry, instanceNftid, token, isVerifying, collateralizationLevel, poolFee, stakingFee, performanceFee)
+        Pool(registry, instanceNftid, token, isInterceptor, isVerifying, collateralizationLevel, poolFee, stakingFee, performanceFee, initialOwner)
     // solhint-disable-next-line no-empty-blocks
     {}
 }

package/contracts/test/TestProduct.sol

@@ -19,12 +19,14 @@ contract TestProduct is Product {
         address registry,
         NftId instanceNftid,
         address token,
+        bool isInterceptor,
         address pool,
         address distribution,
         Fee memory productFee,
-        Fee memory processingFee
+        Fee memory processingFee,
+        address initialOwner
     )
-        Product(registry, instanceNftid, token, pool, distribution, productFee, processingFee)
+        Product(registry, instanceNftid, token, isInterceptor, pool, distribution, productFee, processingFee, initialOwner)
     // solhint-disable-next-line no-empty-blocks
     {
     }

package/contracts/test/TestRegisterable.sol

@@ -8,12 +8,11 @@ import {Registerable} from "../../contracts/shared/Registerable.sol";
 
 contract TestRegisterable is Registerable {
 
-    constructor(address registry, NftId registryNftId)
-        Registerable(registry, registryNftId)
+    constructor(address registry, NftId registryNftId, ObjectType objectType, bool isInterceptor, address initialOwner)
+        //Registerable(registry, registryNftId)
     // solhint-disable-next-line no-empty-blocks
-    {}
-
-    function getType() external pure override returns (ObjectType) {
-        return TOKEN();
+    {
+        bytes memory data = "";
+        _initializeRegisterable(registry, registryNftId, objectType, isInterceptor, initialOwner, data);
     }
 }

package/contracts/test/TestService.sol

@@ -8,25 +8,19 @@ import {ServiceBase} from "../../contracts/instance/base/ServiceBase.sol";
 import {IVersionable} from "../../contracts/shared/IVersionable.sol";
 import {Versionable} from "../../contracts/shared/Versionable.sol";
 
+//import {IService} from "../../contracts/instance/base/IService.sol";
+
 contract TestService is ServiceBase {
 
     string public constant NAME = "TestService";
 
-    constructor(address registry, NftId registryNftId)
-        ServiceBase(registry, registryNftId)
+    constructor(address registry, NftId registryNftId, address initialOwner)
     // solhint-disable-next-line no-empty-blocks
-    {}
-
-    function getVersion()
-        public 
-        pure 
-        virtual override (IVersionable, Versionable)
-        returns(Version)
     {
-        return VersionLib.toVersion(3,0,0);
+        _initializeServiceBase(registry, registryNftId, initialOwner);
     }
 
-    function getName() external pure override returns(string memory name) {
+    function getName() public pure override returns(string memory name) {
         return NAME;
     }
 }

package/contracts/types/Fee.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {UFixed, UFixedMathLib} from "./UFixed.sol";
+import {UFixed, UFixedLib} from "./UFixed.sol";
 
 struct Fee {
     UFixed fractionalFee;
@@ -21,7 +21,7 @@ library FeeLib {
             uint256 netAmount
         )
     {
-        UFixed fractionalAmount = UFixedMathLib.toUFixed(amount) *
+        UFixed fractionalAmount = UFixedLib.toUFixed(amount) *
             fee.fractionalFee;
         feeAmount = fractionalAmount.toInt() + fee.fixedFee;
         netAmount = amount - feeAmount;
@@ -37,7 +37,7 @@ library FeeLib {
 
     /// @dev Return the percent fee struct (x%, 0)
     function percentageFee(uint8 percent) public pure returns (Fee memory fee) {
-        return Fee(UFixedMathLib.toUFixed(percent, -2), 0);
+        return Fee(UFixedLib.toUFixed(percent, -2), 0);
     }
 
     /// @dev Return a zero fee struct (0, 0)

package/contracts/types/RoleId.sol

@@ -20,6 +20,13 @@ function ORACLE_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("
 function POOL_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("PoolOwnerRole"); }
 function PRODUCT_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId("ProductOwnerRole"); }
 
+function PRODUCT_REGISTRAR_ROLE() pure returns(uint64 roleId) { return 1; }
+function POOL_REGISTRAR_ROLE() pure returns(uint64 roleId) { return 2; }
+function DISTRIBUTION_REGISTRAR_ROLE() pure returns(uint64 roleId) { return 3; }
+function ORACLE_REGISTRAR_ROLE() pure returns(uint64 roleId) { return 4; }
+function POLICY_REGISTRAR_ROLE() pure returns(uint64 roleId) { return 5; }
+function BUNDLE_REGISTRAR_ROLE() pure returns(uint64 roleId) { return 6; }
+
 // @dev Returns true iff role ids a and b are identical
 function eqRoleId(RoleId a, RoleId b) pure returns (bool isSame) {
     return RoleId.unwrap(a) == RoleId.unwrap(b);

package/contracts/types/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,15 @@ using {
     ltUFixed as <,
     lteUFixed as <=,
     eqUFixed as ==,
-    UFixedMathLib.toInt
+    neUFixed as !=,
+    UFixedLib.toInt,
+    UFixedLib.gtz
 } for UFixed global;
 
+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 +34,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 +64,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 +84,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 +239,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/Version.sol

@@ -94,6 +94,7 @@ library VersionLib {
 
     // TODO check for overflow?
     function toVersion(uint64 versionNumber) external pure returns(Version) {
+        //assert(versionNumber <= type(Version).max);
         return Version.wrap(uint24(versionNumber));
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-de0a1d3-009",
+  "version": "0.0.2-e1e92ab-754",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {
@@ -42,10 +42,11 @@
     "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",
     "abi-coder": "^5.0.0",
     "ethers": "^6.7.1",
+    "solidity-docgen": "^0.6.0-beta.36",
     "winston": "^3.10.0"
   }
 }

package/artifacts/contracts/instance/module/access/Access.sol/AccessModule.dbg.json

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