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

package/contracts/experiment/inheritance/A.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IA, ISharedA} from "./IA.sol";
+import {B} from "./B.sol";
+import {C} from "./C.sol";
+
+/* 
+
+# dependency graph
+
+   B <...+
+   ^     |
+   |     |
+   A --> C
+
+   - A is the main contract
+   - A provides functionality implemented by modules B and C
+   - B and C rely on functionality shared by A
+   - C accesses functionality of module B
+
+# chisel session
+
+import {A} from "./contracts/experiment/A.sol";
+A a = new A();
+uint(a.getA())
+uint(a.getB()))
+uint(a.getC())
+uint(a.getAfromB())
+uint(a.getAfromC())
+uint(a.getBfromC())
+a.setA(100);
+a.setB(10);
+a.setC(20);
+ */
+
+contract AShared is ISharedA {
+
+    uint256 private _x;
+
+    constructor() {
+        _x = 42;
+    }
+
+    function getA() external view override returns(uint256) { return _x; }
+    function setA(uint256 newA) external override { _x = newA; }
+}
+
+contract A is
+    AShared,
+    B,
+    C,
+    IA
+{
+
+}

package/contracts/experiment/inheritance/B.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ISharedA} from "./IA.sol";
+import {IB} from "./IB.sol";
+
+abstract contract B is ISharedA, IB {
+
+    // names of private variables can be re-used in inheritance
+    uint256 private _x;
+
+    constructor() {
+        _x = 1;
+    }
+
+    // access own state
+    function getB() external view override returns(uint256) { return _x; }
+    function setB(uint256 newB) external override { _x = newB; }
+
+    // access state from parent contract A
+    function getAfromB() external view override returns(uint256) { return this.getA(); }
+
+}

package/contracts/experiment/inheritance/C.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ISharedA} from "./IA.sol";
+import {IB} from "./IB.sol";
+import {IC} from "./IC.sol";
+
+abstract contract C is ISharedA, IC {
+
+    uint256 private _x;
+
+    constructor() {
+        _x = 2;
+    }
+
+    // access own state
+    function getC() external view override returns(uint256) { return _x; }
+    function setC(uint256 newC) external override { _x = newC; }
+
+    // access state from parent contract A
+    function getAfromC() external view override returns(uint256) { return this.getA(); }
+
+    // access state from other module B
+    function getBfromC() external view override returns(uint256) {
+        IB b = IB(address(this));
+        return b.getB();
+    }
+}

package/contracts/experiment/inheritance/IA.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IB} from "./IB.sol";
+import {IC} from "./IC.sol";
+
+interface ISharedA {
+
+    function getA() external view returns(uint256);
+    function setA(uint256 newA) external;
+}
+
+interface IA is
+    ISharedA,
+    IB,
+    IC
+{
+}

package/contracts/experiment/inheritance/IB.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+interface IB {
+
+    function getAfromB() external view returns(uint256);
+    function getB() external view returns(uint256);
+    function setB(uint256 newA) external;
+}

package/contracts/experiment/inheritance/IC.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+interface IC {
+
+    function getAfromC() external view returns(uint256);
+    function getBfromC() external view returns(uint256);
+
+    function getC() external view returns(uint256);
+    function setC(uint256 newA) external;
+}

package/contracts/experiment/types/TypeA.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+/*
+# chisel session for user defined types
+
+import {TypeA, toTypeA} from "./contracts/experiment/types/TypeA.sol";
+TypeA a = toTypeA(1);
+TypeA b = toTypeA(2);
+uint(a.toInt())
+uint(b.toInt())
+a == b
+a != b
+
+import {TypeB, toTypeB} from "./contracts/experiment/types/TypeB.sol";
+TypeB x = toTypeB(33);
+uint(x.toInt())
+a == x; // -> error
+a.toInt() == x.toInt() // -> no error
+ */
+
+// bytes5 allows for chain ids up to 13 digits
+type TypeA is uint248;
+
+// type bindings
+using {
+    eqTypeA as ==,
+    neTypeA as !=,
+    TypeALib.toInt
+} for TypeA global;
+
+// general pure free functions
+function toTypeA(uint256 typeA) pure returns(TypeA) { return TypeA.wrap(uint248(typeA)); }
+
+// pure free functions for operators
+function eqTypeA(TypeA a, TypeA b) pure returns(bool isSame) { return TypeA.unwrap(a) == TypeA.unwrap(b); }
+function neTypeA(TypeA a, TypeA b) pure returns(bool isDifferent) { return TypeA.unwrap(a) != TypeA.unwrap(b); }
+
+// library functions that operate on user defined type
+library TypeALib {
+    function toInt(TypeA typeA) internal pure returns(uint256) { return uint256(TypeA.unwrap(typeA)); }
+}

package/contracts/experiment/types/TypeB.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// bytes5 allows for chain ids up to 13 digits
+type TypeB is uint248;
+
+// type bindings
+using {
+    eqTypeB as ==,
+    addTypeB as +,
+    TypeBLib.toInt
+} for TypeB global;
+
+// general pure free functions
+function toTypeB(uint256 x) pure returns(TypeB) { return TypeB.wrap(uint248(x)); }
+
+// pure free functions for operators
+function eqTypeB(TypeB a, TypeB b) pure returns(bool isSame) { return TypeB.unwrap(a) == TypeB.unwrap(b); }
+function addTypeB(TypeB a, TypeB b) pure returns(TypeB sum) { return TypeB.wrap(TypeB.unwrap(a) + TypeB.unwrap(b)); }
+
+// library functions that operate on user defined type
+library TypeBLib {
+    function toInt(TypeB b) internal pure returns(uint256) { return uint256(TypeB.unwrap(b)); }
+}

package/contracts/instance/IInstance.sol

@@ -12,9 +12,9 @@ import {IPoolModule} from "./pool/IPoolModule.sol";
 interface IInstance is
     IRegisterable,
     IAccessModule,
-    IComponentModule,
-    IProductModule,
     IPolicyModule,
-    IPoolModule
+    IPoolModule,
+    IComponentModule,
+    IProductModule
 { }
 

package/contracts/instance/Instance.sol

@@ -11,6 +11,7 @@ import {PolicyModule} from "./policy/PolicyModule.sol";
 import {PoolModule} from "./pool/PoolModule.sol";
 
 import {IInstance} from "./IInstance.sol";
+import {NftId, toNftId} from "../types/NftId.sol";
 
 contract Instance is
     Registerable,
@@ -36,17 +37,17 @@ contract Instance is
     { }
 
     // from registerable
-    function register() external override returns(uint256 id) {
+    function register() external override returns(NftId nftId) {
         require(address(_registry) != address(0), "ERROR:PRD-001:REGISTRY_ZERO");
         return _registry.register(address(this));
     }
 
     // from registerable
-    function getParentNftId() public view override returns(uint256) {
+    function getParentNftId() public view override returns(NftId) {
         // TODO  add self registry and exchange 0 for_registry.getNftId();
         // define parent tree for all registerables
         // eg 0 <- chain(mainnet) <- global registry <- chain registry <- instance <- component <- policy/bundle 
-        return 0;
+        return toNftId(0);
     }
 
     // from registerable

package/contracts/instance/component/ComponentModule.sol

@@ -9,7 +9,7 @@ import {IInstance} from "../IInstance.sol";
 import {IComponent, IComponentContract, IComponentModule, IComponentOwnerService} from "./IComponent.sol";
 import {IProductComponent} from "../../components/IProduct.sol";
 import {IPoolModule} from "../pool/IPoolModule.sol";
-
+import {NftId, NftIdLib} from "../../types/NftId.sol";
 
 abstract contract ComponentModule is 
     IRegistryLinked,
@@ -17,11 +17,12 @@ abstract contract ComponentModule is
     IAccessCheckRole,
     IComponentModule
 {
+    using NftIdLib for NftId;
 
-    mapping(uint256 nftId => ComponentInfo info) private _componentInfo;
-    mapping(uint256 nftId => uint256 poolNftId) private _poolNftIdForProduct;
-    mapping(address cAddress => uint256 id) private _idByAddress;
-    uint256 [] private _ids;
+    mapping(NftId nftId => ComponentInfo info) private _componentInfo;
+    mapping(NftId nftId => NftId poolNftId) private _poolNftIdForProduct;
+    mapping(address cAddress => NftId nftId) private _nftIdByAddress;
+    NftId[] private _nftIds;
 
     mapping(uint256 cType => bytes32 role) private _componentOwnerRole;
 
@@ -40,7 +41,7 @@ abstract contract ComponentModule is
         external
         override
         onlyComponentOwnerService
-        returns(uint256 nftId)
+        returns(NftId nftId)
     {
         bytes32 typeRole = getRoleForType(component.getType());
         require(
@@ -56,8 +57,8 @@ abstract contract ComponentModule is
         // special case product -> persist product - pool assignment
         if(component.getType() == this.getRegistry().PRODUCT()) {
             IProductComponent product = IProductComponent(address(component));
-            uint256 poolNftId = product.getPoolNftId();
-            require(poolNftId > 0, "ERROR:CMP-005:POOL_UNKNOWN");
+            NftId poolNftId = product.getPoolNftId();
+            require(poolNftId.gtz(), "ERROR:CMP-005:POOL_UNKNOWN");
             // add more validation (type, token, ...)
 
             _poolNftIdForProduct[nftId] = poolNftId;
@@ -73,17 +74,17 @@ abstract contract ComponentModule is
             );
         }
 
-        _idByAddress[address(component)] = nftId;
-        _ids.push(nftId);
+        _nftIdByAddress[address(component)] = nftId;
+        _nftIds.push(nftId);
 
         // add logging
     }
 
-    function getPoolNftId(uint256 productNftId)
+    function getPoolNftId(NftId productNftId)
         external
         view
         override
-        returns(uint256 poolNftId)
+        returns(NftId poolNftId)
     {
         poolNftId = _poolNftIdForProduct[productNftId];
     }
@@ -101,28 +102,28 @@ abstract contract ComponentModule is
     function setComponentInfo(ComponentInfo memory info)
         external
         onlyComponentOwnerService
-        returns(uint256 nftId)
+        returns(NftId nftId)
     {
-        uint256 id = info.nftId;
+        nftId = info.nftId;
         require(
-            id > 0 && _componentInfo[id].nftId == id,
-            "ERROR:CMP-005:COMPONENT_UNKNOWN");
+            nftId.gtz() && _componentInfo[nftId].nftId.eq(nftId),
+            "ERROR:CMP-006:COMPONENT_UNKNOWN");
 
-        _componentInfo[id] = info;
+        _componentInfo[nftId] = info;
 
         // add logging
     }
 
-    function getComponentInfo(uint256 id)
+    function getComponentInfo(NftId nftId)
         external
         override
         view
         returns(ComponentInfo memory)
     {
-        return _componentInfo[id];
+        return _componentInfo[nftId];
     }
 
-    function getComponentOwner(uint256 id)
+    function getComponentOwner(NftId nftId)
         external
         view
         returns(address owner)
@@ -133,9 +134,9 @@ abstract contract ComponentModule is
     function getComponentId(address componentAddress)
         external
         view
-        returns(uint256 id)
+        returns(NftId componentNftId)
     {
-        return _idByAddress[componentAddress];
+        return _nftIdByAddress[componentAddress];
     }
 
 
@@ -143,9 +144,9 @@ abstract contract ComponentModule is
         external
         override
         view
-        returns(uint256 id)
+        returns(NftId componentNftId)
     {
-        return _ids[idx];
+        return _nftIds[idx];
     }
 
 
@@ -155,7 +156,7 @@ abstract contract ComponentModule is
         view
         returns(uint256 numberOfCompnents)
     {
-        return _ids.length;
+        return _nftIds.length;
     }
 
     function getRoleForType(uint256 cType)
@@ -183,11 +184,12 @@ contract ComponentOwnerService is
     IComponent,
     IComponentOwnerService
 {
+    using NftIdLib for NftId;
 
     modifier onlyComponentOwner(IComponentContract component) {
-        uint256 nftId = _registry.getNftId(address(component));
+        NftId nftId = _registry.getNftId(address(component));
         require(
-            nftId > 0, 
+            nftId.gtz(), 
             "ERROR:COS-001:COMPONENT_UNKNOWN");
         require(
             msg.sender == _registry.getOwner(nftId),
@@ -200,23 +202,10 @@ contract ComponentOwnerService is
         RegistryLinked(registry)
     { }
 
-
-    // modifier onlyComponentOwnerRole(IComponentContract component) {
-    //     IInstance instance = component.getInstance();
-    //     // TODO add set/getComponentOwnerRole to IComonentModule
-    //     bytes32 typeRole = instance.getComponentTypeRole(component.getType());
-    //     require(
-    //         instance.hasRole(typeRole, msg.sender),
-    //         "ERROR:COS-003:COMPONENT_ROLE_MISSING"
-    //     );
-    //     _;
-    // }
-
-
     function register(IComponentContract component)
         external
         override
-        returns(uint256 nftId)
+        returns(NftId nftId)
     {
         require(
             msg.sender == component.getInitialOwner(), 
@@ -234,7 +223,7 @@ contract ComponentOwnerService is
     {
         IInstance instance = component.getInstance();
         ComponentInfo memory info = instance.getComponentInfo(component.getNftId());
-        require(info.nftId > 0, "ERROR_COMPONENT_UNKNOWN");
+        require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
         // TODO add state change validation
 
         info.state = CState.Locked;
@@ -249,7 +238,7 @@ contract ComponentOwnerService is
     {
         IInstance instance = component.getInstance();
         ComponentInfo memory info = instance.getComponentInfo(component.getNftId());
-        require(info.nftId > 0, "ERROR_COMPONENT_UNKNOWN");
+        require(info.nftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
         // TODO state change validation
 
         info.state = CState.Active;

package/contracts/instance/component/IComponent.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";
 
 interface IComponent {
 
@@ -16,7 +17,7 @@ interface IComponent {
 
     // component dynamic info (static info kept in registry)
     struct ComponentInfo {
-        uint256 nftId;
+        NftId nftId;
         CState state;
     }
 }
@@ -37,7 +38,7 @@ interface IComponentContract is
 
 interface IComponentOwnerService is IRegistryLinked{
 
-    function register(IComponentContract component) external returns(uint256 id);
+    function register(IComponentContract component) external returns(NftId nftId);
     function lock(IComponentContract component) external;
     function unlock(IComponentContract component) external;
 }
@@ -51,18 +52,18 @@ interface IComponentModule is
 
     function registerComponent(IComponentContract component)
         external
-        returns(uint256 nftInfo);
+        returns(NftId nftId);
 
     function setComponentInfo(ComponentInfo memory info)
         external
-        returns(uint256 componentId);
+        returns(NftId componentNftId);
 
-    function getComponentInfo(uint256 id)
+    function getComponentInfo(NftId nftId)
         external
         view
         returns(ComponentInfo memory info);
 
-    function getComponentOwner(uint256 id)
+    function getComponentOwner(NftId nftId)
         external
         view
         returns(address owner);
@@ -70,17 +71,17 @@ interface IComponentModule is
     function getComponentId(address componentAddress)
         external
         view
-        returns(uint256 id);
+        returns(NftId nftId);
 
     function getComponentId(uint256 idx)
         external
         view
-        returns(uint256 id);
+        returns(NftId nftId);
 
-    function getPoolNftId(uint256 productNftId)
+    function getPoolNftId(NftId productNftId)
         external
         view
-        returns(uint256 poolNftId);
+        returns(NftId poolNftId);
 
     function components()
         external

package/contracts/instance/policy/IPolicy.sol

@@ -4,8 +4,8 @@ pragma solidity ^0.8.19;
 
 import {IOwnable, IRegistryLinked, IRegisterable, IRegistry} from "../../registry/IRegistry.sol";
 import {IInstance} from "../IInstance.sol";
-
 import {IProductService} from "../product/IProductService.sol";
+import {NftId} from "../../types/NftId.sol";
 
 // TODO check if there is value to introuce IContract and let IPolicy derive from IContract
 interface IPolicy {
@@ -19,7 +19,7 @@ interface IPolicy {
     }
 
     struct PolicyInfo {
-        uint256 nftId;
+        NftId nftId;
         PolicyState state; // applied, withdrawn, rejected, active, closed
 
         uint256 sumInsuredAmount;
@@ -45,20 +45,20 @@ interface IPolicyModule is
         uint256 sumInsuredAmount,
         uint256 premiumAmount,
         uint256 lifetime,
-        uint256 bundleNftId
+        NftId bundleNftId
     )
         external
-        returns(uint256 nftId);
+        returns(NftId nftId);
 
-    function activate(uint256 nftId)
+    function activate(NftId nftId)
         external;
 
-    function getBundleNftForPolicy(uint256 nftId)
+    function getBundleNftForPolicy(NftId nftId)
         external
         view
-        returns(uint256 bundleNft);
+        returns(NftId bundleNft);
 
-    function getPolicyInfo(uint256 nftId)
+    function getPolicyInfo(NftId nftId)
         external
         view
         returns(PolicyInfo memory info);

package/contracts/instance/policy/PolicyModule.sol

@@ -7,15 +7,16 @@ import {IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
 
 import {IProductService} from "../product/IProductService.sol";
 import {IPolicy, IPolicyModule} from "./IPolicy.sol";
-
+import {NftId, NftIdLib} from "../../types/NftId.sol";
 
 abstract contract PolicyModule is
     IRegistryLinked,
     IPolicyModule
 {
+    using NftIdLib for NftId;
 
-    mapping(uint256 nftId => PolicyInfo info) private _policyInfo;
-    mapping(uint256 nftId => uint256 bundleNftId) private _bundleForPolicy;
+    mapping(NftId nftId => PolicyInfo info) private _policyInfo;
+    mapping(NftId nftId => NftId bundleNftId) private _bundleForPolicy;
 
     IProductService private _productService;
 
@@ -36,17 +37,17 @@ abstract contract PolicyModule is
         uint256 sumInsuredAmount,
         uint256 premiumAmount,
         uint256 lifetime,
-        uint256 bundleNftId
+        NftId bundleNftId
     )
         external
         override
         onlyProductService2
-        returns(uint256 nftId)
+        returns(NftId nftId)
     {
         // TODO add parameter validation
-        if(bundleNftId > 0) {
+        if(bundleNftId.gtz()) {
             IRegistry.RegistryInfo memory bundleInfo = this.getRegistry().getInfo(bundleNftId);
-            IRegistry.RegistryInfo memory poolInfo = this.getRegistry().getInfo(bundleInfo.parentNftId);
+            // IRegistry.RegistryInfo memory poolInfo = this.getRegistry().getInfo(bundleInfo.parentNftId);
         }
 
         nftId = this.getRegistry().registerObjectForInstance(
@@ -72,7 +73,7 @@ abstract contract PolicyModule is
     }
 
 
-    function activate(uint256 nftId)
+    function activate(NftId nftId)
         external
         override
         onlyProductService2
@@ -87,16 +88,16 @@ abstract contract PolicyModule is
 
 
 
-    function getBundleNftForPolicy(uint256 nftId)
+    function getBundleNftForPolicy(NftId nftId)
         external
         view
-        returns(uint256 bundleNft)
+        returns(NftId bundleNft)
     {
         return _bundleForPolicy[nftId];
     }
 
 
-    function getPolicyInfo(uint256 nftId)
+    function getPolicyInfo(NftId nftId)
         external
         view
         returns(PolicyInfo memory info)

package/contracts/instance/pool/IPoolModule.sol

@@ -2,11 +2,12 @@
 pragma solidity ^0.8.19;
 
 import {IOwnable, IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+import {NftId} from "../../types/NftId.sol";
 
 interface IPool {
 
     struct PoolInfo {
-        uint256 nftId;
+        NftId nftId;
         address wallet;
         address token;
         uint256 capital;
@@ -21,19 +22,19 @@ interface IPoolModule is
 {
     
     function underwrite(
-        uint256 poolNftId,
-        uint256 policyNftId
+        NftId poolNftId,
+        NftId policyNftId
     )
         external;
 
     function createPoolInfo(
-        uint256 nftId,
+        NftId nftId,
         address wallet,
         address token
     )
         external;
 
-    function getPoolInfo(uint256 nftId)
+    function getPoolInfo(NftId nftId)
         external
         view
         returns(PoolInfo memory info);