@etherisc/gif-next 0.0.2-c4efd5e → 0.0.2-c6846dc-026

package/contracts/instance/pool/PoolModule.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.19;
 import {IOwnable, IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
 import {IProductService} from "../product/IProductService.sol";
 import {IPolicy, IPolicyModule} from "../policy/IPolicy.sol";
+import {ITreasuryModule} from "../treasury/ITreasury.sol";
 import {IPoolModule} from "./IPoolModule.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 
@@ -11,9 +12,12 @@ abstract contract PoolModule is IPoolModule {
     using NftIdLib for NftId;
 
     uint256 public constant INITIAL_CAPITAL = 10000 * 10 ** 6;
+    uint256 public constant INITIAL_LOCKED_CAPITAL = 0;
 
     mapping(NftId nftId => PoolInfo info) private _poolInfo;
 
+    IPolicyModule private _policyModule;
+    ITreasuryModule private _treasuryModule;
     IProductService private _productService;
 
     modifier onlyProductService() {
@@ -25,41 +29,45 @@ abstract contract PoolModule is IPoolModule {
     }
 
     constructor(address productService) {
+        _policyModule = IPolicyModule(address(this));
+        _treasuryModule = ITreasuryModule(address(this));
         _productService = IProductService(productService);
     }
 
-    function createPoolInfo(
-        NftId nftId,
-        address wallet,
-        address token
-    ) public override {
+    function registerPool(NftId nftId) public override {
         require(_poolInfo[nftId].nftId.eqz(), "ERROR:PL-001:ALREADY_CREATED");
 
         _poolInfo[nftId] = PoolInfo(
             nftId,
-            wallet,
-            token,
             INITIAL_CAPITAL,
-            0 // locked capital
+            INITIAL_LOCKED_CAPITAL
         );
     }
 
     function underwrite(
-        NftId poolNftId,
-        NftId policyNftId
+        NftId policyNftId,
+        NftId productNftId
     ) external override onlyProductService {
-        PoolInfo storage poolInfo = _poolInfo[poolNftId];
-        require(poolInfo.nftId == poolNftId, "ERROR:PL-002:POOL_UNKNOWN");
-
-        IPolicyModule policyModule = IPolicyModule(address(this));
-        IPolicy.PolicyInfo memory policyInfo = policyModule.getPolicyInfo(
+        IPolicy.PolicyInfo memory policyInfo = _policyModule.getPolicyInfo(
             policyNftId
         );
+        require(policyInfo.nftId == policyNftId, "ERROR:PL-002:POLICY_UNKNOWN");
+
+        ITreasuryModule.ProductSetup memory product = _treasuryModule
+            .getProductSetup(productNftId);
+        require(
+            product.productNftId == productNftId,
+            "ERROR:PL-003:PRODUCT_SETUP_MISSING"
+        );
+
+        NftId poolNftId = product.poolNftId;
+        PoolInfo storage poolInfo = _poolInfo[poolNftId];
+        require(poolInfo.nftId == poolNftId, "ERROR:PL-004:POOL_UNKNOWN");
 
         require(
             poolInfo.capital - poolInfo.lockedCapital >=
                 policyInfo.sumInsuredAmount,
-            "ERROR:PL-003:CAPACITY_TOO_LOW"
+            "ERROR:PL-005:CAPACITY_TOO_LOW"
         );
 
         poolInfo.lockedCapital += policyInfo.sumInsuredAmount;

package/contracts/instance/product/IProductService.sol

@@ -23,7 +23,7 @@ interface IProductService is IRegistryLinked {
     // function expire(uint256 nftId) external;
     function close(NftId nftId) external;
 
-    // function collectPremium(uint256 nftId, uint256 premiumAmount) external;
+    function collectPremium(NftId nftId) external;
 
     // function createClaim(uint256 nftId, uint256 claimAmount) external;
     // function confirmClaim(uint256 nftId, uint256 claimId, uint256 claimAmount) external;

package/contracts/instance/product/ProductService.sol

@@ -8,15 +8,21 @@ import {IRegistry} from "../../registry/IRegistry.sol";
 import {IPolicyModule} from "../policy/IPolicy.sol";
 import {RegistryLinked} from "../../registry/Registry.sol";
 import {IProductService, IProductModule} from "./IProductService.sol";
-import {IComponentModule} from "../../instance/component/IComponent.sol";
+import {ITreasuryModule} from "../../instance/treasury/ITreasury.sol";
 import {IPoolModule} from "../../instance/pool/IPoolModule.sol";
+import {ObjectType, INSTANCE, PRODUCT} from "../../types/ObjectType.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 
 // TODO or name this ProtectionService to have Product be something more generic (loan, savings account, ...)
 contract ProductService is RegistryLinked, IProductService {
     using NftIdLib for NftId;
 
-    constructor(address registry) RegistryLinked(registry) {}
+    constructor(
+        address registry
+    ) RegistryLinked(registry) // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
 
     function createApplication(
         address applicationOwner,
@@ -31,19 +37,13 @@ contract ProductService is RegistryLinked, IProductService {
         IRegistry.RegistryInfo memory productInfo = _registry.getInfo(
             productNftId
         );
-        require(
-            productInfo.objectType == _registry.PRODUCT(),
-            "ERROR_NOT_PRODUCT"
-        );
+        require(productInfo.objectType == PRODUCT(), "ERROR_NOT_PRODUCT");
 
         IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(
             productInfo.parentNftId
         );
         require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
-        require(
-            instanceInfo.objectType == _registry.INSTANCE(),
-            "ERROR_NOT_INSTANCE"
-        );
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
 
         IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
         nftId = policyModule.createApplication(
@@ -58,45 +58,69 @@ contract ProductService is RegistryLinked, IProductService {
         // add logging
     }
 
-    function underwrite(NftId nftId) external override {
+    function underwrite(NftId policyNftId) external override {
+        // validation
         // same as only registered product
         NftId productNftId = _registry.getNftId(msg.sender);
         require(productNftId.gtz(), "ERROR_PRODUCT_UNKNOWN");
         IRegistry.RegistryInfo memory productInfo = _registry.getInfo(
             productNftId
         );
-        require(
-            productInfo.objectType == _registry.PRODUCT(),
-            "ERROR_NOT_PRODUCT"
-        );
+        require(productInfo.objectType == PRODUCT(), "ERROR_NOT_PRODUCT");
 
         IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(
             productInfo.parentNftId
         );
         require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
-        require(
-            instanceInfo.objectType == _registry.INSTANCE(),
-            "ERROR_NOT_INSTANCE"
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
+
+        // underwrite policy
+        address instanceAddress = instanceInfo.objectAddress;
+        IPoolModule poolModule = IPoolModule(instanceAddress);
+        poolModule.underwrite(policyNftId, productNftId);
+
+        // activate policy
+        IPolicyModule policyModule = IPolicyModule(instanceAddress);
+        policyModule.activate(policyNftId);
+
+        // add logging
+    }
+
+    function collectPremium(NftId policyNftId) external override {
+        // validation same as other functions, eg underwrite
+        // TODO unify validation into modifier and/or other suitable approaches
+        // same as only registered product
+        NftId productNftId = _registry.getNftId(msg.sender);
+        require(productNftId.gtz(), "ERROR_PRODUCT_UNKNOWN");
+        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(
+            productNftId
         );
+        require(productInfo.objectType == PRODUCT(), "ERROR_NOT_PRODUCT");
 
-        // get responsible pool
-        IComponentModule componentModule = IComponentModule(
-            instanceInfo.objectAddress
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(
+            productInfo.parentNftId
         );
-        NftId poolNftId = componentModule.getPoolNftId(productNftId);
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
 
-        // lock capital (and update pool accounting)
-        IPoolModule poolModule = IPoolModule(instanceInfo.objectAddress);
-        poolModule.underwrite(poolNftId, nftId);
+        // process/collect premium: book keeping for policy
+        address instanceAddress = instanceInfo.objectAddress;
+        IPolicyModule policyModule = IPolicyModule(instanceAddress);
+        policyModule.processPremium(policyNftId);
 
-        // activate policy
-        IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
-        policyModule.activate(nftId);
+        // process/collect premium: actual token transfer
+        ITreasuryModule treasuryModule = ITreasuryModule(instanceAddress);
+        treasuryModule.processPremium(policyNftId, productNftId);
 
-        // add logging
+        // TODO add logging
     }
 
-    function close(NftId nftId) external override {}
+    function close(
+        NftId policyNftId
+    ) external override // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
 }
 
 abstract contract ProductModule is IProductModule {

package/contracts/instance/treasury/ITreasury.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import {IRegistryLinked} from "../../registry/IRegistry.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {UFixed} from "../../types/UFixed.sol";
+import {Fee} from "../../types/Fee.sol";
+
+import {TokenHandler} from "./TokenHandler.sol";
+
+interface ITreasury {
+    // TODO add events
+    // TODO add errors
+}
+
+interface ITreasuryModule is IRegistryLinked, ITreasury {
+    struct ProductSetup {
+        NftId productNftId;
+        NftId distributorNftId;
+        NftId poolNftId;
+        IERC20 token;
+        TokenHandler tokenHandler;
+        address wallet;
+        Fee policyFee;
+        Fee processingFee;
+    }
+
+    struct DistributorSetup {
+        NftId distributorNftId;
+        address wallet;
+        Fee commissionFees;
+    }
+
+    struct PoolSetup {
+        NftId poolNftId;
+        address wallet;
+        Fee stakingFee;
+        Fee performanceFee;
+    }
+
+    function registerProduct(
+        NftId productNftId,
+        NftId distributorNftId,
+        NftId poolNftId,
+        IERC20 token,
+        address wallet,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) external;
+
+    function setProductFees(
+        NftId productNftId,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) external;
+
+    function registerPool(
+        NftId poolNftId,
+        address wallet,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) external;
+
+    function setPoolFees(
+        NftId poolNftId,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) external;
+
+    function processPremium(NftId policyNftId, NftId productNftId) external;
+
+    function getTokenHandler(
+        NftId productNftId
+    ) external view returns (TokenHandler tokenHandler);
+
+    function getProductSetup(
+        NftId productNftId
+    ) external view returns (ProductSetup memory setup);
+
+    function getPoolSetup(
+        NftId poolNftId
+    ) external view returns (PoolSetup memory setup);
+
+    function calculateFeeAmount(
+        uint256 amount,
+        Fee memory fee
+    ) external pure returns (uint256 feeAmount, uint256 netAmount);
+}

package/contracts/instance/treasury/TokenHandler.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract TokenHandler {
+    // TODO use oz safeTransferFrom
+
+    IERC20 _token;
+
+    constructor(address token) {
+        _token = IERC20(token);
+    }
+
+    // TODO add logging
+    function transfer(
+        address from,
+        address to,
+        uint256 amount
+    ) external // TODO add authz (only treasury)
+    {
+        _token.transferFrom(from, to, amount);
+    }
+}

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/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;
+}