@etherisc/gif-next 0.0.2-ed4dd55 → 0.0.2-f619be3-760

package/contracts/registry/ChainNft.sol

@@ -4,10 +4,7 @@ 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";
 
@@ -18,22 +15,18 @@ contract ChainNft is
     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;
@@ -43,88 +36,59 @@ contract ChainNft is
         _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 override view returns(uint256) {
+    function totalMinted() external view override returns (uint256) {
         return _totalMinted;
     }
 
@@ -153,17 +117,15 @@ contract ChainNft is
     // (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,16 +3,19 @@ pragma solidity ^0.8.19;
 
 import {IERC721Enumerable} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
 
-interface IChainNft is 
-    IERC721Enumerable 
-{
+interface IChainNft is IERC721Enumerable {
+    function mint(
+        address to,
+        string memory uri
+    ) external returns (uint256 tokenId);
 
-    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

@@ -1,68 +1,67 @@
 // SPDX-License-Identifier: Apache-2.0
 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);
+    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(uint256 nftId);
-    
-    function getNftId() external view returns(uint256 nftId);
-    function getParentNftId() external view returns(uint256 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);
 
-interface IRegistry {
+    function getParentNftId() external view returns (NftId parentNftId);
+
+    function getType() external view returns (ObjectType 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 {
-        uint256 nftId;
-        uint256 parentNftId;
-        uint256 objectType;
+        NftId nftId;
+        NftId parentNftId;
+        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 register(address objectAddress) external returns(uint256 nftId);
     function registerObjectForInstance(
-        uint256 parentNftid,
-        uint256 objectType,
+        NftId parentNftid,
+        ObjectType objectType,
         address initialOwner
-    )
-        external returns(uint256 nftId);
+    ) external returns (NftId nftId);
+
+    function getObjectCount() external view returns (uint256);
+
+    function getNftId(
+        address objectAddress
+    ) external view returns (NftId nftId);
 
-    function getObjectCount() external view returns(uint256);
+    function getInfo(
+        NftId nftId
+    ) external view returns (RegistryInfo memory info);
 
-    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 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);
 }

package/contracts/registry/Registry.sol

@@ -3,102 +3,105 @@ pragma solidity ^0.8.19;
 
 import {IChainNft} from "./IChainNft.sol";
 import {IRegistry, IRegistryLinked, IRegisterable} from "./IRegistry.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;
-    
+
     constructor(address registry) {
         _registry = IRegistry(registry);
     }
 
-    function getRegistry() external view override returns(IRegistry registry) {
+    function getRegistry() external view override returns (IRegistry registry) {
         return _registry;
     }
-
 }
 
-
-abstract contract Registerable is 
-    RegistryLinked,
-    IRegisterable
-{
+abstract contract Registerable is RegistryLinked, IRegisterable {
+    using NftIdLib for NftId;
 
     address private _initialOwner;
-    
-    constructor(address registry)
-        RegistryLinked(registry)
-    {
+
+    constructor(address registry) RegistryLinked(registry) {
         _initialOwner = msg.sender;
     }
 
     // getType, getData and register need to be implemented by concrete contract
 
-    function isRegisterable() external pure override returns(bool) {
+    function isRegisterable() external pure override returns (bool) {
         return true;
     }
 
-    function getInitialOwner() public view override returns(address deployer) {
+    function getInitialOwner() public view override returns (address deployer) {
         return _initialOwner;
     }
 
-    function isRegistered() public view override returns(bool) {
-        return _registry.getNftId(address(this)) > 0;
+    function isRegistered() public view override returns (bool) {
+        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));
+    function getOwner() public view override returns (address owner) {
+        NftId id = _registry.getNftId(address(this));
         owner = _registry.getOwner(id);
         return owner != address(0) ? owner : _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;
+    mapping(NftId nftId => RegistryInfo info) private _info;
+    mapping(NftId nftId => address owner) private _owner;
+    mapping(address object => NftId nftId) private _nftIdByAddress;
 
     IChainNft private _chainNft;
 
     function initialize(address chainNft) external {
-        require(address(_chainNft) == address(0), "ERROR:REG-001:ALREADY_INITIALIZED");
+        require(
+            address(_chainNft) == address(0),
+            "ERROR:REG-001:ALREADY_INITIALIZED"
+        );
         _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(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");
+        if (registerable.getType() != INSTANCE()) {
+            RegistryInfo memory parentInfo = _info[
+                registerable.getParentNftId()
+            ];
+            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 = _chainNft.mint(
-            registerable.getInitialOwner(), 
-            EMPTY_URI);
-    
+        uint256 mintedTokenId = _chainNft.mint(
+            registerable.getInitialOwner(),
+            EMPTY_URI
+        );
+        nftId = toNftId(mintedTokenId);
+
         RegistryInfo memory info = RegistryInfo(
             nftId,
             registerable.getParentNftId(),
@@ -108,30 +111,31 @@ contract Registry is IRegistry {
         );
 
         _info[nftId] = info;
-        _idByAddress[objectAddress] = nftId;
+        _nftIdByAddress[objectAddress] = nftId;
 
         // add logging
     }
 
-
     function registerObjectForInstance(
-        uint256 parentNftId,
-        uint256 objectType,
+        NftId parentNftId,
+        ObjectType objectType,
         address initialOwner
     )
-        external 
+        external
         override
-        // TODO add onlyRegisteredInstance
-        returns(uint256 nftId)
+        returns (
+            // TODO add onlyRegisteredInstance
+            NftId nftId
+        )
     {
         // TODO add more validation
         require(
             objectType == POLICY() || objectType == BUNDLE(),
-            "ERROR:REG-005:TYPE_INVALID");
+            "ERROR:REG-005:TYPE_INVALID"
+        );
 
-        nftId = _chainNft.mint(
-            initialOwner,
-            EMPTY_URI);
+        uint256 mintedTokenId = _chainNft.mint(initialOwner, EMPTY_URI);
+        nftId = toNftId(mintedTokenId);
 
         RegistryInfo memory info = RegistryInfo(
             nftId,
@@ -146,31 +150,33 @@ contract Registry is IRegistry {
         // add logging
     }
 
-
-    function getObjectCount() external view override returns(uint256) {
+    function getObjectCount() external view override returns (uint256) {
         return _chainNft.totalSupply();
     }
 
-
-    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;
+    function isRegistered(
+        address object
+    ) external view override returns (bool) {
+        return _nftIdByAddress[object].gtz();
     }
 
-
-    function getInfo(uint256 nftId) external view override returns(RegistryInfo memory info) {
+    function getInfo(
+        NftId nftId
+    ) external view override returns (RegistryInfo memory info) {
         return _info[nftId];
     }
 
-    function getOwner(uint256 nftId) external view override returns(address) {
-        return _chainNft.ownerOf(nftId);
+    function getOwner(NftId nftId) external view override returns (address) {
+        return _chainNft.ownerOf(nftId.toInt());
     }
 
-    function getNftAddress() external view override returns(address nft) {
+    function getNftAddress() external view override returns (address nft) {
         return address(_chainNft);
     }
 }

package/contracts/types/Blocknumber.sol

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+type Blocknumber is uint32;
+
+using {
+    gtBlocknumber as >,
+    gteBlocknumber as >=,
+    ltBlocknumber as <,
+    lteBlocknumber as <=,
+    eqBlocknumber as ==,
+    neBlocknumber as !=,
+    BlocknumberLib.toInt
+} for Blocknumber global;
+
+/// @dev return true if Blocknumber a is greater than Blocknumber b
+function gtBlocknumber(Blocknumber a, Blocknumber b) pure returns (bool) {
+    return Blocknumber.unwrap(a) > Blocknumber.unwrap(b);
+}
+
+/// @dev return true if Blocknumber a is greater than or equal to Blocknumber b
+function gteBlocknumber(Blocknumber a, Blocknumber b) pure returns (bool) {
+    return Blocknumber.unwrap(a) >= Blocknumber.unwrap(b);
+}
+
+/// @dev return true if Blocknumber a is less than Blocknumber b
+function ltBlocknumber(Blocknumber a, Blocknumber b) pure returns (bool) {
+    return Blocknumber.unwrap(a) < Blocknumber.unwrap(b);
+}
+
+/// @dev return true if Blocknumber a is less than or equal to Blocknumber b
+function lteBlocknumber(Blocknumber a, Blocknumber b) pure returns (bool) {
+    return Blocknumber.unwrap(a) <= Blocknumber.unwrap(b);
+}
+
+/// @dev return true if Blocknumber a is equal to Blocknumber b
+function eqBlocknumber(Blocknumber a, Blocknumber b) pure returns (bool) {
+    return Blocknumber.unwrap(a) == Blocknumber.unwrap(b);
+}
+
+/// @dev return true if Blocknumber a is not equal to Blocknumber b
+function neBlocknumber(Blocknumber a, Blocknumber b) pure returns (bool) {
+    return Blocknumber.unwrap(a) != Blocknumber.unwrap(b);
+}
+
+/// @dev Converts the uint256 to a Blocknumber.
+function toBlocknumber(uint256 blocknum) pure returns (Blocknumber) {
+    return Blocknumber.wrap(uint32(blocknum));
+}
+
+function blockBlocknumber() view returns (Blocknumber) {
+    return toBlocknumber(block.number);
+}
+
+/// @dev Return the Blocknumber zero (0)
+function zeroBlocknumber() pure returns (Blocknumber) {
+    return toBlocknumber(0);
+}
+
+/// @dev Return the current block number
+function blockNumber() view returns (Blocknumber) {
+    return toBlocknumber(block.number);
+}
+
+library BlocknumberLib {
+    /// @dev return true if Blocknumber a is greater than Blocknumber b
+    function gt(
+        Blocknumber a,
+        Blocknumber b
+    ) public pure returns (bool isAfter) {
+        return gtBlocknumber(a, b);
+    }
+
+    /// @dev return true if Blocknumber a is greater than or equal to Blocknumber b
+    function gte(
+        Blocknumber a,
+        Blocknumber b
+    ) public pure returns (bool isAfterOrSame) {
+        return gteBlocknumber(a, b);
+    }
+
+    /// @dev return true if Blocknumber a is less than Blocknumber b
+    function lt(
+        Blocknumber a,
+        Blocknumber b
+    ) public pure returns (bool isBefore) {
+        return ltBlocknumber(a, b);
+    }
+
+    /// @dev return true if Blocknumber a is less than or equal to Blocknumber b
+    function lte(
+        Blocknumber a,
+        Blocknumber b
+    ) public pure returns (bool isBeforeOrSame) {
+        return lteBlocknumber(a, b);
+    }
+
+    /// @dev return true if Blocknumber a is equal to Blocknumber b
+    function eq(
+        Blocknumber a,
+        Blocknumber b
+    ) public pure returns (bool isSame) {
+        return eqBlocknumber(a, b);
+    }
+
+    /// @dev return true if Blocknumber a is not equal to Blocknumber b
+    function ne(
+        Blocknumber a,
+        Blocknumber b
+    ) public pure returns (bool isDifferent) {
+        return neBlocknumber(a, b);
+    }
+
+    /// @dev converts the Blocknumber to a uint256
+    function toInt(Blocknumber blocknumber) public pure returns (uint256) {
+        return uint256(uint32(Blocknumber.unwrap(blocknumber)));
+    }
+}