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

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);
+}

package/contracts/registry/IRegistry.sol

@@ -0,0 +1,80 @@
+// 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);
+}

package/contracts/registry/Registry.sol

@@ -0,0 +1,209 @@
+// 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 {
+    IRegistry internal _registry;
+
+    constructor(address registry) {
+        _registry = IRegistry(registry);
+    }
+
+    function getRegistry() external view override returns (IRegistry registry) {
+        return _registry;
+    }
+}
+
+abstract contract Registerable is RegistryLinked, IRegisterable {
+    using NftIdLib for NftId;
+
+    address private _initialOwner;
+
+    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) {
+        return true;
+    }
+
+    function getInitialOwner() public view override returns (address deployer) {
+        return _initialOwner;
+    }
+
+    function isRegistered() public view override returns (bool) {
+        NftId nftId = _registry.getNftId(address(this));
+        return nftId.gtz();
+    }
+
+    function getNftId() public view override returns (NftId nftId) {
+        return _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(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"
+        );
+        _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 (NftId nftId) {
+        require(
+            _nftIdByAddress[objectAddress].eqz(),
+            "ERROR:REG-002:ALREADY_REGISTERED"
+        );
+
+        IRegisterable registerable = IRegisterable(objectAddress);
+        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.gtz(), "ERROR:REG-004:PARENT_NOT_FOUND");
+            // check validity of parent relation, valid relations are
+            // policy -> product, bundle -> pool, product -> instance, pool -> instance
+        }
+
+        uint256 mintedTokenId = _chainNft.mint(
+            registerable.getInitialOwner(),
+            EMPTY_URI
+        );
+        nftId = toNftId(mintedTokenId);
+
+        RegistryInfo memory info = RegistryInfo(
+            nftId,
+            registerable.getParentNftId(),
+            registerable.getType(),
+            objectAddress,
+            registerable.getInitialOwner()
+        );
+
+        _info[nftId] = info;
+        _nftIdByAddress[objectAddress] = nftId;
+
+        // add logging
+    }
+
+    function registerObjectForInstance(
+        NftId parentNftId,
+        uint256 objectType,
+        address initialOwner
+    )
+        external
+        override
+        returns (
+            // TODO add onlyRegisteredInstance
+            NftId nftId
+        )
+    {
+        // TODO add more validation
+        require(
+            objectType == POLICY() || objectType == BUNDLE(),
+            "ERROR:REG-005:TYPE_INVALID"
+        );
+
+        uint256 mintedTokenId = _chainNft.mint(initialOwner, EMPTY_URI);
+        nftId = toNftId(mintedTokenId);
+
+        RegistryInfo memory info = RegistryInfo(
+            nftId,
+            parentNftId,
+            objectType,
+            address(0),
+            initialOwner
+        );
+
+        _info[nftId] = info;
+
+        // add logging
+    }
+
+    function getObjectCount() external view override returns (uint256) {
+        return _chainNft.totalSupply();
+    }
+
+    function getNftId(
+        address object
+    ) external view override returns (NftId id) {
+        return _nftIdByAddress[object];
+    }
+
+    function isRegistered(
+        address object
+    ) external view override returns (bool) {
+        return _nftIdByAddress[object].gtz();
+    }
+
+    function getInfo(
+        NftId nftId
+    ) external view override returns (RegistryInfo memory info) {
+        return _info[nftId];
+    }
+
+    function getOwner(NftId nftId) external view override returns (address) {
+        return _chainNft.ownerOf(nftId.toInt());
+    }
+
+    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)));
+    }
+}

package/contracts/types/ChainId.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+/// @dev 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
+/// @dev Converts the uint256 to a ChainId.
+function toChainId(uint256 chainId) pure returns (ChainId) {
+    return ChainId.wrap(bytes5(uint40(chainId)));
+}
+
+/// @dev Return the ChainId for the chain the contract is deployed to
+function thisChainId() view returns (ChainId) {
+    return toChainId(block.chainid);
+}
+
+// pure free functions for operators
+/// @dev Returns true if the values are equal (==).
+function eqChainId(ChainId a, ChainId b) pure returns (bool isSame) {
+    return ChainId.unwrap(a) == ChainId.unwrap(b);
+}
+
+/// @dev Returns true if the values are not equal (!=).
+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 {
+    /// @dev Converts the ChainId to a uint256.
+    function toInt(ChainId chainId) internal pure returns (uint256) {
+        return uint256(uint40(ChainId.unwrap(chainId)));
+    }
+}

package/contracts/types/NftId.sol

@@ -0,0 +1,51 @@
+// 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);
+    }
+}