@etherisc/gif-next 0.0.2-9141c0d → 0.0.2-a380f15

package/contracts/instance/policy/PolicyModule.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+
+// import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
+import {IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+
+import {IProductService} from "../product/IProductService.sol";
+import {IPolicy, IPolicyModule} from "./IPolicy.sol";
+import {NftId, NftIdLib} from "../../types/NftId.sol";
+
+abstract contract PolicyModule is
+    IRegistryLinked,
+    IPolicyModule
+{
+    using NftIdLib for NftId;
+
+    mapping(NftId nftId => PolicyInfo info) private _policyInfo;
+    mapping(NftId nftId => NftId bundleNftId) private _bundleForPolicy;
+
+    IProductService private _productService;
+
+    // TODO find a better place to avoid dupliation
+    modifier onlyProductService2() {
+        require(address(_productService) == msg.sender, "ERROR:POL-001:NOT_PRODUCT_SERVICE");
+        _;
+    }
+
+    constructor(address productService) {
+        _productService = IProductService(productService);
+    }
+
+
+    function createApplication(
+        IRegistry.RegistryInfo memory productInfo,
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        NftId bundleNftId
+    )
+        external
+        override
+        onlyProductService2
+        returns(NftId nftId)
+    {
+        // TODO add parameter validation
+        if(bundleNftId.gtz()) {
+            IRegistry.RegistryInfo memory bundleInfo = this.getRegistry().getInfo(bundleNftId);
+            // IRegistry.RegistryInfo memory poolInfo = this.getRegistry().getInfo(bundleInfo.parentNftId);
+        }
+
+        nftId = this.getRegistry().registerObjectForInstance(
+            productInfo.nftId,
+            this.getRegistry().POLICY(),
+            applicationOwner);
+
+        _policyInfo[nftId] = PolicyInfo(
+            nftId,
+            PolicyState.Applied,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            block.timestamp,
+            0, // activatedAt
+            0, // expiredAt
+            0 // closedAt
+        );
+
+        _bundleForPolicy[nftId] = bundleNftId;
+
+        // add logging
+    }
+
+
+    function activate(NftId nftId)
+        external
+        override
+        onlyProductService2
+    {
+        PolicyInfo storage info = _policyInfo[nftId];
+        info.activatedAt = block.timestamp;
+        info.expiredAt = block.timestamp + info.lifetime;
+        info.state = PolicyState.Active;
+
+        // add logging
+    }
+
+
+
+    function getBundleNftForPolicy(NftId nftId)
+        external
+        view
+        returns(NftId bundleNft)
+    {
+        return _bundleForPolicy[nftId];
+    }
+
+
+    function getPolicyInfo(NftId nftId)
+        external
+        view
+        returns(PolicyInfo memory info)
+    {
+        return _policyInfo[nftId];
+    }
+}

package/contracts/instance/pool/IPoolModule.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IOwnable, IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+import {NftId} from "../../types/NftId.sol";
+
+interface IPool {
+
+    struct PoolInfo {
+        NftId nftId;
+        address wallet;
+        address token;
+        uint256 capital;
+        uint256 lockedCapital;
+    }
+}
+
+interface IPoolModule is
+    IOwnable,
+    IRegistryLinked,
+    IPool
+{
+    
+    function underwrite(
+        NftId poolNftId,
+        NftId policyNftId
+    )
+        external;
+
+    function createPoolInfo(
+        NftId nftId,
+        address wallet,
+        address token
+    )
+        external;
+
+    function getPoolInfo(NftId nftId)
+        external
+        view
+        returns(PoolInfo memory info);
+}

package/contracts/instance/pool/PoolModule.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: Apache-2.0
+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 {IPoolModule} from "./IPoolModule.sol";
+import {NftId, NftIdLib} from "../../types/NftId.sol";
+
+abstract contract PoolModule is
+    IPoolModule
+{
+    using NftIdLib for NftId;
+    
+    uint256 public constant INITIAL_CAPITAL = 10000*10**6;
+
+    mapping(NftId nftId => PoolInfo info) private _poolInfo;
+
+    IProductService private _productService;
+
+    modifier onlyProductService() {
+        require(address(_productService) == msg.sender, "ERROR:POL-001:NOT_PRODUCT_SERVICE");
+        _;
+    }
+
+    constructor(address productService) {
+        _productService = IProductService(productService);
+    }
+
+    function createPoolInfo(
+        NftId nftId,
+        address wallet,
+        address token
+    )
+        public
+        override
+    {
+        require(
+            _poolInfo[nftId].nftId.eqz(),
+            "ERROR:PL-001:ALREADY_CREATED");
+
+        _poolInfo[nftId] = PoolInfo(
+            nftId,
+            wallet,
+            token,
+            INITIAL_CAPITAL,
+            0 // locked capital
+        );
+
+    }
+
+
+    function underwrite(
+        NftId poolNftId,
+        NftId policyNftId
+    )
+        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(policyNftId);
+
+        require(
+            poolInfo.capital - poolInfo.lockedCapital >= policyInfo.sumInsuredAmount,
+            "ERROR:PL-003:CAPACITY_TOO_LOW");
+
+        poolInfo.lockedCapital += policyInfo.sumInsuredAmount;
+    }
+
+
+    function getPoolInfo(NftId nftId)
+        external
+        view
+        override
+        returns(PoolInfo memory info)
+    {
+        info = _poolInfo[nftId];
+    }
+
+}

package/contracts/instance/product/IProductService.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+
+import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
+import {IInstance} from "../IInstance.sol";
+import {NftId} from "../../types/NftId.sol";
+
+
+// TODO or name this IProtectionService to have Product be something more generic (loan, savings account, ...)
+interface IProductService is
+    IRegistryLinked
+{
+
+    function createApplication(
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        NftId bundleNftId
+    )
+        external 
+        returns(NftId nftId);
+
+    // function revoke(unit256 nftId) external;
+
+    function underwrite(NftId nftId) external;
+    // function decline(uint256 nftId) external;
+    // function expire(uint256 nftId) external;
+    function close(NftId nftId) external;
+
+    // function collectPremium(uint256 nftId, uint256 premiumAmount) external;
+
+    // function createClaim(uint256 nftId, uint256 claimAmount) external;
+    // function confirmClaim(uint256 nftId, uint256 claimId, uint256 claimAmount) external;
+    // function declineClaim(uint256 nftId, uint256 claimId) external;
+    // function closeClaim(uint256 nftId, uint256 claimId) external;
+}
+
+
+interface IProductModule is
+    IOwnable,
+    IRegistryLinked
+{
+    function getProductService() external view returns(IProductService);
+}

package/contracts/instance/product/ProductService.sol

@@ -0,0 +1,108 @@
+// 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";
+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 {IPoolModule} from "../../instance/pool/IPoolModule.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)
+    { }
+
+
+    function createApplication(
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        NftId bundleNftId
+    )
+        external 
+        override
+        returns(NftId nftId)
+    {
+        // 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");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
+
+        IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
+        nftId = policyModule.createApplication(
+            productInfo,
+            applicationOwner,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            bundleNftId);
+
+        // add logging
+    }
+
+    function underwrite(NftId nftId)
+        external
+        override
+    {
+        // 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");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(productInfo.parentNftId);
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
+
+        // get responsible pool
+        IComponentModule componentModule = IComponentModule(instanceInfo.objectAddress);
+        NftId poolNftId = componentModule.getPoolNftId(productNftId);
+
+        // lock capital (and update pool accounting)
+        IPoolModule poolModule = IPoolModule(instanceInfo.objectAddress);
+        poolModule.underwrite(
+            poolNftId,
+            nftId);
+
+        // activate policy
+        IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
+        policyModule.activate(nftId);
+
+        // add logging
+    }
+
+    function close(NftId nftId) external override {}
+}
+
+abstract contract ProductModule is
+    IProductModule
+{
+    IProductService private _productService;
+
+    constructor(address productService) {
+        _productService = IProductService(productService);
+    }
+
+    function getProductService() external view returns(IProductService) {
+        return _productService;
+    }
+
+}

package/contracts/registry/ChainNft.sol

@@ -0,0 +1,173 @@
+// 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 override view 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,18 @@
+// 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);
+}

package/contracts/registry/IRegistry.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../types/NftId.sol";
+
+interface IOwnable {
+    function getOwner() external view returns(address owner);
+}
+
+interface IRegistryLinked {
+
+    event LogDebug(uint256 idx, address module, string comment);
+
+    function getRegistry() external view returns(IRegistry registry);
+}
+
+interface IRegisterable is 
+    IOwnable,
+    IRegistryLinked
+{
+
+    function register() external returns(NftId nftId);
+    
+    function getNftId() external view returns(NftId nftId);
+    function getParentNftId() external view returns(NftId parentNftId);
+    function getType() external view returns(uint256 objectType);
+    function getData() external view returns(bytes memory data);
+    function isRegisterable() external pure returns(bool);
+    function getInitialOwner() external view returns(address initialOwner);
+
+    function isRegistered() external view returns(bool);
+}
+
+
+interface IRegistry {
+
+    struct RegistryInfo {
+        NftId nftId;
+        NftId parentNftId;
+        uint256 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,
+        address initialOwner
+    )
+        external returns(NftId nftId);
+
+    function getObjectCount() external view returns(uint256);
+
+    function getNftId(address objectAddress) external view returns(NftId nftId);
+    function getInfo(NftId nftId) external view returns(RegistryInfo memory info);
+    function getOwner(NftId nftId) external view returns(address ownerAddress);
+
+    function isRegistered(address objectAddress) external view returns(bool);
+
+    function getNftAddress() external view returns(address nft);
+}