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

package/contracts/components/IProduct.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IComponentContract} from "../instance/component/IComponent.sol";
+import {NftId} from "../types/NftId.sol";
+
+interface IProductComponent is
+    IComponentContract
+{
+
+    function getPoolNftId() external view returns(NftId poolNftId);
+}

package/contracts/components/Pool.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IPoolComponent} from "./IPool.sol";
+import {Component} from "./Component.sol";
+
+
+contract Pool is
+    Component,
+    IPoolComponent
+{
+
+    constructor(
+        address registry, 
+        address instance
+    )
+        Component(registry, instance)
+    { }
+
+    // from registerable
+    function getType() public view override returns(uint256) {
+        return _registry.POOL();
+    }
+
+    // from registerable
+    function getData() external view override returns(bytes memory data) {
+        return bytes(abi.encode(getInstance().getNftId()));
+    }
+}

package/contracts/components/Product.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IProductService} from "../instance/product/IProductService.sol";
+import {Component} from "./Component.sol";
+import {IProductComponent} from "./IProduct.sol";
+import {NftId} from "../types/NftId.sol";
+
+
+contract Product is
+    Component,
+    IProductComponent
+{
+    IProductService private _productService;
+    address private _pool;
+
+    constructor(
+        address registry, 
+        address instance, 
+        address pool
+    )
+        Component(registry, instance)
+    { 
+        _productService = _instance.getProductService();
+        _pool = pool;
+    }
+
+    function _createApplication(
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        NftId bundleNftId
+    )
+        internal
+        returns(NftId nftId)
+    {
+        nftId = _productService.createApplication(
+            applicationOwner,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            bundleNftId
+        );
+    }
+
+    function _underwrite(NftId nftId)
+        internal
+    {
+        _productService.underwrite(nftId);
+    }
+
+    function getPoolNftId() external view override returns(NftId poolNftId) {
+        return _registry.getNftId(_pool);
+    }
+
+    // from registerable
+    function getType() public view override returns(uint256) {
+        return _registry.PRODUCT();
+    }
+
+    // from registerable
+    function getData() external view override returns(bytes memory data) {
+        return bytes(abi.encode(getInstance().getNftId()));
+    }
+}

package/contracts/experiment/errors/Require.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+contract Require {
+
+    error AsmallerThanB_S();
+    error AsmallerThanB_M(uint a);
+    error AsmallerThanB_L(uint a, uint b);
+
+    uint256 private _b;
+
+    constructor() {
+        _b = 42;
+    }
+
+    function isAlargerThanBRequire_S(uint a) external view returns(bool isLarger) {
+        require(a > _b, "ERROR:ABC-001");
+
+        return true;
+    }
+
+    function isAlargerThanBRequire_M(uint a) external view returns(bool isLarger) {
+        require(a > _b, "ERROR:ABC-002:A_IS_SMALLER");
+
+        return true;
+    }
+
+    function isAlargerThanBRequire_L(uint a) external view returns(bool isLarger) {
+        require(a > _b, "ERROR:ABC-003:A_IS_SMALLER_THAN_B");
+
+        return true;
+    }
+}

package/contracts/experiment/errors/Revert.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+contract Revert {
+
+    error AsmallerThanB_S();
+    error AsmallerThanB_M(uint a);
+    error AsmallerThanB_L(uint a, uint b);
+
+    uint256 private _b;
+
+    constructor() {
+        _b = 42;
+    }
+
+    function isAlargerThanBRevert_S(uint a) external view returns(bool isLarger) {
+        if(a <= _b) {
+            revert AsmallerThanB_S();
+        }
+
+        return true;
+    }
+
+    function isAlargerThanBRevert_M(uint a) external view returns(bool isLarger) {
+        if(a <= _b) {
+            revert AsmallerThanB_M(a);
+        }
+
+        return true;
+    }
+
+    function isAlargerThanBRevert_L(uint a) external view returns(bool isLarger) {
+        if(a <= _b) {
+            revert AsmallerThanB_L(a, _b);
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegisterable} from "../registry/IRegistry.sol";
+import {IAccessModule} from "./access/IAccess.sol";
+import {IComponentModule} from "./component/IComponent.sol";
+import {IProductModule} from "./product/IProductService.sol";
+import {IPolicyModule} from "./policy/IPolicy.sol";
+import {IPoolModule} from "./pool/IPoolModule.sol";
+
+
+interface IInstance is
+    IRegisterable,
+    IAccessModule,
+    IPolicyModule,
+    IPoolModule,
+    IComponentModule,
+    IProductModule
+{ }
+

package/contracts/instance/Instance.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Registerable} from "../registry/Registry.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+
+import {IAccessModule, AccessModule} from "./access/Access.sol";
+import {ComponentModule} from "./component/ComponentModule.sol";
+import {ProductModule} from "./product/ProductService.sol";
+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,
+    AccessModule,
+    ComponentModule, 
+    PolicyModule, 
+    PoolModule,
+    ProductModule, 
+    IInstance
+{
+
+    constructor(
+        address registry,
+        address componentOwnerService,
+        address productService
+    )
+        Registerable(registry)
+        AccessModule()
+        ComponentModule(componentOwnerService)
+        PolicyModule(productService)
+        ProductModule(productService)
+        PoolModule(productService)
+    { }
+
+    // from registerable
+    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(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 toNftId(0);
+    }
+
+    // from registerable
+    function getType() external view override returns(uint256 objectType) {
+        return _registry.INSTANCE();
+    }
+
+    // from registerable
+    function getData() external view override returns(bytes memory data) {
+        return bytes(abi.encode(0));
+    }
+
+
+}