@etherisc/gif-next 0.0.2-b9b3e89 → 0.0.2-d250c72

package/contracts/instance/pool/PoolModule.sol

@@ -5,13 +5,16 @@ 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(uint256 nftId => PoolInfo info) private _poolInfo;
+    mapping(NftId nftId => PoolInfo info) private _poolInfo;
 
     IProductService private _productService;
 
@@ -25,7 +28,7 @@ abstract contract PoolModule is
     }
 
     function createPoolInfo(
-        uint256 nftId,
+        NftId nftId,
         address wallet,
         address token
     )
@@ -33,7 +36,7 @@ abstract contract PoolModule is
         override
     {
         require(
-            _poolInfo[nftId].nftId == 0,
+            _poolInfo[nftId].nftId.eqz(),
             "ERROR:PL-001:ALREADY_CREATED");
 
         _poolInfo[nftId] = PoolInfo(
@@ -48,8 +51,8 @@ abstract contract PoolModule is
 
 
     function underwrite(
-        uint256 poolNftId,
-        uint256 policyNftId
+        NftId poolNftId,
+        NftId policyNftId
     )
         external
         override
@@ -71,7 +74,7 @@ abstract contract PoolModule is
     }
 
 
-    function getPoolInfo(uint256 nftId)
+    function getPoolInfo(NftId nftId)
         external
         view
         override

package/contracts/instance/product/IProductService.sol

@@ -4,6 +4,7 @@ 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, ...)
@@ -16,17 +17,17 @@ interface IProductService is
         uint256 sumInsuredAmount,
         uint256 premiumAmount,
         uint256 lifetime,
-        uint256 bundleNftId
+        NftId bundleNftId
     )
         external 
-        returns(uint256 nftId);
+        returns(NftId nftId);
 
     // function revoke(unit256 nftId) external;
 
-    function underwrite(uint256 nftId) external;
+    function underwrite(NftId nftId) external;
     // function decline(uint256 nftId) external;
     // function expire(uint256 nftId) external;
-    function close(uint256 nftId) external;
+    function close(NftId nftId) external;
 
     // function collectPremium(uint256 nftId, uint256 premiumAmount) external;
 

package/contracts/instance/product/ProductService.sol

@@ -11,12 +11,15 @@ 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)
     { }
@@ -27,20 +30,20 @@ contract ProductService is
         uint256 sumInsuredAmount,
         uint256 premiumAmount,
         uint256 lifetime,
-        uint256 bundleNftId
+        NftId bundleNftId
     )
         external 
         override
-        returns(uint256 nftId)
+        returns(NftId nftId)
     {
         // same as only registered product
-        uint256 productNftId = _registry.getNftId(msg.sender);
-        require(productNftId > 0, "ERROR_PRODUCT_UNKNOWN");
+        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 > 0, "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
         require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
 
         IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
@@ -55,23 +58,23 @@ contract ProductService is
         // add logging
     }
 
-    function underwrite(uint256 nftId)
+    function underwrite(NftId nftId)
         external
         override
     {
         // same as only registered product
-        uint256 productNftId = _registry.getNftId(msg.sender);
-        require(productNftId > 0, "ERROR_PRODUCT_UNKNOWN");
+        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 > 0, "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
         require(instanceInfo.objectType == _registry.INSTANCE(), "ERROR_NOT_INSTANCE");
 
         // get responsible pool
         IComponentModule componentModule = IComponentModule(instanceInfo.objectAddress);
-        uint256 poolNftId = componentModule.getPoolNftId(productNftId);
+        NftId poolNftId = componentModule.getPoolNftId(productNftId);
 
         // lock capital (and update pool accounting)
         IPoolModule poolModule = IPoolModule(instanceInfo.objectAddress);
@@ -86,7 +89,7 @@ contract ProductService is
         // add logging
     }
 
-    function close(uint256 nftId) external override {}
+    function close(NftId nftId) external override {}
 }
 
 abstract contract ProductModule is

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

@@ -1,6 +1,8 @@
 // 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);
 }
@@ -17,10 +19,10 @@ interface IRegisterable is
     IRegistryLinked
 {
 
-    function register() external returns(uint256 nftId);
+    function register() external returns(NftId nftId);
     
-    function getNftId() external view returns(uint256 nftId);
-    function getParentNftId() external view returns(uint256 parentNftId);
+    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);
@@ -33,8 +35,8 @@ interface IRegisterable is
 interface IRegistry {
 
     struct RegistryInfo {
-        uint256 nftId;
-        uint256 parentNftId;
+        NftId nftId;
+        NftId parentNftId;
         uint256 objectType;
         address objectAddress;
         address initialOwner;
@@ -48,19 +50,21 @@ interface IRegistry {
     function POLICY() external pure returns(uint256);
     function BUNDLE() external pure returns(uint256);
 
-    function register(address objectAddress) external returns(uint256 nftId);
+    function register(address objectAddress) external returns(NftId nftId);
     function registerObjectForInstance(
-        uint256 parentNftid,
+        NftId parentNftid,
         uint256 objectType,
         address initialOwner
     )
-        external returns(uint256 nftId);
+        external returns(NftId nftId);
 
-    function transfer(uint256 nftId, address newOwner) external;
+    function getObjectCount() external view returns(uint256);
 
-    function getNftId(address objectAddress) external view returns(uint256 nftId);
-    function getInfo(uint256 nftId) external view returns(RegistryInfo memory info);
-    function getOwner(uint256 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 getNftAddress() external view returns(address nft);
 }

package/contracts/registry/Registry.sol

@@ -1,7 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 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";
 
 contract RegistryLinked is IRegistryLinked {
 
@@ -11,11 +14,6 @@ contract RegistryLinked is IRegistryLinked {
         _registry = IRegistry(registry);
     }
 
-    // function setRegistry(address registry) public override {
-    //     require(address(_registry) == address(0), "ERROR:RGL-001:REGISTRY_ALREADY_SET");
-    //     _registry = IRegistry(registry);
-    // }
-
     function getRegistry() external view override returns(IRegistry registry) {
         return _registry;
     }
@@ -27,6 +25,7 @@ abstract contract Registerable is
     RegistryLinked,
     IRegisterable
 {
+    using NftIdLib for NftId;
 
     address private _initialOwner;
     
@@ -47,39 +46,35 @@ abstract contract Registerable is
     }
 
     function isRegistered() public view override returns(bool) {
-        return _registry.getNftId(address(this)) > 0;
+        NftId nftId = _registry.getNftId(address(this));
+        return nftId.gtz();
     }
 
-    function getNftId() public view override returns(uint256 id) {
+    function getNftId() public view override returns(NftId nftId) {
         return _registry.getNftId(address(this));
     }
 
     function getOwner() public view override returns(address owner) {
-        uint256 id = _registry.getNftId(address(this));
+        NftId id = _registry.getNftId(address(this));
         owner = _registry.getOwner(id);
         return owner != address(0) ? owner : _initialOwner;
     }
 
 }
 
-    // struct RegistryInfo {
-    //     bytes32 id;
-    //     uint256 objectType;
-    //     address objectAddress;
-    //     address initialOwner;
-    // }
-
 contract Registry is IRegistry {
+    using NftIdLib for NftId;
+    string public constant EMPTY_URI = "";
 
-    mapping(uint256 id => RegistryInfo info) private _info;
-    mapping(uint256 id => address owner) private _owner;
-    mapping(address object => uint256 id) private _idByAddress;
-    uint256 [] private _ids;
-    uint256 private _idNext;
+    mapping(NftId nftId => RegistryInfo info) private _info;
+    mapping(NftId nftId => address owner) private _owner;
+    mapping(address object => NftId nftId) private _nftIdByAddress;
 
+    IChainNft private _chainNft;
 
-    constructor() {
-        _idNext = 0;
+    function initialize(address chainNft) external {
+        require(address(_chainNft) == address(0), "ERROR:REG-001:ALREADY_INITIALIZED");
+        _chainNft = IChainNft(chainNft);
     }
 
     function TOKEN() public pure override returns(uint256) { return 30; }
@@ -90,21 +85,24 @@ contract Registry is IRegistry {
     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(uint256 nftId) {
-        require(_idByAddress[objectAddress] == 0, "ERROR:REG-001:ALREADY_REGISTERED");
+    function register(address objectAddress) external override returns(NftId nftId) {
+        require(_nftIdByAddress[objectAddress].eqz(), "ERROR:REG-002:ALREADY_REGISTERED");
 
         IRegisterable registerable = IRegisterable(objectAddress);
-        require(registerable.isRegisterable(), "ERROR:REG-002:NOT_REGISTERABLE");
+        require(registerable.isRegisterable(), "ERROR:REG-003:NOT_REGISTERABLE");
 
         // check parent exists (for objects not instances)
         if(registerable.getType() != INSTANCE()) {
             RegistryInfo memory parentInfo = _info[registerable.getParentNftId()];
-            require(parentInfo.nftId > 0, "ERROR:REG-003:PARENT_NOT_FOUND");
+            require(parentInfo.nftId.gtz(), "ERROR:REG-004:PARENT_NOT_FOUND");
             // check validity of parent relation, valid relations are
             // policy -> product, bundle -> pool, product -> instance, pool -> instance
         }
 
-        nftId = _mint(registerable.getInitialOwner());
+        uint256 mintedTokenId = _chainNft.mint(
+            registerable.getInitialOwner(), 
+            EMPTY_URI);
+        nftId = toNftId(mintedTokenId);
     
         RegistryInfo memory info = RegistryInfo(
             nftId,
@@ -115,28 +113,31 @@ contract Registry is IRegistry {
         );
 
         _info[nftId] = info;
-        _idByAddress[objectAddress] = nftId;
+        _nftIdByAddress[objectAddress] = nftId;
 
         // add logging
     }
 
 
     function registerObjectForInstance(
-        uint256 parentNftId,
+        NftId parentNftId,
         uint256 objectType,
         address initialOwner
     )
         external 
         override
         // TODO add onlyRegisteredInstance
-        returns(uint256 nftId)
+        returns(NftId nftId)
     {
         // TODO add more validation
         require(
             objectType == POLICY() || objectType == BUNDLE(),
             "ERROR:REG-005:TYPE_INVALID");
 
-        nftId = _mint(initialOwner);
+        uint256 mintedTokenId = _chainNft.mint(
+            initialOwner,
+            EMPTY_URI);
+        nftId = toNftId(mintedTokenId);
 
         RegistryInfo memory info = RegistryInfo(
             nftId,
@@ -152,46 +153,30 @@ contract Registry is IRegistry {
     }
 
 
-    function transfer(uint256 id, address newOwner) external {
-        require(msg.sender == _owner[id], "ERROR:REG-010:NOT_OWNER");
-        _owner[id] = newOwner;
-
-        // TODO logging
+    function getObjectCount() external view override returns(uint256) {
+        return _chainNft.totalSupply();
     }
 
 
-    function getObjectCount() external view returns(uint256) {
-        return _ids.length;
-    }
-
-
-    function getNftId(address object) external view override returns(uint256 id) {
-        return _idByAddress[object];
+    function getNftId(address object) external view override returns(NftId id) {
+        return _nftIdByAddress[object];
     }
 
 
     function isRegistered(address object) external view override returns(bool) {
-        return _idByAddress[object] > 0;
+        return _nftIdByAddress[object].gtz();
     }
 
 
-    function getInfo(uint256 id) external view override returns(RegistryInfo memory info) {
-        return _info[id];
+    function getInfo(NftId nftId) external view override returns(RegistryInfo memory info) {
+        return _info[nftId];
     }
 
-    function getOwner(uint256 id) external view override returns(address) {
-        return _owner[id];
+    function getOwner(NftId nftId) external view override returns(address) {
+        return _chainNft.ownerOf(nftId.toInt());
     }
 
-
-    function _mint(address initialOwner)
-        internal
-        returns(uint256 id)
-    {
-        _idNext++;
-
-        id = _idNext;
-        _owner[id] = initialOwner;
-        _ids.push(id);
+    function getNftAddress() external view override returns(address nft) {
+        return address(_chainNft);
     }
 }

package/contracts/types/ChainId.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// bytes5 (uint40) allows for chain ids up to 13 digits
+type ChainId is bytes5;
+
+// type bindings
+using {
+    eqChainId as ==,
+    neChainId as !=,
+    ChainIdLib.toInt
+} for ChainId global;
+
+// general pure free functions
+function toChainId(uint256 chainId) pure returns(ChainId) { return ChainId.wrap(bytes5(uint40(chainId))); }
+
+// pure free functions for operators
+function eqChainId(ChainId a, ChainId b) pure returns(bool isSame) { return ChainId.unwrap(a) == ChainId.unwrap(b); }
+function neChainId(ChainId a, ChainId b) pure returns(bool isDifferent) { return ChainId.unwrap(a) != ChainId.unwrap(b); }
+
+// library functions that operate on user defined type
+library ChainIdLib {
+    function toInt(ChainId chainId) internal pure returns(uint256) { return uint256(uint40(ChainId.unwrap(chainId))); }
+}

package/contracts/types/NftId.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// uint96 allows for chain ids up to 13 digits
+type NftId is uint96;
+
+// type bindings
+using {
+    eqNftId as ==,
+    neNftId as !=,
+    NftIdLib.toInt
+} for NftId global;
+
+// general pure free functions
+/// @dev Converts the uint256 to a NftId.
+function toNftId(uint256 id) pure returns(NftId) { return NftId.wrap(uint96(id)); }
+
+/// @dev Return the NftId zero (0)
+function zeroNftId() pure returns(NftId) { return NftId.wrap(0); }
+
+// pure free functions for operators
+function eqNftId(NftId a, NftId b) pure returns(bool isSame) { return NftId.unwrap(a) == NftId.unwrap(b); }
+function neNftId(NftId a, NftId b) pure returns(bool isDifferent) { return NftId.unwrap(a) != NftId.unwrap(b); }
+
+// library functions that operate on user defined type
+library NftIdLib {
+    /// @dev Converts the NftId to a uint256.
+    function toInt(NftId nftId) public pure returns(uint96) { return uint96(NftId.unwrap(nftId)); }
+    /// @dev Returns true if the value is non-zero (> 0).
+    function gtz(NftId a) public pure returns(bool) { return NftId.unwrap(a) > 0; }
+    /// @dev Returns true if the value is zero (== 0).
+    function eqz(NftId a) public pure returns(bool) { return NftId.unwrap(a) == 0; }
+    /// @dev Returns true if the values are equal (==).
+    function eq(NftId a, NftId b) public pure returns(bool isSame) { return eqNftId(a, b); }
+}