@etherisc/gif-next 0.0.2-4caa207 → 0.0.2-4e9f361

package/contracts/registry/Registry.sol

@@ -0,0 +1,182 @@
+// 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
+        // TODO add onlyRegisteredInstance
+        returns(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/ChainId.sol

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

package/contracts/types/Timestamp.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+type Timestamp is uint40;
+
+using {
+    gtTimestamp as >,
+    gteTimestamp as >=,
+    ltTimestamp as <,
+    lteTimestamp as <=,
+    eqTimestamp as ==,
+    neqTimestamp as !=
+} for Timestamp global;
+
+/// @dev return true if Timestamp a is after Timestamp b
+function gtTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) > Timestamp.unwrap(b); }
+/// @dev return true if Timestamp a is after or equal to Timestamp b
+function gteTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) >= Timestamp.unwrap(b); }
+
+/// @dev return true if Timestamp a is before Timestamp b
+function ltTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) < Timestamp.unwrap(b); }
+/// @dev return true if Timestamp a is before or equal to Timestamp b
+function lteTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) <= Timestamp.unwrap(b); }
+
+/// @dev return true if Timestamp a is equal to Timestamp b
+function eqTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) == Timestamp.unwrap(b); }
+/// @dev return true if Timestamp a is not equal to Timestamp b
+function neqTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) != Timestamp.unwrap(b); }
+
+/// @dev Converts the uint256 to a Timestamp.
+function toTimestamp(uint256 timestamp) pure returns(Timestamp) { return Timestamp.wrap(uint40(timestamp));}
+
+function blockTimestamp() view returns(Timestamp) { return toTimestamp(block.timestamp); }
+
+/// @dev Return the Timestamp zero (0)
+function zeroTimestamp() pure returns(Timestamp) { return toTimestamp(0); }
+
+library TimestampLib {
+    /// @dev return true if Timestamp a is after Timestamp b
+    function gt(Timestamp a, Timestamp b) internal pure returns(bool isAfter) { return gtTimestamp(a, b); }
+    /// @dev return true if Timestamp a is after or the same than Timestamp b
+    function gte(Timestamp a, Timestamp b) internal pure returns(bool isAfterOrSame) { return gteTimestamp(a, b); }
+
+    /// @dev return true if Timestamp a is before Timestamp b
+    function lt(Timestamp a, Timestamp b) internal pure returns(bool isBefore) { return ltTimestamp(a, b); }
+    /// @dev return true if Timestamp a is before or the same than Timestamp b
+    function lte(Timestamp a, Timestamp b) internal pure returns(bool isBeforeOrSame) { return lteTimestamp(a, b); }
+
+    /// @dev return true if Timestamp a is equal to Timestamp b
+    function eq(Timestamp a, Timestamp b) internal pure returns(bool isSame) { return eqTimestamp(a, b); }
+    /// @dev return true if Timestamp a is not equal to Timestamp b
+    function ne(Timestamp a, Timestamp b) internal pure returns(bool isDifferent) { return neqTimestamp(a, b); }
+
+    function toInt(Timestamp timestamp) internal pure returns(uint256) { return uint256(uint40(Timestamp.unwrap(timestamp))); }
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-4caa207",
+  "version": "0.0.2-4e9f361",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {
-    "build": "hardhat compile",
-    "test": "hardhat test",
-    "ptest": "hardhat test --parallel",
-    "test-with-gas": "REPORT_GAS=true hardhat test",
-    "coverage": "hardhat coverage"
+    "build": "hh compile",
+    "test": "hh test",
+    "ptest": "hh test --parallel",
+    "test-with-gas": "REPORT_GAS=true hh test",
+    "coverage": "hh coverage"
   },
   "repository": {
     "type": "git",
@@ -27,6 +27,7 @@
   "devDependencies": {
     "@nomicfoundation/hardhat-foundry": "^1.0.3",
     "@nomicfoundation/hardhat-toolbox": "^3.0.0",
+    "dotenv": "^16.3.1",
     "hardhat": "^2.17.1"
   },
   "dependencies": {

package/artifacts/contracts/Dip.sol/DIP.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../build-info/d6ddc31c8d0f29d05ebcf7dbd3184aca.json"
-}