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

package/contracts/registry/Registry.sol

@@ -7,50 +7,59 @@ import {NftId, toNftId} from "../types/NftId.sol";
 import {NftIdLib} from "../types/NftId.sol";
 
 contract RegistryLinked is IRegistryLinked {
-    IRegistry internal _registry;
 
+    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) {
+    function isRegistered() public view override returns(bool) {
         NftId nftId = _registry.getNftId(address(this));
         return nftId.gtz();
     }
 
-    function getNftId() public view override returns (NftId nftId) {
+    function getNftId() public view override returns(NftId nftId) {
         return _registry.getNftId(address(this));
     }
 
-    function getOwner() public view override returns (address owner) {
+    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 {
@@ -64,71 +73,37 @@ contract Registry is IRegistry {
     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 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 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"
-        );
+    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"
-        );
+        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()
-            ];
+        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
-        );
+            registerable.getInitialOwner(), 
+            EMPTY_URI);
         nftId = toNftId(mintedTokenId);
-
+    
         RegistryInfo memory info = RegistryInfo(
             nftId,
             registerable.getParentNftId(),
@@ -143,25 +118,25 @@ contract Registry is IRegistry {
         // add logging
     }
 
+
     function registerObjectForInstance(
         NftId parentNftId,
         uint256 objectType,
         address initialOwner
     )
-        external
+        external 
         override
-        returns (
-            // TODO add onlyRegisteredInstance
-            NftId nftId
-        )
+        // TODO add onlyRegisteredInstance
+        returns(NftId nftId)
     {
         // TODO add more validation
         require(
             objectType == POLICY() || objectType == BUNDLE(),
-            "ERROR:REG-005:TYPE_INVALID"
-        );
+            "ERROR:REG-005:TYPE_INVALID");
 
-        uint256 mintedTokenId = _chainNft.mint(initialOwner, EMPTY_URI);
+        uint256 mintedTokenId = _chainNft.mint(
+            initialOwner,
+            EMPTY_URI);
         nftId = toNftId(mintedTokenId);
 
         RegistryInfo memory info = RegistryInfo(
@@ -177,33 +152,31 @@ 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 (NftId id) {
+
+    function getNftId(address object) external view override returns(NftId id) {
         return _nftIdByAddress[object];
     }
 
-    function isRegistered(
-        address object
-    ) external view override returns (bool) {
+
+    function isRegistered(address object) external view override returns(bool) {
         return _nftIdByAddress[object].gtz();
     }
 
-    function getInfo(
-        NftId nftId
-    ) external view override returns (RegistryInfo memory info) {
+
+    function getInfo(NftId nftId) external view override returns(RegistryInfo memory info) {
         return _info[nftId];
     }
 
-    function getOwner(NftId nftId) external view override returns (address) {
+    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

@@ -14,105 +14,47 @@ using {
 } 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);
-}
-
+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);
-}
+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);
-}
-
+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);
-}
+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);
-}
-
+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);
-}
+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 toBlocknumber(uint256 blocknum) pure returns(Blocknumber) { return Blocknumber.wrap(uint32(blocknum)); }
 
-function blockBlocknumber() view returns (Blocknumber) {
-    return toBlocknumber(block.number);
-}
+function blockBlocknumber() view returns(Blocknumber) { return toBlocknumber(block.number); }
 
 /// @dev Return the Blocknumber zero (0)
-function zeroBlocknumber() pure returns (Blocknumber) {
-    return toBlocknumber(0);
-}
+function zeroBlocknumber() pure returns(Blocknumber) { return toBlocknumber(0); }
 
 /// @dev Return the current block number
-function blockNumber() view returns (Blocknumber) {
-    return toBlocknumber(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);
-    }
-
+    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);
-    }
-
+    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);
-    }
-
+    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);
-    }
+    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);
-    }
-
+    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);
-    }
+    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)));
-    }
+    function toInt(Blocknumber blocknumber) public pure returns(uint256) { return uint256(uint32(Blocknumber.unwrap(blocknumber))); }
 }

package/contracts/types/ChainId.sol

@@ -5,34 +5,26 @@ pragma solidity ^0.8.19;
 type ChainId is bytes5;
 
 // type bindings
-using {eqChainId as ==, neChainId as !=, ChainIdLib.toInt} for ChainId global;
+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)));
-}
-
+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);
-}
+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);
-}
-
+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);
-}
+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)));
-    }
+    function toInt(ChainId chainId) internal pure returns(uint256) { return uint256(uint40(ChainId.unwrap(chainId))); }
 }

package/contracts/types/NftId.sol

@@ -5,47 +5,31 @@ pragma solidity ^0.8.19;
 type NftId is uint96;
 
 // type bindings
-using {eqNftId as ==, neNftId as !=, NftIdLib.toInt} for NftId global;
+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));
-}
+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);
-}
+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);
-}
+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));
-    }
-
+    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;
-    }
-
+    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;
-    }
-
+    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);
-    }
+    function eq(NftId a, NftId b) public pure returns(bool isSame) { return eqNftId(a, b); }
 }

package/contracts/types/Timestamp.sol

@@ -13,90 +13,43 @@ using {
 } 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);
-}
-
+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);
-}
+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);
-}
-
+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);
-}
+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);
-}
-
+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 neTimestamp(Timestamp a, Timestamp b) pure returns (bool) {
-    return Timestamp.unwrap(a) != Timestamp.unwrap(b);
-}
+function neTimestamp(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 toTimestamp(uint256 timestamp) pure returns(Timestamp) { return Timestamp.wrap(uint40(timestamp));}
 
-function blockTimestamp() view returns (Timestamp) {
-    return toTimestamp(block.timestamp);
-}
+function blockTimestamp() view returns(Timestamp) { return toTimestamp(block.timestamp); }
 
 /// @dev Return the Timestamp zero (0)
-function zeroTimestamp() pure returns (Timestamp) {
-    return toTimestamp(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) public pure returns (bool isAfter) {
-        return gtTimestamp(a, b);
-    }
-
+    function gt(Timestamp a, Timestamp b) public 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
-    ) public pure returns (bool isAfterOrSame) {
-        return gteTimestamp(a, b);
-    }
+    function gte(Timestamp a, Timestamp b) public pure returns(bool isAfterOrSame) { return gteTimestamp(a, b); }
 
     /// @dev return true if Timestamp a is before Timestamp b
-    function lt(Timestamp a, Timestamp b) public pure returns (bool isBefore) {
-        return ltTimestamp(a, b);
-    }
-
+    function lt(Timestamp a, Timestamp b) public 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
-    ) public pure returns (bool isBeforeOrSame) {
-        return lteTimestamp(a, b);
-    }
+    function lte(Timestamp a, Timestamp b) public 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) public pure returns (bool isSame) {
-        return eqTimestamp(a, b);
-    }
-
+    function eq(Timestamp a, Timestamp b) public 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
-    ) public pure returns (bool isDifferent) {
-        return neTimestamp(a, b);
-    }
+    function ne(Timestamp a, Timestamp b) public pure returns(bool isDifferent) { return neTimestamp(a, b); }
 
-    function toInt(Timestamp timestamp) public pure returns (uint256) {
-        return uint256(uint40(Timestamp.unwrap(timestamp)));
-    }
+    function toInt(Timestamp timestamp) public pure returns(uint256) { return uint256(uint40(Timestamp.unwrap(timestamp))); }
 }