@etherisc/gif-next 0.0.2-c4efd5e → 0.0.2-c630f3f-038

package/contracts/instance/treasury/TreasuryModule.sol

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {Fee, feeIsZero} from "../../types/Fee.sol";
+import {UFixed, UFixedMathLib} from "../../types/UFixed.sol";
+import {IProductComponent} from "../../components/IProduct.sol";
+import {IPolicy, IPolicyModule} from "../policy/IPolicy.sol";
+import {TokenHandler} from "./TokenHandler.sol";
+import {ITreasuryModule} from "./ITreasury.sol";
+import {TokenHandler} from "./TokenHandler.sol";
+
+abstract contract TreasuryModule is ITreasuryModule {
+    mapping(NftId productNftId => ProductSetup setup) private _productSetup;
+    mapping(NftId distributorNftId => DistributorSetup setup)
+        private _distributorSetup;
+    mapping(NftId poolNftId => PoolSetup setup) private _poolSetup;
+
+    IPolicyModule private _policyModule;
+
+    constructor() {
+        _policyModule = IPolicyModule(address(this));
+    }
+
+    function registerProduct(
+        NftId productNftId,
+        NftId distributorNftId,
+        NftId poolNftId,
+        IERC20 token,
+        address wallet,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) external override // TODO add authz (only component module)
+    {
+        // TODO add validation
+
+        // deploy product specific handler contract
+        TokenHandler tokenHandler = new TokenHandler(address(token));
+
+        _productSetup[productNftId] = ProductSetup(
+            productNftId,
+            distributorNftId,
+            poolNftId,
+            token,
+            tokenHandler,
+            wallet,
+            policyFee,
+            processingFee
+        );
+
+        // TODO add logging
+    }
+
+    function setProductFees(
+        NftId productNftId,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) external override // TODO add authz (only component owner service)
+    {
+        // TODO add validation
+
+        ProductSetup storage setup = _productSetup[productNftId];
+        setup.policyFee = policyFee;
+        setup.processingFee = processingFee;
+
+        // TODO add logging
+    }
+
+    function registerPool(
+        NftId poolNftId,
+        address wallet,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) external override // TODO add authz (only component module)
+    {
+        // TODO add validation
+
+        _poolSetup[poolNftId] = PoolSetup(
+            poolNftId,
+            wallet,
+            stakingFee,
+            performanceFee
+        );
+
+        // TODO add logging
+    }
+
+    function setPoolFees(
+        NftId poolNftId,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) external override // TODO add authz (only component owner service)
+    {
+        // TODO add validation
+
+        PoolSetup storage setup = _poolSetup[poolNftId];
+        setup.stakingFee = stakingFee;
+        setup.performanceFee = performanceFee;
+
+        // TODO add logging
+    }
+
+    function getTokenHandler(
+        NftId productNftId
+    ) external view override returns (TokenHandler tokenHandler) {
+        return _productSetup[productNftId].tokenHandler;
+    }
+
+    function getProductSetup(
+        NftId productNftId
+    ) external view override returns (ProductSetup memory setup) {
+        return _productSetup[productNftId];
+    }
+
+    function getPoolSetup(
+        NftId poolNftId
+    ) external view override returns (PoolSetup memory setup) {
+        return _poolSetup[poolNftId];
+    }
+
+    function processPremium(
+        NftId policyNftId,
+        NftId productNftId
+    ) external override // TODO add authz (only product service)
+    {
+        IPolicy.PolicyInfo memory policyInfo = _policyModule.getPolicyInfo(
+            policyNftId
+        );
+        require(
+            policyInfo.nftId == policyNftId,
+            "ERROR:TRS-020:POLICY_UNKNOWN"
+        );
+
+        ProductSetup memory product = _productSetup[productNftId];
+        TokenHandler tokenHandler = product.tokenHandler;
+        address policyOwner = this.getRegistry().getOwner(policyNftId);
+        address poolWallet = _poolSetup[product.poolNftId].wallet;
+        // TODO add validation
+
+        if (feeIsZero(product.policyFee)) {
+            tokenHandler.transfer(
+                policyOwner,
+                poolWallet,
+                policyInfo.premiumAmount
+            );
+        } else {
+            (uint256 feeAmount, uint256 netAmount) = calculateFeeAmount(
+                policyInfo.premiumAmount,
+                product.policyFee
+            );
+
+            tokenHandler.transfer(policyOwner, product.wallet, feeAmount);
+            tokenHandler.transfer(policyOwner, poolWallet, netAmount);
+        }
+    }
+
+    function calculateFeeAmount(
+        uint256 amount,
+        Fee memory fee
+    ) public pure override returns (uint256 feeAmount, uint256 netAmount) {
+        UFixed fractionalAmount = UFixedMathLib.itof(amount) *
+            fee.fractionalFee;
+        feeAmount = UFixedMathLib.ftoi(fractionalAmount) + fee.fixedFee;
+        netAmount = amount - feeAmount;
+    }
+}

package/contracts/mock/Dip.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract DIP is ERC20 {
+
+    // https://etherscan.io/token/0xc719d010b63e5bbf2c0551872cd5316ed26acd83#readContract
+    string public constant NAME = "Decentralized Insurance Protocol - DUMMY";
+    string public constant SYMBOL = "DIP";
+    uint8 public constant DECIMALS = 18;
+    uint256 public constant INITIAL_SUPPLY = 10**9 * 10**DECIMALS; // 1 Billion 1'000'000'000
+    // decimals == 18 (openzeppelin erc20 default)
+    constructor()
+        ERC20(NAME, SYMBOL)
+    {
+        _mint(
+            _msgSender(),
+            INITIAL_SUPPLY
+        );   
+    }
+
+    function decimals() public pure override returns(uint8) {
+        return DECIMALS;
+    }
+}

package/contracts/mock/TestPool.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Fee, zeroFee} from "../../contracts/types/Fee.sol";
+import {Pool} from "../../contracts/components/Pool.sol";
+
+
+contract TestPool is Pool {
+
+    constructor(address registry, address instance, address token)
+        // feeless pool (no staking fee, no performance fee)
+        Pool(registry, instance, token, zeroFee(), zeroFee())
+    // solhint-disable-next-line no-empty-blocks
+    {}
+
+}

package/contracts/mock/TestProduct.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Product} from "../../contracts/components/Product.sol";
+import {NftId, toNftId} from "../../contracts/types/NftId.sol";
+import {Fee, zeroFee} from "../../contracts/types/Fee.sol";
+
+contract TestProduct is Product {
+
+    constructor(address registry, address instance, address token, address pool, Fee memory policyFee)
+        Product(registry, instance, token, pool, policyFee, zeroFee())
+    // solhint-disable-next-line no-empty-blocks
+    {}
+
+    function applyForPolicy(
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime
+    )
+        external
+        returns(NftId nftId)
+    {
+        nftId = _createApplication(
+            msg.sender, // policy holder
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            toNftId(0) // requested bundle nft id
+        );
+    }
+
+    function underwrite(NftId nftId) external {
+        _underwrite(nftId);
+    }
+
+    function collectPremium(NftId nftId) external {
+        _collectPremium(nftId);
+    }
+}

package/contracts/mock/Usdc.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract USDC is ERC20 {
+
+    // https://etherscan.io/token/0xc719d010b63e5bbf2c0551872cd5316ed26acd83#readContract
+    string public constant NAME = "USDC - DUMMY";
+    string public constant SYMBOL = "USDC";
+    uint8 public constant DECIMALS = 6;
+    uint256 public constant INITIAL_SUPPLY = 10**9 * 10**DECIMALS; // 1 Billion 1'000'000'000
+    // decimals == 18 (openzeppelin erc20 default)
+    constructor()
+        ERC20(NAME, SYMBOL)
+    {
+        _mint(
+            _msgSender(),
+            INITIAL_SUPPLY
+        );   
+    }
+
+    function decimals() public pure override returns(uint8) {
+        return DECIMALS;
+    }
+}

package/contracts/registry/IRegistry.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.19;
 
 import {NftId} from "../types/NftId.sol";
+import {ObjectType} from "../types/ObjectType.sol";
 
 interface IOwnable {
     function getOwner() external view returns (address owner);
@@ -20,7 +21,7 @@ interface IRegisterable is IOwnable, IRegistryLinked {
 
     function getParentNftId() external view returns (NftId parentNftId);
 
-    function getType() external view returns (uint256 objectType);
+    function getType() external view returns (ObjectType objectType);
 
     function getData() external view returns (bytes memory data);
 
@@ -35,30 +36,16 @@ interface IRegistry {
     struct RegistryInfo {
         NftId nftId;
         NftId parentNftId;
-        uint256 objectType;
+        ObjectType objectType;
         address objectAddress;
         address initialOwner;
     }
 
-    function TOKEN() external pure returns (uint256);
-
-    function INSTANCE() external pure returns (uint256);
-
-    function PRODUCT() external pure returns (uint256);
-
-    function ORACLE() external pure returns (uint256);
-
-    function POOL() external pure returns (uint256);
-
-    function POLICY() external pure returns (uint256);
-
-    function BUNDLE() external pure returns (uint256);
-
     function register(address objectAddress) external returns (NftId nftId);
 
     function registerObjectForInstance(
         NftId parentNftid,
-        uint256 objectType,
+        ObjectType objectType,
         address initialOwner
     ) external returns (NftId nftId);
 

package/contracts/registry/Registry.sol

@@ -3,8 +3,8 @@ pragma solidity ^0.8.19;
 
 import {IChainNft} from "./IChainNft.sol";
 import {IRegistry, IRegistryLinked, IRegisterable} from "./IRegistry.sol";
-import {NftId, toNftId} from "../types/NftId.sol";
-import {NftIdLib} from "../types/NftId.sol";
+import {NftId, toNftId, NftIdLib} from "../types/NftId.sol";
+import {ObjectType, INSTANCE, POLICY, BUNDLE} from "../types/ObjectType.sol";
 
 contract RegistryLinked is IRegistryLinked {
     IRegistry internal _registry;
@@ -55,6 +55,7 @@ abstract contract Registerable is RegistryLinked, IRegisterable {
 
 contract Registry is IRegistry {
     using NftIdLib for NftId;
+
     string public constant EMPTY_URI = "";
 
     mapping(NftId nftId => RegistryInfo info) private _info;
@@ -71,34 +72,6 @@ contract Registry is IRegistry {
         _chainNft = IChainNft(chainNft);
     }
 
-    function TOKEN() public pure override returns (uint256) {
-        return 30;
-    }
-
-    function INSTANCE() public pure override returns (uint256) {
-        return 40;
-    }
-
-    function PRODUCT() public pure override returns (uint256) {
-        return 50;
-    }
-
-    function ORACLE() public pure override returns (uint256) {
-        return 60;
-    }
-
-    function POOL() public pure override returns (uint256) {
-        return 70;
-    }
-
-    function POLICY() public pure override returns (uint256) {
-        return 80;
-    }
-
-    function BUNDLE() public pure override returns (uint256) {
-        return 90;
-    }
-
     function register(
         address objectAddress
     ) external override returns (NftId nftId) {
@@ -145,7 +118,7 @@ contract Registry is IRegistry {
 
     function registerObjectForInstance(
         NftId parentNftId,
-        uint256 objectType,
+        ObjectType objectType,
         address initialOwner
     )
         external

package/contracts/types/Fee.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {UFixed} from "./UFixed.sol";
+
+struct Fee {
+    UFixed fractionalFee;
+    uint256 fixedFee;
+}
+
+// general pure free functions
+/// @dev Converts the uint256 to a NftId.
+function toFee(
+    UFixed fractionalFee,
+    uint256 fixedFee
+) pure returns (Fee memory fee) {
+    return Fee(fractionalFee, fixedFee);
+}
+
+/// @dev Return the NftId zero (0)
+function zeroFee() pure returns (Fee memory fee) {
+    return Fee(UFixed.wrap(0), 0);
+}
+
+// pure free functions for operators
+function feeIsSame(Fee memory a, Fee memory b) pure returns (bool isSame) {
+    return a.fixedFee == b.fixedFee && a.fractionalFee == b.fractionalFee;
+}
+
+function feeIsZero(Fee memory fee) pure returns (bool) {
+    return fee.fixedFee == 0 && UFixed.unwrap(fee.fractionalFee) == 0;
+}

package/contracts/types/ObjectType.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// uint96 allows for chain ids up to 13 digits
+type ObjectType is uint8;
+
+// type bindings
+using {
+    eqObjectType as ==,
+    neObjectType as !=,
+    ObjectTypeLib.toInt
+} for ObjectType global;
+
+// general pure free functions
+
+function PROTOCOL() pure returns (ObjectType) {
+    return toObjectType(10);
+}
+
+function CHAIN() pure returns (ObjectType) {
+    return toObjectType(20);
+}
+
+function REGISTRY() pure returns (ObjectType) {
+    return toObjectType(30);
+}
+
+function TOKEN() pure returns (ObjectType) {
+    return toObjectType(40);
+}
+
+function INSTANCE() pure returns (ObjectType) {
+    return toObjectType(50);
+}
+
+function PRODUCT() pure returns (ObjectType) {
+    return toObjectType(60);
+}
+
+function ORACLE() pure returns (ObjectType) {
+    return toObjectType(70);
+}
+
+function POOL() pure returns (ObjectType) {
+    return toObjectType(80);
+}
+
+function BUNDLE() pure returns (ObjectType) {
+    return toObjectType(81);
+}
+
+function POLICY() pure returns (ObjectType) {
+    return toObjectType(90);
+}
+
+function CLAIM() pure returns (ObjectType) {
+    return toObjectType(91);
+}
+
+function PAYOUT() pure returns (ObjectType) {
+    return toObjectType(92);
+}
+
+/// @dev Converts the uint8 to a ObjectType.
+function toObjectType(uint256 objectType) pure returns (ObjectType) {
+    return ObjectType.wrap(uint8(objectType));
+}
+
+/// @dev Return the ObjectType zero (0)
+function zeroObjectType() pure returns (ObjectType) {
+    return ObjectType.wrap(0);
+}
+
+// pure free functions for operators
+function eqObjectType(ObjectType a, ObjectType b) pure returns (bool isSame) {
+    return ObjectType.unwrap(a) == ObjectType.unwrap(b);
+}
+
+function neObjectType(
+    ObjectType a,
+    ObjectType b
+) pure returns (bool isDifferent) {
+    return ObjectType.unwrap(a) != ObjectType.unwrap(b);
+}
+
+// library functions that operate on user defined type
+library ObjectTypeLib {
+    /// @dev Converts the NftId to a uint256.
+    function toInt(ObjectType objectType) public pure returns (uint96) {
+        return uint96(ObjectType.unwrap(objectType));
+    }
+
+    /// @dev Returns true if the value is non-zero (> 0).
+    function gtz(ObjectType a) public pure returns (bool) {
+        return ObjectType.unwrap(a) > 0;
+    }
+
+    /// @dev Returns true if the value is zero (== 0).
+    function eqz(ObjectType a) public pure returns (bool) {
+        return ObjectType.unwrap(a) == 0;
+    }
+
+    /// @dev Returns true if the values are equal (==).
+    function eq(ObjectType a, ObjectType b) public pure returns (bool isSame) {
+        return eqObjectType(a, b);
+    }
+}

package/contracts/types/StateId.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// uint96 allows for chain ids up to 13 digits
+type StateId is uint8;
+
+// type bindings
+using {eqStateId as ==, neStateId as !=, StateIdLib.toInt} for StateId global;
+
+// general pure free functions
+function APPLIED() pure returns (StateId) {
+    return toStateId(10);
+}
+
+function REVOKED() pure returns (StateId) {
+    return toStateId(20);
+}
+
+function DECLINED() pure returns (StateId) {
+    return toStateId(30);
+}
+
+function CONFIRMED() pure returns (StateId) {
+    return toStateId(40);
+}
+
+function EXPECTED() pure returns (StateId) {
+    return toStateId(50);
+}
+
+function ACTIVE() pure returns (StateId) {
+    return toStateId(100);
+}
+
+function PAUSED() pure returns (StateId) {
+    return toStateId(110);
+}
+
+function CLOSED() pure returns (StateId) {
+    return toStateId(200);
+}
+
+function ARCHIVED() pure returns (StateId) {
+    return toStateId(210);
+}
+
+function PAID() pure returns (StateId) {
+    return toStateId(220);
+}
+
+/// @dev Converts the uint8 to a StateId.
+function toStateId(uint256 id) pure returns (StateId) {
+    return StateId.wrap(uint8(id));
+}
+
+/// @dev Return the StateId zero (0)
+function zeroStateId() pure returns (StateId) {
+    return StateId.wrap(0);
+}
+
+// pure free functions for operators
+function eqStateId(StateId a, StateId b) pure returns (bool isSame) {
+    return StateId.unwrap(a) == StateId.unwrap(b);
+}
+
+function neStateId(StateId a, StateId b) pure returns (bool isDifferent) {
+    return StateId.unwrap(a) != StateId.unwrap(b);
+}
+
+// library functions that operate on user defined type
+library StateIdLib {
+    /// @dev Converts the NftId to a uint256.
+    function toInt(StateId stateId) public pure returns (uint96) {
+        return uint96(StateId.unwrap(stateId));
+    }
+
+    /// @dev Returns true if the value is non-zero (> 0).
+    function gtz(StateId a) public pure returns (bool) {
+        return StateId.unwrap(a) > 0;
+    }
+
+    /// @dev Returns true if the value is zero (== 0).
+    function eqz(StateId a) public pure returns (bool) {
+        return StateId.unwrap(a) == 0;
+    }
+
+    /// @dev Returns true if the values are equal (==).
+    function eq(StateId a, StateId b) public pure returns (bool isSame) {
+        return eqStateId(a, b);
+    }
+}

package/contracts/types/UFixed.sol

@@ -76,21 +76,25 @@ function deltaUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 }
 
 library UFixedMathLib {
-    enum Rounding {
-        /// @dev Round down - floor(value)
-        Down,
-        /// @dev Round up - ceil(value)
-        Up,
-        /// @dev Round half up - round(value)
-        HalfUp
-    }
 
     int8 public constant EXP = 18;
     uint256 public constant MULTIPLIER = 10 ** uint256(int256(EXP));
     uint256 public constant MULTIPLIER_HALF = MULTIPLIER / 2;
 
-    /// @dev Default rounding mode used by ftoi is HalfUp
-    Rounding public constant ROUNDING_DEFAULT = Rounding.HalfUp;
+    /// @dev returns the rounding mode DOWN - 0.4 becomes 0, 0.5 becomes 0, 0.6 becomes 0
+    function ROUNDING_DOWN() public pure returns (uint8) {
+        return uint8(0);
+    }
+
+    /// @dev returns the rounding mode UP - 0.4 becomes 1, 0.5 becomes 1, 0.6 becomes 1
+    function ROUNDING_UP() public pure returns (uint8) {
+        return uint8(1);
+    }
+
+    /// @dev returns the rounding mode HALF_UP - 0.4 becomes 0, 0.5 becomes 1, 0.6 becomes 1
+    function ROUNDING_HALF_UP() public pure returns (uint8) {
+        return uint8(2);
+    }
 
     /// @dev returns the decimals precision of the UFixed type
     function decimals() public pure returns (uint256) {
@@ -102,6 +106,7 @@ library UFixedMathLib {
         return UFixed.wrap(a * MULTIPLIER);
     }
 
+    // TODO rename to toUFixed
     /// @dev Converts the uint256 to a UFixed with given exponent.
     function itof(uint256 a, int8 exp) public pure returns (UFixed) {
         require(EXP + exp >= 0, "ERROR:FM-010:EXPONENT_TOO_SMALL");
@@ -112,12 +117,12 @@ library UFixedMathLib {
 
     /// @dev Converts a UFixed to a uint256.
     function ftoi(UFixed a) public pure returns (uint256) {
-        return ftoi(a, ROUNDING_DEFAULT);
+        return ftoi(a, ROUNDING_HALF_UP());
     }
 
     /// @dev Converts a UFixed to a uint256 with given rounding mode.
-    function ftoi(UFixed a, Rounding rounding) public pure returns (uint256) {
-        if (rounding == Rounding.HalfUp) {
+    function ftoi(UFixed a, uint8 rounding) public pure returns (uint256) {
+        if (rounding == ROUNDING_HALF_UP()) {
             return
                 Math.mulDiv(
                     UFixed.unwrap(a) + MULTIPLIER_HALF,
@@ -125,7 +130,7 @@ library UFixedMathLib {
                     MULTIPLIER,
                     Math.Rounding.Down
                 );
-        } else if (rounding == Rounding.Down) {
+        } else if (rounding == ROUNDING_DOWN()) {
             return
                 Math.mulDiv(
                     UFixed.unwrap(a),