@etherisc/gif-next 0.0.2-d250c72 → 0.0.2-d3543ee-345

package/contracts/components/Pool.sol

@@ -1,29 +1,52 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
+import {ObjectType, POOL} from "../types/ObjectType.sol";
+import {Fee} from "../types/Fee.sol";
 import {IPoolComponent} from "./IPool.sol";
 import {Component} from "./Component.sol";
 
-
-contract Pool is
-    Component,
-    IPoolComponent
-{
+contract Pool is Component, IPoolComponent {
+    Fee private _stakingFee;
+    Fee private _performanceFee;
 
     constructor(
-        address registry, 
-        address instance
-    )
-        Component(registry, instance)
-    { }
+        address registry,
+        address instance,
+        address token,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) Component(registry, instance, token) {
+        _stakingFee = stakingFee;
+        _performanceFee = performanceFee;
+    }
+
+    // from pool component
+    function getStakingFee()
+        external
+        view
+        override
+        returns (Fee memory stakingFee)
+    {
+        return _stakingFee;
+    }
+
+    function getPerformanceFee()
+        external
+        view
+        override
+        returns (Fee memory performanceFee)
+    {
+        return _performanceFee;
+    }
 
     // from registerable
-    function getType() public view override returns(uint256) {
-        return _registry.POOL();
+    function getType() public pure override returns (ObjectType) {
+        return POOL();
     }
 
     // from registerable
-    function getData() external view override returns(bytes memory data) {
+    function getData() external view override returns (bytes memory data) {
         return bytes(abi.encode(getInstance().getNftId()));
     }
-}
+}

package/contracts/components/Product.sol

@@ -5,24 +5,29 @@ import {IProductService} from "../instance/product/IProductService.sol";
 import {Component} from "./Component.sol";
 import {IProductComponent} from "./IProduct.sol";
 import {NftId} from "../types/NftId.sol";
+import {ObjectType, PRODUCT} from "../types/ObjectType.sol";
+import {Fee} from "../types/Fee.sol";
+import {Component} from "./Component.sol";
 
-
-contract Product is
-    Component,
-    IProductComponent
-{
+contract Product is Component, IProductComponent {
     IProductService private _productService;
     address private _pool;
+    Fee private _policyFee;
+    Fee private _processingFee;
 
     constructor(
-        address registry, 
-        address instance, 
-        address pool
-    )
-        Component(registry, instance)
-    { 
+        address registry,
+        address instance,
+        address token,
+        address pool,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) Component(registry, instance, token) {
+        // TODO add validation
         _productService = _instance.getProductService();
         _pool = pool;
+        _policyFee = policyFee;
+        _processingFee = processingFee;
     }
 
     function _createApplication(
@@ -31,10 +36,7 @@ contract Product is
         uint256 premiumAmount,
         uint256 lifetime,
         NftId bundleNftId
-    )
-        internal
-        returns(NftId nftId)
-    {
+    ) internal returns (NftId nftId) {
         nftId = _productService.createApplication(
             applicationOwner,
             sumInsuredAmount,
@@ -44,23 +46,44 @@ contract Product is
         );
     }
 
-    function _underwrite(NftId nftId)
-        internal
-    {
+    function _underwrite(NftId nftId) internal {
         _productService.underwrite(nftId);
     }
 
-    function getPoolNftId() external view override returns(NftId poolNftId) {
+    function _collectPremium(NftId nftId) internal {
+        _productService.collectPremium(nftId);
+    }
+
+    function getPoolNftId() external view override returns (NftId poolNftId) {
         return _registry.getNftId(_pool);
     }
 
+    // from product component
+    function getPolicyFee()
+        external
+        view
+        override
+        returns (Fee memory policyFee)
+    {
+        return _policyFee;
+    }
+
+    function getProcessingFee()
+        external
+        view
+        override
+        returns (Fee memory processingFee)
+    {
+        return _processingFee;
+    }
+
     // from registerable
-    function getType() public view override returns(uint256) {
-        return _registry.PRODUCT();
+    function getType() public pure override returns (ObjectType) {
+        return PRODUCT();
     }
 
     // from registerable
-    function getData() external view override returns(bytes memory data) {
+    function getData() external view override returns (bytes memory data) {
         return bytes(abi.encode(getInstance().getNftId()));
     }
-}
+}

package/contracts/experiment/errors/Require.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.19;
 
 contract Require {
-
     error AsmallerThanB_S();
     error AsmallerThanB_M(uint a);
     error AsmallerThanB_L(uint a, uint b);
@@ -13,21 +12,27 @@ contract Require {
         _b = 42;
     }
 
-    function isAlargerThanBRequire_S(uint a) external view returns(bool isLarger) {
+    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) {
+    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) {
+    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

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.19;
 
 contract Revert {
-
     error AsmallerThanB_S();
     error AsmallerThanB_M(uint a);
     error AsmallerThanB_L(uint a, uint b);
@@ -13,27 +12,33 @@ contract Revert {
         _b = 42;
     }
 
-    function isAlargerThanBRevert_S(uint a) external view returns(bool isLarger) {
-        if(a <= _b) {
+    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) {
+    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) {
+    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

@@ -35,22 +35,19 @@ 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
-{
+    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

@@ -5,7 +5,6 @@ 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;
 
@@ -14,10 +13,16 @@ abstract contract B is ISharedA, IB {
     }
 
     // access own state
-    function getB() external view override returns(uint256) { return _x; }
-    function setB(uint256 newB) external override { _x = newB; }
+    function getB() external view override returns (uint256) {
+        return _x;
+    }
 
-    // access state from parent contract A
-    function getAfromB() external view override returns(uint256) { return this.getA(); }
+    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

@@ -6,7 +6,6 @@ import {IB} from "./IB.sol";
 import {IC} from "./IC.sol";
 
 abstract contract C is ISharedA, IC {
-
     uint256 private _x;
 
     constructor() {
@@ -14,14 +13,21 @@ abstract contract C is ISharedA, IC {
     }
 
     // access own state
-    function getC() external view override returns(uint256) { return _x; }
-    function setC(uint256 newC) external override { _x = newC; }
+    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(); }
+    function getAfromC() external view override returns (uint256) {
+        return this.getA();
+    }
 
     // access state from other module B
-    function getBfromC() external view override returns(uint256) {
+    function getBfromC() external view override returns (uint256) {
         IB b = IB(address(this));
         return b.getB();
     }

package/contracts/experiment/inheritance/IA.sol

@@ -5,14 +5,9 @@ import {IB} from "./IB.sol";
 import {IC} from "./IC.sol";
 
 interface ISharedA {
+    function getA() external view returns (uint256);
 
-    function getA() external view returns(uint256);
     function setA(uint256 newA) external;
 }
 
-interface IA is
-    ISharedA,
-    IB,
-    IC
-{
-}
+interface IA is ISharedA, IB, IC {}

package/contracts/experiment/inheritance/IB.sol

@@ -2,8 +2,9 @@
 pragma solidity ^0.8.19;
 
 interface IB {
+    function getAfromB() external view returns (uint256);
+
+    function getB() external view returns (uint256);
 
-    function getAfromB() external view returns(uint256);
-    function getB() external view returns(uint256);
     function setB(uint256 newA) external;
 }

package/contracts/experiment/inheritance/IC.sol

@@ -2,10 +2,11 @@
 pragma solidity ^0.8.19;
 
 interface IC {
+    function getAfromC() external view returns (uint256);
 
-    function getAfromC() external view returns(uint256);
-    function getBfromC() external view returns(uint256);
+    function getBfromC() external view returns (uint256);
+
+    function getC() external view returns (uint256);
 
-    function getC() external view returns(uint256);
     function setC(uint256 newA) external;
 }

package/contracts/experiment/statemachine/Dummy.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {ObjectType} from "../../types/ObjectType.sol";
+import {StateId, toStateId, zeroStateId} from "../../types/StateId.sol";
+
+contract LifeCycleModule {
+    mapping(ObjectType objectType => StateId initialState)
+        private _initialState;
+
+    mapping(ObjectType objectType => mapping(StateId stateFrom => mapping(StateId stateTo => bool isValid)))
+        private _isValidTransition;
+
+    function getInitialState(
+        ObjectType objectType
+    ) external view returns (StateId) {
+        return _initialState[objectType];
+    }
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) external view returns (bool) {
+        return _isValidTransition[objectType][fromId][toId];
+    }
+}

package/contracts/experiment/statemachine/ISM.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {StateId} from "../../types/StateId.sol";
+
+interface ISMEE {
+    error ErrorInitialStateUndefined();
+    error ErrorStartStateUndefined();
+    error ErrorNextStateUndefined();
+    error ErrorStateChangeInvalid(StateId currentStateId, StateId newStateId);
+
+    event LogInitialStateSet(StateId initialStateId);
+    event LogStateChanged(StateId oldStateId, StateId newStateId);
+}
+
+interface ISM is ISMEE {
+    function changeToState(StateId newStateId) external;
+
+    function isValidTransition(
+        StateId currentStateId,
+        StateId newStateId
+    ) external view returns (bool isValid);
+
+    function getState() external view returns (StateId currentStateId);
+}

package/contracts/experiment/statemachine/README.md

@@ -0,0 +1,112 @@
+# State Machines
+
+Most GIF objects have a life cycle defined by a state machine.
+
+For each object type the set of possible states is defined together with its initial state and the set of valid state transitions.
+
+## Object Types without States
+
+* Protocol
+* Chains
+* Registries (both chain and main registry)
+
+## Object Types with States
+
+* Tokens
+* Instances
+* Products
+* Oracles
+* Pools
+* Bundles
+* Policies
+* Claim (non-NFT)
+* Payout (non-NFT)
+
+### Simple State Machine
+
+Valid states
+
+* Active (initial state)
+* Paused
+* Archived (final state)
+
+Valid state transitions:
+
+* Active -> Paused
+* Paused -> Active
+* Paused -> Archived
+
+
+Candidate object types for simple state machine
+
+* Token
+* Instance
+* Product
+* Oracle
+* Pool
+
+To discuss: 
+
+* Archived is final state
+* What mechanism should exist to revert an unintended transition to 'Archived' state. Should there be such a mechanism?
+* What mechanism should exist when the NFT of such an object is burned prematurely. Should there be such a mechanism
+
+### Bundle State Machine
+
+Valid states
+
+* Active (initial state)
+* Paused
+* Expired (implicit state)
+* Closed (final state)
+
+Expired is not an explicit state. 
+A bundle is expired for block.timestamp >= expiredAt
+
+### Policy State Machine
+
+Valid states
+
+* Applied (initial state)
+* Revoked (final state)
+* Declined (final state)
+* Active
+* Expired (implicit state)
+* Closed (final state)
+
+Expired is not an explicit state. 
+A policy is expired for block.timestamp >= expiredAt
+
+To discuss: 
+
+* Should 'Closed' be less explicit using a closedAt state variable? 
+* Or even more lighweight? ie. block.timestamp >= expiredAt and no open claims
+
+Valid state transitions:
+
+* Applied -> Revoked
+* Applied -> Declined
+* Applied -> Active
+* Active -> Closed (needs to be expired)
+
+### Claim State Machine
+
+Valid states
+* Applied (initial state)
+* Confirmed
+* Declined (final state)
+* Closed (final state)
+
+Valid state transitions:
+* Applied -> Confirmed
+* Applied -> Declined
+* Confirmed -> Closed
+
+### Payout State Machine
+
+Valid states
+* Expected
+* PaidOut
+
+Valid state transitions:
+* Expected -> PaidOut

package/contracts/experiment/statemachine/SM.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {StateId, toStateId, zeroStateId} from "../../types/StateId.sol";
+import {ISM} from "./ISM.sol";
+
+contract SM is ISM {
+    mapping(StateId currentState => mapping(StateId newState => bool isValid))
+        private _isValidTransition;
+
+    StateId internal _state;
+
+    function setInitialState(StateId initialStateId) internal {
+        if (initialStateId == zeroStateId()) {
+            revert ErrorInitialStateUndefined();
+        }
+
+        _state = initialStateId;
+    }
+
+    function addTransition(
+        StateId currentStateId,
+        StateId nextStateId
+    ) internal {
+        if (currentStateId == zeroStateId()) {
+            revert ErrorStartStateUndefined();
+        }
+
+        if (nextStateId == zeroStateId()) {
+            revert ErrorNextStateUndefined();
+        }
+
+        _isValidTransition[currentStateId][nextStateId] = true;
+    }
+
+    function changeToState(StateId newStateId) external override {
+        if (!_isValidTransition[_state][newStateId]) {
+            revert ErrorStateChangeInvalid(_state, newStateId);
+        }
+
+        StateId stateOld = _state;
+        _state = newStateId;
+
+        emit LogStateChanged(stateOld, _state);
+    }
+
+    function isValidTransition(
+        StateId currentStateId,
+        StateId newStateId
+    ) external view override returns (bool isValid) {
+        return _isValidTransition[currentStateId][newStateId];
+    }
+
+    function getState() external view override returns (StateId state) {
+        return _state;
+    }
+}

package/contracts/experiment/statemachine/SimpleStateMachine.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {StateId, toStateId} from "../../types/StateId.sol";
+import {SM} from "./SM.sol";
+
+contract SimpleStateMachine is SM {
+    uint8 public constant STATE_ACTIVE = 10;
+    uint8 public constant STATE_PAUSED = 20;
+    uint8 public constant STATE_ARCHIVED = 30;
+
+    constructor() {
+        addTransition(ACTIVE(), PAUSED());
+        addTransition(PAUSED(), ACTIVE());
+        addTransition(PAUSED(), ARCHIVED());
+
+        setInitialState(ACTIVE());
+    }
+
+    function ACTIVE() public pure returns (StateId stateId) {
+        return toStateId(STATE_ACTIVE);
+    }
+
+    function PAUSED() public pure returns (StateId stateId) {
+        return toStateId(STATE_PAUSED);
+    }
+
+    function ARCHIVED() public pure returns (StateId stateId) {
+        return toStateId(STATE_ARCHIVED);
+    }
+}

package/contracts/experiment/types/TypeA.sol

@@ -23,20 +23,25 @@ a.toInt() == x.toInt() // -> no error
 type TypeA is uint248;
 
 // type bindings
-using {
-    eqTypeA as ==,
-    neTypeA as !=,
-    TypeALib.toInt
-} for TypeA global;
+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)); }
+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); }
+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)); }
+    function toInt(TypeA typeA) internal pure returns (uint256) {
+        return uint256(TypeA.unwrap(typeA));
+    }
 }