@etherisc/gif-next 0.0.2-34d25ca → 0.0.2-35bac6a

package/contracts/instance/pool/PoolModule.sol

@@ -7,20 +7,19 @@ import {IPolicy, IPolicyModule} from "../policy/IPolicy.sol";
 import {IPoolModule} from "./IPoolModule.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 
-abstract contract PoolModule is IPoolModule {
+abstract contract PoolModule is
+    IPoolModule
+{
     using NftIdLib for NftId;
-
-    uint256 public constant INITIAL_CAPITAL = 10000 * 10 ** 6;
+    
+    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"
-        );
+        require(address(_productService) == msg.sender, "ERROR:POL-001:NOT_PRODUCT_SERVICE");
         _;
     }
 
@@ -32,8 +31,13 @@ abstract contract PoolModule is IPoolModule {
         NftId nftId,
         address wallet,
         address token
-    ) public override {
-        require(_poolInfo[nftId].nftId.eqz(), "ERROR:PL-001:ALREADY_CREATED");
+    )
+        public
+        override
+    {
+        require(
+            _poolInfo[nftId].nftId.eqz(),
+            "ERROR:PL-001:ALREADY_CREATED");
 
         _poolInfo[nftId] = PoolInfo(
             nftId,
@@ -42,32 +46,41 @@ abstract contract PoolModule is IPoolModule {
             INITIAL_CAPITAL,
             0 // locked capital
         );
+
     }
 
+
     function underwrite(
         NftId poolNftId,
         NftId policyNftId
-    ) external override onlyProductService {
+    )
+        external
+        override
+        onlyProductService
+    {
         PoolInfo storage poolInfo = _poolInfo[poolNftId];
-        require(poolInfo.nftId == poolNftId, "ERROR:PL-002:POOL_UNKNOWN");
+        require(
+            poolInfo.nftId == poolNftId,
+            "ERROR:PL-002:POOL_UNKNOWN");
 
         IPolicyModule policyModule = IPolicyModule(address(this));
-        IPolicy.PolicyInfo memory policyInfo = policyModule.getPolicyInfo(
-            policyNftId
-        );
+        IPolicy.PolicyInfo memory policyInfo = policyModule.getPolicyInfo(policyNftId);
 
         require(
-            poolInfo.capital - poolInfo.lockedCapital >=
-                policyInfo.sumInsuredAmount,
-            "ERROR:PL-003:CAPACITY_TOO_LOW"
-        );
+            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) {
+
+    function getPoolInfo(NftId nftId)
+        external
+        view
+        override
+        returns(PoolInfo memory info)
+    {
         info = _poolInfo[nftId];
     }
-}
+
+}

package/contracts/instance/product/IProductService.sol

@@ -1,24 +1,30 @@
 // 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 {
+interface IProductService is
+    IRegistryLinked
+{
+
     function createApplication(
         address applicationOwner,
         uint256 sumInsuredAmount,
         uint256 premiumAmount,
         uint256 lifetime,
         NftId bundleNftId
-    ) external returns (NftId nftId);
+    )
+        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;
@@ -31,6 +37,10 @@ interface IProductService is IRegistryLinked {
     // function closeClaim(uint256 nftId, uint256 claimId) external;
 }
 
-interface IProductModule is IOwnable, IRegistryLinked {
-    function getProductService() external view returns (IProductService);
+
+interface IProductModule is
+    IOwnable,
+    IRegistryLinked
+{
+    function getProductService() external view returns(IProductService);
 }

package/contracts/instance/product/ProductService.sol

@@ -1,6 +1,7 @@
 // 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";
@@ -13,10 +14,16 @@ 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 {
+contract ProductService is
+    RegistryLinked,
+    IProductService
+{
     using NftIdLib for NftId;
+    
+    constructor(address registry) 
+        RegistryLinked(registry)
+    { }
 
-    constructor(address registry) RegistryLinked(registry) {}
 
     function createApplication(
         address applicationOwner,
@@ -24,26 +31,20 @@ contract ProductService is RegistryLinked, IProductService {
         uint256 premiumAmount,
         uint256 lifetime,
         NftId bundleNftId
-    ) external override returns (NftId nftId) {
+    )
+        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
-        );
+        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"
-        );
+        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
 
         IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
         nftId = policyModule.createApplication(
@@ -52,42 +53,34 @@ contract ProductService is RegistryLinked, IProductService {
             sumInsuredAmount,
             premiumAmount,
             lifetime,
-            bundleNftId
-        );
+            bundleNftId);
 
         // add logging
     }
 
-    function underwrite(NftId nftId) external override {
+    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
-        );
+        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"
-        );
+        require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
 
         // get responsible pool
-        IComponentModule componentModule = IComponentModule(
-            instanceInfo.objectAddress
-        );
+        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);
+        poolModule.underwrite(
+            poolNftId,
+            nftId);
 
         // activate policy
         IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
@@ -99,14 +92,17 @@ contract ProductService is RegistryLinked, IProductService {
     function close(NftId nftId) external override {}
 }
 
-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/registry/ChainNft.sol

@@ -4,7 +4,10 @@ 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 {
+contract ChainNft is
+    ERC721Enumerable,
+    IChainNft
+{
     string public constant NAME = "Dezentralized Insurance Protocol Registry";
     string public constant SYMBOL = "DIPR";
 
@@ -15,18 +18,22 @@ contract ChainNft is ERC721Enumerable, IChainNft {
     address private _registry;
 
     // only used for _getNextTokenId
-    uint256 internal _chainIdInt;
+    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) {
+
+    constructor(address registry)
+        ERC721(NAME, SYMBOL)
+    {
         require(registry != address(0), "ERROR:NFT-010:REGISTRY_ZERO");
 
         _registry = registry;
@@ -36,59 +43,88 @@ contract ChainNft is ERC721Enumerable, IChainNft {
         _chainIdMultiplier = 10 ** _chainIdDigits;
 
         // on mainnet/goerli start /1 (reserved for protocol nft) on other chains with 2
-        if (block.chainid == 1 || block.chainid == 5) {
+        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) {
+    )
+        external
+        override
+        onlyRegistry
+        returns(uint256 tokenId)
+    {
         tokenId = _getNextTokenId();
         _totalMinted++;
 
         _safeMint(to, tokenId);
 
-        if (bytes(uri).length > 0) {
+        if(bytes(uri).length > 0) {
             _uri[tokenId] = uri;
         }
     }
 
-    function burn(uint256 tokenId) external override onlyRegistry {
+
+    function burn(uint256 tokenId)
+        external
+        override
+        onlyRegistry
+    {
         _requireMinted(tokenId);
         _burn(tokenId);
         delete _uri[tokenId];
     }
 
-    function setURI(
-        uint256 tokenId,
-        string memory uri
-    ) external override onlyRegistry {
+
+    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) {
+
+    function exists(uint256 tokenId)
+        external
+        view
+        override
+        returns(bool)
+    {
         return _exists(tokenId);
     }
 
-    function tokenURI(
-        uint256 tokenId
-    ) public view override returns (string memory) {
+
+    function tokenURI(uint256 tokenId)
+        public
+        view
+        override 
+        returns(string memory)
+    {
         _requireMinted(tokenId);
         return _uri[tokenId];
     }
 
-    function getRegistryAddress() external view override returns (address) {
+
+    function getRegistryAddress()
+        external
+        view
+        override
+        returns(address)
+    {
         return _registry;
     }
 
-    function totalMinted() external view override returns (uint256) {
+    function totalMinted() external override view returns(uint256) {
         return _totalMinted;
     }
 
@@ -117,15 +153,17 @@ contract ChainNft is ERC721Enumerable, IChainNft {
     // (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;
+    function _getNextTokenId() private returns(uint256 id) {
+        id = (_idNext * _chainIdMultiplier + _chainIdInt) * 100 + _chainIdDigits;
         _idNext++;
     }
 
-    function _countDigits(uint256 num) private pure returns (uint256 count) {
+
+    function _countDigits(uint256 num)
+        private 
+        pure 
+        returns (uint256 count)
+    {
         count = 0;
         while (num != 0) {
             count++;

package/contracts/registry/IChainNft.sol

@@ -3,19 +3,16 @@ 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);
+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 exists(uint256 tokenId) external view returns(bool);
+    function totalMinted() external view returns(uint256);
 
-    function getRegistryAddress() external view returns (address registry);
+    function getRegistryAddress() external view returns(address registry);
 }

package/contracts/registry/IRegistry.sol

@@ -4,34 +4,36 @@ pragma solidity ^0.8.19;
 import {NftId} from "../types/NftId.sol";
 
 interface IOwnable {
-    function getOwner() external view returns (address owner);
+    function getOwner() external view returns(address owner);
 }
 
 interface IRegistryLinked {
+
     event LogDebug(uint256 idx, address module, string comment);
 
-    function getRegistry() external view returns (IRegistry registry);
+    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 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;
@@ -40,41 +42,29 @@ interface IRegistry {
         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 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);
+    )
+        external returns(NftId nftId);
 
-    function getInfo(
-        NftId nftId
-    ) external view returns (RegistryInfo memory info);
+    function getObjectCount() external view returns(uint256);
 
-    function getOwner(NftId nftId) external view returns (address ownerAddress);
+    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 isRegistered(address objectAddress) external view returns(bool);
 
-    function getNftAddress() external view returns (address nft);
+    function getNftAddress() external view returns(address nft);
 }