@etherisc/gif-next 0.0.2-ebbe63d → 0.0.2-f824182-503

package/contracts/instance/lifecycle/LifecycleModule.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {NftId} from "../../types/NftId.sol";
+import {ObjectType, PRODUCT, ORACLE, POOL, BUNDLE, POLICY} from "../../types/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, REVOKED, DECLINED} from "../../types/StateId.sol";
+import {ILifecycleModule} from "./ILifecycle.sol";
+
+contract LifecycleModule is ILifecycleModule {
+    mapping(ObjectType objectType => StateId initialState)
+        private _initialState;
+
+    mapping(ObjectType objectType => mapping(StateId stateFrom => mapping(StateId stateTo => bool isValid)))
+        private _isValidTransition;
+
+    constructor() {
+        _setupComponentLifecycle(PRODUCT());
+        _setupComponentLifecycle(ORACLE());
+        _setupComponentLifecycle(POOL());
+
+        _setupBundleLifecycle();
+        _setupPolicyLifecycle();
+    }
+
+    function checkAndLogTransition(
+        NftId nftId,
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) public returns (StateId) // add only currentcontract? would that work?
+    {
+        if (!_isValidTransition[objectType][fromId][toId]) {
+            revert ErrorInvalidStateTransition(nftId, objectType, fromId, toId);
+        }
+
+        if (objectType == POLICY()) {
+            emit LogPolicyStateChanged(nftId, fromId, toId);
+        } else if (objectType == BUNDLE()) {
+            emit LogBundleStateChanged(nftId, fromId, toId);
+        } else if (
+            objectType == PRODUCT() ||
+            objectType == ORACLE() ||
+            objectType == POOL()
+        ) {
+            emit LogComponentStateChanged(nftId, objectType, fromId, toId);
+        } else {
+            revert ErrorNoLifecycle(nftId, objectType);
+        }
+
+        return toId;
+    }
+
+    function getInitialState(
+        ObjectType objectType
+    ) public view returns (StateId) {
+        return _initialState[objectType];
+    }
+
+    function isValidTransition(
+        ObjectType objectType,
+        StateId fromId,
+        StateId toId
+    ) public view returns (bool) {
+        return _isValidTransition[objectType][fromId][toId];
+    }
+
+    function _setupComponentLifecycle(ObjectType objectType) internal {
+        _initialState[objectType] = ACTIVE();
+        _isValidTransition[objectType][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[objectType][PAUSED()][ACTIVE()] = true;
+        _isValidTransition[objectType][PAUSED()][ARCHIVED()] = true;
+    }
+
+    function _setupBundleLifecycle() internal {
+        _initialState[BUNDLE()] = ACTIVE();
+        _isValidTransition[BUNDLE()][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[BUNDLE()][PAUSED()][ACTIVE()] = true;
+        _isValidTransition[BUNDLE()][PAUSED()][CLOSED()] = true;
+    }
+
+    function _setupPolicyLifecycle() internal {
+        _initialState[POLICY()] = APPLIED();
+        _isValidTransition[POLICY()][APPLIED()][REVOKED()] = true;
+        _isValidTransition[POLICY()][APPLIED()][DECLINED()] = true;
+        _isValidTransition[POLICY()][APPLIED()][ACTIVE()] = true;
+        _isValidTransition[POLICY()][ACTIVE()][CLOSED()] = true;
+    }
+}

package/contracts/instance/policy/IPolicy.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+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";
+import {StateId} from "../../types/StateId.sol";
+
+// TODO check if there is value to introuce IContract and let IPolicy derive from IContract
+interface IPolicy {
+    struct PolicyInfo {
+        NftId nftId;
+        StateId state; // applied, withdrawn, rejected, active, closed
+        // TODO add beneficiary address
+        uint256 sumInsuredAmount;
+        uint256 premiumAmount;
+        uint256 premiumPaidAmount;
+        uint256 lifetime; // activatedAt + lifetime >= expiredAt
+        uint256 createdAt;
+        uint256 updatedAt;
+        uint256 activatedAt; // time of underwriting
+        uint256 expiredAt; // no new claims
+        uint256 closedAt; // no locked capital
+    }
+}
+
+interface IPolicyModule is IOwnable, IRegistryLinked, IPolicy {
+    function createApplication(
+        IRegistry.RegistryInfo memory productInfo,
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        NftId bundleNftId
+    ) external returns (NftId nftId);
+
+    // process full premium
+    function processPremium(NftId nftId) external;
+
+    function activate(NftId nftId) external;
+
+    function getBundleNftForPolicy(
+        NftId nftId
+    ) external view returns (NftId bundleNft);
+
+    function getPolicyInfo(
+        NftId nftId
+    ) external view returns (PolicyInfo memory info);
+}

package/contracts/instance/policy/PolicyModule.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
+import {IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+
+import {LifecycleModule} from "../lifecycle/LifecycleModule.sol";
+import {IProductService} from "../product/IProductService.sol";
+import {IPolicy, IPolicyModule} from "./IPolicy.sol";
+import {ObjectType, POLICY} from "../../types/ObjectType.sol";
+import {ACTIVE} from "../../types/StateId.sol";
+import {NftId, NftIdLib} from "../../types/NftId.sol";
+
+import {LifecycleModule} from "../lifecycle/LifecycleModule.sol";
+
+abstract contract PolicyModule is IRegistryLinked, IPolicyModule {
+    using NftIdLib for NftId;
+
+    mapping(NftId nftId => PolicyInfo info) private _policyInfo;
+    mapping(NftId nftId => NftId bundleNftId) private _bundleForPolicy;
+
+    LifecycleModule private _lifecycleModule;
+    IProductService private _productService;
+
+    // TODO find a better place to avoid dupliation
+    modifier onlyProductService2() {
+        require(
+            address(_productService) == msg.sender,
+            "ERROR:POL-001:NOT_PRODUCT_SERVICE"
+        );
+        _;
+    }
+
+    constructor(address productService) {
+        _lifecycleModule = LifecycleModule(address(this));
+        _productService = IProductService(productService);
+    }
+
+    function createApplication(
+        IRegistry.RegistryInfo memory productInfo,
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        NftId bundleNftId
+    ) external override onlyProductService2 returns (NftId nftId) {
+        // TODO add parameter validation
+        if (bundleNftId.gtz()) {
+            // IRegistry.RegistryInfo memory bundleInfo = this
+            //     .getRegistry()
+            //     .getInfo(bundleNftId);
+            // IRegistry.RegistryInfo memory poolInfo = this.getRegistry().getInfo(bundleInfo.parentNftId);
+        }
+
+        nftId = this.getRegistry().registerObjectForInstance(
+            productInfo.nftId,
+            POLICY(),
+            applicationOwner
+        );
+
+        _policyInfo[nftId] = PolicyInfo(
+            nftId,
+            _lifecycleModule.getInitialState(POLICY()),
+            sumInsuredAmount,
+            premiumAmount,
+            0, // premium paid amount
+            lifetime,
+            // solhint-disable-next-line not-rely-on-time
+            block.timestamp, // createdAt
+            // solhint-disable-next-line not-rely-on-time
+            block.timestamp, // updatedAt
+            0, // activatedAt
+            0, // expiredAt
+            0 // closedAt
+        );
+
+        _bundleForPolicy[nftId] = bundleNftId;
+
+        // add logging
+    }
+
+    function processPremium(NftId nftId) external override onlyProductService2 {
+        PolicyInfo storage info = _policyInfo[nftId];
+        info.premiumPaidAmount = info.premiumAmount;
+        // solhint-disable-next-line not-rely-on-time
+        info.updatedAt = block.timestamp;
+    }
+
+    function activate(NftId nftId) external override onlyProductService2 {
+        PolicyInfo storage info = _policyInfo[nftId];
+        // solhint-disable-next-line not-rely-on-time
+        info.activatedAt = block.timestamp;
+        // solhint-disable-next-line not-rely-on-time
+        info.expiredAt = block.timestamp + info.lifetime;
+        info.state = _lifecycleModule.checkAndLogTransition(
+            nftId,
+            POLICY(),
+            info.state,
+            ACTIVE()
+        );
+    }
+
+    function getBundleNftForPolicy(
+        NftId nftId
+    ) external view returns (NftId bundleNft) {
+        return _bundleForPolicy[nftId];
+    }
+
+    function getPolicyInfo(
+        NftId nftId
+    ) external view returns (PolicyInfo memory info) {
+        return _policyInfo[nftId];
+    }
+}

package/contracts/instance/pool/IPoolModule.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IOwnable, IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+import {NftId} from "../../types/NftId.sol";
+
+interface IPool {
+    struct PoolInfo {
+        NftId nftId;
+        uint256 capital;
+        uint256 lockedCapital;
+    }
+}
+
+interface IPoolModule is IOwnable, IRegistryLinked, IPool {
+    function underwrite(NftId policyNftId, NftId productNftId) external;
+
+    function registerPool(NftId nftId) external;
+
+    function getPoolInfo(
+        NftId nftId
+    ) external view returns (PoolInfo memory info);
+}

package/contracts/instance/pool/PoolModule.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IOwnable, IRegistry, IRegistryLinked} from "../../registry/IRegistry.sol";
+import {IProductService} from "../product/IProductService.sol";
+import {IPolicy, IPolicyModule} from "../policy/IPolicy.sol";
+import {ITreasuryModule} from "../treasury/ITreasury.sol";
+import {IPoolModule} from "./IPoolModule.sol";
+import {NftId, NftIdLib} from "../../types/NftId.sol";
+
+abstract contract PoolModule is IPoolModule {
+    using NftIdLib for NftId;
+
+    uint256 public constant INITIAL_CAPITAL = 10000 * 10 ** 6;
+    uint256 public constant INITIAL_LOCKED_CAPITAL = 0;
+
+    mapping(NftId nftId => PoolInfo info) private _poolInfo;
+
+    IPolicyModule private _policyModule;
+    ITreasuryModule private _treasuryModule;
+    IProductService private _productService;
+
+    modifier onlyProductService() {
+        require(
+            address(_productService) == msg.sender,
+            "ERROR:POL-001:NOT_PRODUCT_SERVICE"
+        );
+        _;
+    }
+
+    constructor(address productService) {
+        _policyModule = IPolicyModule(address(this));
+        _treasuryModule = ITreasuryModule(address(this));
+        _productService = IProductService(productService);
+    }
+
+    function registerPool(NftId nftId) public override {
+        require(_poolInfo[nftId].nftId.eqz(), "ERROR:PL-001:ALREADY_CREATED");
+
+        _poolInfo[nftId] = PoolInfo(
+            nftId,
+            INITIAL_CAPITAL,
+            INITIAL_LOCKED_CAPITAL
+        );
+    }
+
+    function underwrite(
+        NftId policyNftId,
+        NftId productNftId
+    ) external override onlyProductService {
+        IPolicy.PolicyInfo memory policyInfo = _policyModule.getPolicyInfo(
+            policyNftId
+        );
+        require(policyInfo.nftId == policyNftId, "ERROR:PL-002:POLICY_UNKNOWN");
+
+        ITreasuryModule.ProductSetup memory product = _treasuryModule
+            .getProductSetup(productNftId);
+        require(
+            product.productNftId == productNftId,
+            "ERROR:PL-003:PRODUCT_SETUP_MISSING"
+        );
+
+        NftId poolNftId = product.poolNftId;
+        PoolInfo storage poolInfo = _poolInfo[poolNftId];
+        require(poolInfo.nftId == poolNftId, "ERROR:PL-004:POOL_UNKNOWN");
+
+        require(
+            poolInfo.capital - poolInfo.lockedCapital >=
+                policyInfo.sumInsuredAmount,
+            "ERROR:PL-005:CAPACITY_TOO_LOW"
+        );
+
+        poolInfo.lockedCapital += policyInfo.sumInsuredAmount;
+    }
+
+    function getPoolInfo(
+        NftId nftId
+    ) external view override returns (PoolInfo memory info) {
+        info = _poolInfo[nftId];
+    }
+}

package/contracts/instance/product/IProductService.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IOwnable, IRegistryLinked, IRegisterable} from "../../registry/IRegistry.sol";
+import {IInstance} from "../IInstance.sol";
+import {NftId} from "../../types/NftId.sol";
+
+// TODO or name this IProtectionService to have Product be something more generic (loan, savings account, ...)
+interface IProductService is IRegistryLinked {
+    function createApplication(
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        NftId bundleNftId
+    ) external returns (NftId nftId);
+
+    // function revoke(unit256 nftId) external;
+
+    function underwrite(NftId nftId) external;
+
+    // function decline(uint256 nftId) external;
+    // function expire(uint256 nftId) external;
+    function close(NftId nftId) external;
+
+    function collectPremium(NftId nftId) external;
+
+    // function createClaim(uint256 nftId, uint256 claimAmount) external;
+    // function confirmClaim(uint256 nftId, uint256 claimId, uint256 claimAmount) external;
+    // function declineClaim(uint256 nftId, uint256 claimId) external;
+    // function closeClaim(uint256 nftId, uint256 claimId) external;
+}
+
+interface IProductModule is IOwnable, IRegistryLinked {
+    function getProductService() external view returns (IProductService);
+}

package/contracts/instance/product/ProductService.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// import {IProduct} from "../../components/IProduct.sol";
+// import {IOwnable, IRegistryLinked, IRegisterable, IRegistry} from "../../registry/IRegistry.sol";
+// import {IInstance} from "../IInstance.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {IPolicyModule} from "../policy/IPolicy.sol";
+import {RegistryLinked} from "../../registry/Registry.sol";
+import {IProductService, IProductModule} from "./IProductService.sol";
+import {ITreasuryModule} from "../../instance/treasury/ITreasury.sol";
+import {IPoolModule} from "../../instance/pool/IPoolModule.sol";
+import {ObjectType, INSTANCE, PRODUCT} from "../../types/ObjectType.sol";
+import {NftId, NftIdLib} from "../../types/NftId.sol";
+
+// TODO or name this ProtectionService to have Product be something more generic (loan, savings account, ...)
+contract ProductService is RegistryLinked, IProductService {
+    using NftIdLib for NftId;
+
+    constructor(
+        address registry
+    ) RegistryLinked(registry) // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
+
+    function createApplication(
+        address applicationOwner,
+        uint256 sumInsuredAmount,
+        uint256 premiumAmount,
+        uint256 lifetime,
+        NftId bundleNftId
+    ) external override returns (NftId nftId) {
+        // same as only registered product
+        NftId productNftId = _registry.getNftId(msg.sender);
+        require(productNftId.gtz(), "ERROR_PRODUCT_UNKNOWN");
+        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(
+            productNftId
+        );
+        require(productInfo.objectType == PRODUCT(), "ERROR_NOT_PRODUCT");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(
+            productInfo.parentNftId
+        );
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
+
+        IPolicyModule policyModule = IPolicyModule(instanceInfo.objectAddress);
+        nftId = policyModule.createApplication(
+            productInfo,
+            applicationOwner,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            bundleNftId
+        );
+
+        // add logging
+    }
+
+    function underwrite(NftId policyNftId) external override {
+        // validation
+        // same as only registered product
+        NftId productNftId = _registry.getNftId(msg.sender);
+        require(productNftId.gtz(), "ERROR_PRODUCT_UNKNOWN");
+        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(
+            productNftId
+        );
+        require(productInfo.objectType == PRODUCT(), "ERROR_NOT_PRODUCT");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(
+            productInfo.parentNftId
+        );
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
+
+        // underwrite policy
+        address instanceAddress = instanceInfo.objectAddress;
+        IPoolModule poolModule = IPoolModule(instanceAddress);
+        poolModule.underwrite(policyNftId, productNftId);
+
+        // activate policy
+        IPolicyModule policyModule = IPolicyModule(instanceAddress);
+        policyModule.activate(policyNftId);
+
+        // add logging
+    }
+
+    function collectPremium(NftId policyNftId) external override {
+        // validation same as other functions, eg underwrite
+        // TODO unify validation into modifier and/or other suitable approaches
+        // same as only registered product
+        NftId productNftId = _registry.getNftId(msg.sender);
+        require(productNftId.gtz(), "ERROR_PRODUCT_UNKNOWN");
+        IRegistry.RegistryInfo memory productInfo = _registry.getInfo(
+            productNftId
+        );
+        require(productInfo.objectType == PRODUCT(), "ERROR_NOT_PRODUCT");
+
+        IRegistry.RegistryInfo memory instanceInfo = _registry.getInfo(
+            productInfo.parentNftId
+        );
+        require(instanceInfo.nftId.gtz(), "ERROR_INSTANCE_UNKNOWN");
+        require(instanceInfo.objectType == INSTANCE(), "ERROR_NOT_INSTANCE");
+
+        // process/collect premium: book keeping for policy
+        address instanceAddress = instanceInfo.objectAddress;
+        IPolicyModule policyModule = IPolicyModule(instanceAddress);
+        policyModule.processPremium(policyNftId);
+
+        // process/collect premium: actual token transfer
+        ITreasuryModule treasuryModule = ITreasuryModule(instanceAddress);
+        treasuryModule.processPremium(policyNftId, productNftId);
+
+        // TODO add logging
+    }
+
+    function close(
+        NftId policyNftId
+    ) external override // solhint-disable-next-line no-empty-blocks
+    {
+
+    }
+}
+
+abstract contract ProductModule is IProductModule {
+    IProductService private _productService;
+
+    constructor(address productService) {
+        _productService = IProductService(productService);
+    }
+
+    function getProductService() external view returns (IProductService) {
+        return _productService;
+    }
+}

package/contracts/instance/treasury/ITreasury.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import {IRegistryLinked} from "../../registry/IRegistry.sol";
+
+import {NftId} from "../../types/NftId.sol";
+import {UFixed} from "../../types/UFixed.sol";
+import {Fee} from "../../types/Fee.sol";
+
+import {TokenHandler} from "./TokenHandler.sol";
+
+interface ITreasury {
+    // TODO add events
+    // TODO add errors
+}
+
+interface ITreasuryModule is IRegistryLinked, ITreasury {
+    struct ProductSetup {
+        NftId productNftId;
+        NftId distributorNftId;
+        NftId poolNftId;
+        IERC20 token;
+        TokenHandler tokenHandler;
+        address wallet;
+        Fee policyFee;
+        Fee processingFee;
+    }
+
+    struct DistributorSetup {
+        NftId distributorNftId;
+        address wallet;
+        Fee commissionFees;
+    }
+
+    struct PoolSetup {
+        NftId poolNftId;
+        address wallet;
+        Fee stakingFee;
+        Fee performanceFee;
+    }
+
+    function registerProduct(
+        NftId productNftId,
+        NftId distributorNftId,
+        NftId poolNftId,
+        IERC20 token,
+        address wallet,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) external;
+
+    function setProductFees(
+        NftId productNftId,
+        Fee memory policyFee,
+        Fee memory processingFee
+    ) external;
+
+    function registerPool(
+        NftId poolNftId,
+        address wallet,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) external;
+
+    function setPoolFees(
+        NftId poolNftId,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) external;
+
+    function processPremium(NftId policyNftId, NftId productNftId) external;
+
+    function getTokenHandler(
+        NftId productNftId
+    ) external view returns (TokenHandler tokenHandler);
+
+    function getProductSetup(
+        NftId productNftId
+    ) external view returns (ProductSetup memory setup);
+
+    function getPoolSetup(
+        NftId poolNftId
+    ) external view returns (PoolSetup memory setup);
+
+    function calculateFeeAmount(
+        uint256 amount,
+        Fee memory fee
+    ) external pure returns (uint256 feeAmount, uint256 netAmount);
+}

package/contracts/instance/treasury/TokenHandler.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract TokenHandler {
+    // TODO use oz safeTransferFrom
+
+    IERC20 _token;
+
+    constructor(address token) {
+        _token = IERC20(token);
+    }
+
+    // TODO add logging
+    function transfer(
+        address from,
+        address to,
+        uint256 amount
+    ) external // TODO add authz (only treasury)
+    {
+        _token.transferFrom(from, to, amount);
+    }
+}