@etherisc/gif-next 0.0.2-f9905e1 → 0.0.2-f99f1d2-109

package/contracts/instance/product/ProductService.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-
 // import {IProduct} from "../../components/IProduct.sol";
 // import {IOwnable, IRegistryLinked, IRegisterable, IRegistry} from "../../registry/IRegistry.sol";
 // import {IInstance} from "../IInstance.sol";
@@ -9,39 +8,42 @@ 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
-{
-    constructor(address registry) 
-        RegistryLinked(registry)
-    { }
+contract ProductService is RegistryLinked, IProductService {
+    using NftIdLib for NftId;
 
+    constructor(
+        address registry
+    ) RegistryLinked(registry) // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
 
     function createApplication(
         address applicationOwner,
         uint256 sumInsuredAmount,
         uint256 premiumAmount,
         uint256 lifetime,
-        uint256 bundleNftId
-    )
-        external 
-        override
-        returns(uint256 nftId)
-    {
+        NftId bundleNftId
+    ) external override returns (NftId nftId) {
         // same as only registered product
-        uint256 productNftId = _registry.getNftId(msg.sender);
-        require(productNftId > 0, "ERROR_PRODUCT_UNKNOWN");
-        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(productNftId);
-        require(productInfo.objectType == _registry.PRODUCT(), "ERROR_NOT_PRODUCT");
-
-        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
-        require(instanceInfo.nftId > 0, "ERROR_INSTANCE_UNKNOWN");
-        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
+        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");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(
+            productInfo.parentNftId
+        );
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
 
         IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
         nftId = policyModule.createApplication(
@@ -50,56 +52,85 @@ contract ProductService is
             sumInsuredAmount,
             premiumAmount,
             lifetime,
-            bundleNftId);
+            bundleNftId
+        );
 
         // add logging
     }
 
-    function underwrite(uint256 nftId)
-        external
-        override
-    {
+    function underwrite(NftId policyNftId) external override {
+        // validation
         // same as only registered product
-        uint256 productNftId = _registry.getNftId(msg.sender);
-        require(productNftId > 0, "ERROR_PRODUCT_UNKNOWN");
-        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(productNftId);
-        require(productInfo.objectType == _registry.PRODUCT(), "ERROR_NOT_PRODUCT");
-
-        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
-        require(instanceInfo.nftId > 0, "ERROR_INSTANCE_UNKNOWN");
-        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
-
-        // get responsible pool
-        IComponentModule componentModule = IComponentModule(instanceInfo.objectAddress);
-        uint256 poolNftId = componentModule.getPoolNftId(productNftId);
-
-        // lock capital (and update pool accounting)
-        IPoolModule poolModule = IPoolModule(instanceInfo.objectAddress);
-        poolModule.underwrite(
-            poolNftId,
-            nftId);
+        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");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(
+            productInfo.parentNftId
+        );
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
+        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(instanceInfo.objectAddress);
-        policyModule.activate(nftId);
+        IPolicyModule policyModule = IPolicyModule(instanceAddress);
+        policyModule.activate(policyNftId);
 
         // add logging
     }
 
-    function close(uint256 nftId) external override {}
+    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");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(
+            productInfo.parentNftId
+        );
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
+
+        // process/collect premium: book keeping for policy
+        address instanceAddress = instanceInfo.objectAddress;
+        IPolicyModule policyModule = IPolicyModule(instanceAddress);
+        policyModule.processPremium(policyNftId);
+
+        // process/collect premium: actual token transfer
+        ITreasuryModule treasuryModule = ITreasuryModule(instanceAddress);
+        treasuryModule.processPremium(policyNftId, productNftId);
+
+        // TODO add logging
+    }
+
+    function close(
+        NftId policyNftId
+    ) external override // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
 }
 
-abstract contract ProductModule is
-    IProductModule
-{
+abstract contract ProductModule is IProductModule {
     IProductService private _productService;
 
     constructor(address productService) {
         _productService = IProductService(productService);
     }
 
-    function getProductService() external view returns(IProductService) {
+    function getProductService() external view returns (IProductService) {
         return _productService;
     }
-
-}
+}

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/ChainNft.sol

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ERC721, ERC721Enumerable} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
+import {IChainNft} from "./IChainNft.sol";
+
+contract ChainNft is ERC721Enumerable, IChainNft {
+    string public constant NAME = "Dezentralized Insurance Protocol Registry";
+    string public constant SYMBOL = "DIPR";
+
+    // remember token uri
+    mapping(uint256 tokenId => string uri) private _uri;
+
+    // remember registry
+    address private _registry;
+
+    // only used for _getNextTokenId
+    uint256 internal _chainIdInt;
+    uint256 internal _chainIdDigits;
+    uint256 internal _chainIdMultiplier;
+    uint256 internal _idNext;
+    uint256 internal _totalMinted;
+
+    modifier onlyRegistry() {
+        require(msg.sender == _registry, "ERROR:NFT-001:CALLER_NOT_REGISTRY");
+        _;
+    }
+
+    constructor(address registry) ERC721(NAME, SYMBOL) {
+        require(registry != address(0), "ERROR:NFT-010:REGISTRY_ZERO");
+
+        _registry = registry;
+
+        _chainIdInt = block.chainid;
+        _chainIdDigits = _countDigits(_chainIdInt);
+        _chainIdMultiplier = 10 ** _chainIdDigits;
+
+        // on mainnet/goerli start /1 (reserved for protocol nft) on other chains with 2
+        if (block.chainid == 1 || block.chainid == 5) {
+            _idNext = 1;
+        } else {
+            _idNext = 2;
+        }
+    }
+
+    function mint(
+        address to,
+        string memory uri
+    ) external override onlyRegistry returns (uint256 tokenId) {
+        tokenId = _getNextTokenId();
+        _totalMinted++;
+
+        _safeMint(to, tokenId);
+
+        if (bytes(uri).length > 0) {
+            _uri[tokenId] = uri;
+        }
+    }
+
+    function burn(uint256 tokenId) external override onlyRegistry {
+        _requireMinted(tokenId);
+        _burn(tokenId);
+        delete _uri[tokenId];
+    }
+
+    function setURI(
+        uint256 tokenId,
+        string memory uri
+    ) external override onlyRegistry {
+        require(bytes(uri).length > 0, "ERROR:CRG-011:URI_EMPTY");
+
+        _requireMinted(tokenId);
+        _uri[tokenId] = uri;
+    }
+
+    function exists(uint256 tokenId) external view override returns (bool) {
+        return _exists(tokenId);
+    }
+
+    function tokenURI(
+        uint256 tokenId
+    ) public view override returns (string memory) {
+        _requireMinted(tokenId);
+        return _uri[tokenId];
+    }
+
+    function getRegistryAddress() external view override returns (address) {
+        return _registry;
+    }
+
+    function totalMinted() external view override returns (uint256) {
+        return _totalMinted;
+    }
+
+    // requirement: each chain registry produces token ids that
+    // are guaranteed to not collide with any token id genereated
+    // on a different chain
+    //
+    // format concat(counter,chainid,2 digits for len-of-chain-id)
+    // restriction chainid up to 99 digits
+    // decode: from right to left:
+    // - 2 right most digits encode length of chainid
+    // - move number of digits to left as determined above (-> chainid)
+    // - the reminder to the left is the counter
+    // examples
+    // 1101
+    // ^^ ^
+    // || +- 1-digit chain id
+    // |+-- chain id = 1 (mainnet)
+    // +-- 1st token id on mainnet
+    // (1 * 10 ** 1 + 1) * 100 + 1
+    // 42987654321010
+    // ^ ^          ^
+    // | |          +- 10-digit chain id
+    // | +-- chain id = 9876543210 (hypothetical chainid)
+    // +-- 42nd token id on this chain
+    // (42 * 10 ** 10 + 9876543210) * 100 + 10
+    // (index * 10 ** digits + chainid) * 100 + digits (1 < digits < 100)
+
+    function _getNextTokenId() private returns (uint256 id) {
+        id =
+            (_idNext * _chainIdMultiplier + _chainIdInt) *
+            100 +
+            _chainIdDigits;
+        _idNext++;
+    }
+
+    function _countDigits(uint256 num) private pure returns (uint256 count) {
+        count = 0;
+        while (num != 0) {
+            count++;
+            num /= 10;
+        }
+    }
+}

package/contracts/registry/IChainNft.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IERC721Enumerable} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
+
+interface IChainNft is IERC721Enumerable {
+    function mint(
+        address to,
+        string memory uri
+    ) external returns (uint256 tokenId);
+
+    function burn(uint256 tokenId) external;
+
+    function setURI(uint256 tokenId, string memory uri) external;
+
+    function exists(uint256 tokenId) external view returns (bool);
+
+    function totalMinted() external view returns (uint256);
+
+    function getRegistryAddress() external view returns (address registry);
+}