@etherisc/gif-next 0.0.2-b9366f5-670 → 0.0.2-b95860d-028

package/contracts/examples/fire/FireProduct.sol

@@ -0,0 +1,412 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ACTIVE, PAUSED} from "../../type/StateId.sol";
+import {Amount, AmountLib} from "../../type/Amount.sol";
+import {BasicProduct} from "../../product/BasicProduct.sol";
+import {ClaimId} from "../../type/ClaimId.sol";
+import {DamageLevel, DAMAGE_SMALL, DAMAGE_MEDIUM, DAMAGE_LARGE} from "./DamageLevel.sol";
+import {IAuthorization} from "../../authorization/IAuthorization.sol";
+import {IPolicy} from "../../instance/module/IPolicy.sol";
+import {NftId} from "../../type/NftId.sol";
+import {PayoutId} from "../../type/PayoutId.sol";
+import {POLICY} from "../../type/ObjectType.sol";
+import {ReferralLib} from "../../type/Referral.sol";
+import {RiskId, RiskIdLib} from "../../type/RiskId.sol";
+import {Seconds} from "../../type/Seconds.sol";
+import {Timestamp, TimestampLib} from "../../type/Timestamp.sol";
+import {UFixed, UFixedLib} from "../../type/UFixed.sol";
+
+// solhint-disable-next-line func-name-mixedcase
+function HALF_YEAR() pure returns (Seconds) {
+    return Seconds.wrap(180 * 86400);
+}
+
+// solhint-disable-next-line func-name-mixedcase
+function ONE_YEAR() pure returns (Seconds) {
+    return Seconds.wrap(360 * 86400);
+}
+
+/// @dev This is the product component for the fire insurance example. 
+/// It show how to insure a house for a given suminsured in a city. 
+/// The risk is based on the city. 
+/// If a fire is reported in the city, the policy holder is able to submit a claim and get a payout. 
+contract FireProduct is 
+    BasicProduct
+{
+    struct Fire {
+        string cityName;
+        DamageLevel damageLevel;
+        Timestamp reportedAt;
+    }
+
+    error ErrorFireProductCityUnknown(string cityName);
+    error ErrorFireProductTimestampInFuture();
+    error ErrorFireProductFireAlreadyReported();
+    error ErrorFireProductAlreadyClaimed();
+    error ErrorFireProductPolicyNotActive(NftId policyNftId);
+    error ErrorFireProductPolicyNotYetActive(NftId policyNftId, Timestamp activateAt);
+    error ErrorFireProductPolicyExpired(NftId policyNftId, Timestamp expiredAt);
+    error ErrorFireProductUnknownDamageLevel(DamageLevel damageLevel);
+    error ErrorFireProductFireUnknown(uint256 fireId);
+    error ErrorFireProductNotPolicyOwner(NftId nftId, address owner);
+    error ErrorFireProductFireNotInCoveredCity(uint256 fireId, string cityName);
+
+    string[] private _cities;
+    // map from city name to the RiskId
+    mapping(string cityName => RiskId risk) private _riskMapping;
+
+    // map from city name to the damage level and the time of the report
+    mapping(uint256 fireId => Fire) private _fires;
+    mapping(uint256 fireId => mapping (NftId policyId => bool claimed)) private _claimed;
+
+    constructor(
+        address registry,
+        NftId instanceNftid,
+        string memory componentName,
+        address token,
+        address pool,
+        IAuthorization authorization
+    )
+    {
+        address initialOwner = msg.sender;
+
+        _initialize(
+            registry,
+            instanceNftid,
+            componentName,
+            token,
+            pool,
+            authorization,
+            initialOwner);
+    }
+
+    function _initialize(
+        address registry,
+        NftId instanceNftid,
+        string memory componentName,
+        address token,
+        address pool,
+        IAuthorization authorization,
+        address initialOwner
+    )
+        internal
+        initializer
+    {
+        _initializeBasicProduct(
+            registry,
+            instanceNftid,
+            authorization,
+            initialOwner,
+            componentName,
+            token,
+            false, // is interceptor
+            false, // has distribution
+            0);  // number of oracles
+    }
+    
+    function cities() public view returns (uint256) {
+        return _cities.length;
+    }
+
+    function city(uint256 idx) public view returns (string memory) {
+        return _cities[idx];
+    }
+
+    function riskId(string memory cityName) public view returns (RiskId) {
+        return _riskMapping[cityName];
+    }
+
+    function pauseCity(
+        string memory cityName
+    ) 
+        public 
+        restricted()
+    {
+        if (_riskMapping[cityName].eqz()) {
+            revert ErrorFireProductCityUnknown(cityName);
+        }
+
+        _updateRiskState(
+            _riskMapping[cityName],
+            PAUSED()
+        );
+    }
+
+    function unpauseCity(
+        string memory cityName
+    ) 
+        public 
+        restricted()
+    {
+        if (_riskMapping[cityName].eqz()) {
+            revert ErrorFireProductCityUnknown(cityName);
+        }
+
+        _updateRiskState(
+            _riskMapping[cityName],
+            ACTIVE()
+        );
+    }
+
+    function calculatePremium(
+        string memory cityName,
+        Amount sumInsured,
+        Seconds lifetime,
+        NftId bundleNftId
+    ) 
+        public
+        view
+        returns (Amount premiumAmount)
+    {
+        RiskId risk = _riskMapping[cityName];
+        if (risk.eqz()) {
+            revert ErrorFireProductCityUnknown(cityName);
+        }
+        premiumAmount = calculatePremium( 
+            sumInsured,
+            risk,
+            lifetime,
+            "",
+            bundleNftId,
+            ReferralLib.zero());
+    }
+
+    function calculateNetPremium(
+        Amount sumInsured,
+        RiskId,
+        Seconds lifetime,
+        bytes memory
+    )
+        external
+        view
+        virtual override
+        returns (Amount netPremiumAmount)
+    {
+        UFixed numDays = UFixedLib.toUFixed(lifetime.toInt() / 86400);
+        // to simplify time calculation we assume 360 days per year
+        UFixed pctOfYear = numDays / UFixedLib.toUFixed(360);
+        Amount premiumPerYear = AmountLib.toAmount(sumInsured.toInt() / 20);
+        return  premiumPerYear.multiplyWith(pctOfYear);
+    }
+
+    function createApplication(
+        string memory cityName,
+        Amount sumInsured,
+        Seconds lifetime,
+        NftId bundleNftId
+    )
+        public
+        restricted()
+        returns (NftId policyNftId)
+    {
+        address applicationOwner = msg.sender;
+        RiskId risk = initializeCity(cityName);
+
+        Amount premiumAmount = calculatePremium(
+            sumInsured,
+            risk,
+            lifetime,
+            "",
+            bundleNftId,
+            ReferralLib.zero());
+
+        return _createApplication(
+            applicationOwner,
+            risk,
+            sumInsured,
+            premiumAmount,
+            lifetime,
+            bundleNftId,
+            ReferralLib.zero(),
+            ""
+        );
+    }
+
+    function initializeCity(
+        string memory cityName
+    ) 
+        public
+        returns (RiskId risk) 
+    {
+        if (! _riskMapping[cityName].eqz()) {
+            return _riskMapping[cityName];
+        }
+        _cities.push(cityName);
+        risk = RiskIdLib.toRiskId(cityName);
+        _createRisk(risk, "");
+        _riskMapping[cityName] = risk;
+    }
+
+    /// @dev Calling this method will lock the sum insured amount in the pool and activate the policy at the given time. 
+    /// It will also collect the tokens payment for the premium. An approval with the correct amount towards the TokenHandler of the product is therefor required. 
+    function createPolicy(
+        NftId policyNftId,
+        Timestamp activateAt
+    ) 
+        public 
+        restricted()
+        onlyOwner()
+    {
+        _createPolicy(policyNftId, activateAt);
+        _collectPremium(policyNftId, activateAt);
+    }
+
+    /// @dev Decline the policy application
+    function decline(
+        NftId policyNftId
+    ) 
+        public 
+        restricted()
+        onlyOwner()
+    {
+        _decline(policyNftId);
+    }
+
+    function expire(
+        NftId policyNftId,
+        Timestamp expireAt
+    ) 
+        public 
+        restricted()
+        onlyOwner()
+        returns (Timestamp)
+    {
+        return _expire(policyNftId, expireAt);
+    }
+
+    function close(
+        NftId policyNftId
+    ) 
+        public 
+        restricted()
+        onlyOwner()
+    {
+        _close(policyNftId);
+    }
+
+    function reportFire(
+        uint256 fireId,
+        string memory cityName,
+        DamageLevel damageLevel,
+        Timestamp reportedAt
+    ) 
+        public 
+        restricted()
+    {
+        if (_riskMapping[cityName].eqz()) {
+            revert ErrorFireProductCityUnknown(cityName);
+        }
+
+        if (reportedAt > TimestampLib.blockTimestamp()) {
+            revert ErrorFireProductTimestampInFuture();
+        }
+
+        if (! _fires[fireId].reportedAt.eqz()) {
+            revert ErrorFireProductFireAlreadyReported();
+        }
+
+        _fires[fireId] = Fire({
+            cityName: cityName,
+            damageLevel: damageLevel,
+            reportedAt: reportedAt
+        });
+    }
+
+    function fire(uint256 fireId) public view returns (Fire memory) {
+        return _fires[fireId];
+    }
+
+    function submitClaim(
+        NftId policyNftId,
+        uint256 fireId
+    ) 
+        public 
+        restricted()
+        onlyNftOwner(policyNftId)
+        onlyNftOfType(policyNftId, POLICY())
+        returns (ClaimId claimId, PayoutId payoutId) 
+    {
+        IPolicy.PolicyInfo memory policyInfo = _getInstanceReader().getPolicyInfo(policyNftId);
+        _checkClaimConditions(policyNftId, policyInfo, fireId);
+        
+        Fire memory theFire = _fires[fireId];
+        _claimed[fireId][policyNftId] = true;
+
+        Amount claimAmount = _getClaimAmount(policyNftId, policyInfo.sumInsuredAmount, theFire.damageLevel);
+        
+        claimId = _submitClaim(policyNftId, claimAmount, abi.encodePacked(fireId));
+        _confirmClaim(policyNftId, claimId, claimAmount, "");
+
+        payoutId = _createPayout(policyNftId, claimId, claimAmount, "");
+        _processPayout(policyNftId, payoutId);
+    }
+
+    function _checkClaimConditions(
+        NftId policyNftId,
+        IPolicy.PolicyInfo memory policyInfo,
+        uint256 fireId
+    ) 
+        internal
+        view
+    {
+        // check fire exists
+        if (_fires[fireId].reportedAt.eqz()) {
+            revert ErrorFireProductFireUnknown(fireId);
+        }
+
+        // check fire is in same city as policy coverage
+        if (_riskMapping[_fires[fireId].cityName] != policyInfo.riskId) {
+            revert ErrorFireProductFireNotInCoveredCity(fireId, _fires[fireId].cityName);
+        }
+
+        // check policy has not been claimed yet for this fire
+        if (_claimed[fireId][policyNftId]) {
+            revert ErrorFireProductAlreadyClaimed();
+        }
+
+        Fire memory theFire = _fires[fireId];
+
+        // check fire is during policy lifetime
+        if (theFire.reportedAt < policyInfo.activatedAt) {
+            revert ErrorFireProductPolicyNotYetActive(policyNftId, policyInfo.activatedAt);
+        }
+
+        if (theFire.reportedAt >= policyInfo.expiredAt) {
+            revert ErrorFireProductPolicyExpired(policyNftId, policyInfo.expiredAt);
+        }
+    }
+
+    function _getClaimAmount(
+        NftId policyNftId,
+        Amount sumInsured,
+        DamageLevel damageLevel
+    ) 
+        internal
+        view
+        returns (Amount)
+    {
+        Amount claimAmount = sumInsured.multiplyWith(_damageLevelToPayoutPercentage(damageLevel));
+        Amount maxPayoutRemaining = _getInstanceReader().getRemainingClaimableAmount(policyNftId);
+
+        // if payout is higher than the remaining maximum payout, then claim what is remaining
+        if (maxPayoutRemaining < claimAmount) {
+            return maxPayoutRemaining;
+        }
+
+        return claimAmount;
+    }
+
+    function _damageLevelToPayoutPercentage(DamageLevel damageLevel) internal pure returns (UFixed) {
+        if (damageLevel.eq(DAMAGE_SMALL())) {
+            return UFixedLib.toUFixed(25, -2);
+        } else if (damageLevel.eq(DAMAGE_MEDIUM())) {
+            return UFixedLib.toUFixed(5, -1);
+        } else if (damageLevel.eq(DAMAGE_LARGE())) {
+            return UFixedLib.toUFixed(1);
+        } else {
+            revert ErrorFireProductUnknownDamageLevel(damageLevel);
+        }
+    }
+
+}

package/contracts/examples/fire/FireProductAuthorization.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {BasicProductAuthorization} from "../../product/BasicProductAuthorization.sol";
+import {FireProduct} from "./FireProduct.sol";
+import {IAccess} from "../../../contracts/authorization/IAccess.sol";
+import {PUBLIC_ROLE} from "../../../contracts/type/RoleId.sol";
+
+
+contract FireProductAuthorization
+    is BasicProductAuthorization
+{
+
+    constructor(string memory poolName)
+        BasicProductAuthorization(poolName)
+    {}
+
+    function _setupTargetAuthorizations()
+        internal
+        virtual override
+    {
+        super._setupTargetAuthorizations();
+        IAccess.FunctionInfo[] storage functions;
+
+        // authorize public role (open access to any account, only allows to lock target)
+        functions = _authorizeForTarget(getTargetName(), PUBLIC_ROLE());
+        // fully public functions
+        _authorize(functions, FireProduct.createApplication.selector, "createApplication");
+        
+        // only owner
+        _authorize(functions, FireProduct.createPolicy.selector, "createPolicy"); 
+        _authorize(functions, FireProduct.decline.selector, "decline"); 
+        _authorize(functions, FireProduct.expire.selector, "expire"); 
+        _authorize(functions, FireProduct.close.selector, "close"); 
+
+        // only policy nft owner
+        _authorize(functions, FireProduct.submitClaim.selector, "submitClaim"); 
+
+        // TODO: add custom role for fire reporter
+        _authorize(functions, FireProduct.reportFire.selector, "reportFire");
+    }
+
+}
+

package/contracts/examples/fire/FireUSD.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/// @dev FireUSD is a stablecoin with 6 decimals and an initial supply of 1 Billion tokens. 
+contract FireUSD is ERC20 {
+
+    string public constant NAME = "FireUSD";
+    string public constant SYMBOL = "HOT";
+    uint8 public constant DECIMALS = 6;
+    uint256 public constant INITIAL_SUPPLY = 10**12 * 10**DECIMALS; // 1'000'000'000'000
+    
+    constructor()
+        ERC20(NAME, SYMBOL)
+    {
+        _mint(
+            _msgSender(),
+            INITIAL_SUPPLY
+        );   
+    }
+
+    function decimals() public pure override returns(uint8) {
+        return DECIMALS;
+    }
+}

package/contracts/{example_components → examples}/unpermissioned/SimpleDistribution.sol

@@ -12,7 +12,7 @@ contract SimpleDistribution is
     
     constructor(
         address registry,
-        NftId instanceNftId,
+        NftId productNftId,
         IAuthorization authorization,
         address initialOwner,
         address token
@@ -20,7 +20,7 @@ contract SimpleDistribution is
     {
         initialize(
             registry,
-            instanceNftId,
+            productNftId,
             authorization,
             initialOwner,
             "SimpleDistribution",
@@ -29,7 +29,7 @@ contract SimpleDistribution is
 
     function initialize(
         address registry,
-        NftId instanceNftId,
+        NftId productNftId,
         IAuthorization authorization,
         address initialOwner,
         string memory name,
@@ -41,7 +41,7 @@ contract SimpleDistribution is
     {
         _initializeBasicDistribution(
             registry,
-            instanceNftId,
+            productNftId,
             authorization,
             initialOwner,
             name,

package/contracts/{example_components → examples}/unpermissioned/SimpleOracle.sol

@@ -32,7 +32,7 @@ contract SimpleOracle is
 
     constructor(
         address registry,
-        NftId instanceNftId,
+        NftId productNftId,
         IAuthorization authorization,
         address initialOwner,
         address token
@@ -40,7 +40,7 @@ contract SimpleOracle is
     {
         initialize(
             registry,
-            instanceNftId,
+            productNftId,
             authorization,
             initialOwner,
             "SimpleOracle",
@@ -50,7 +50,7 @@ contract SimpleOracle is
 
     function initialize(
         address registry,
-        NftId instanceNftId,
+        NftId productNftId,
         IAuthorization authorization,
         address initialOwner,
         string memory name,
@@ -62,7 +62,7 @@ contract SimpleOracle is
     {
         _initializeBasicOracle(
             registry,
-            instanceNftId,
+            productNftId,
             authorization,
             initialOwner,
             name,

package/contracts/{example_components → examples}/unpermissioned/SimplePool.sol

@@ -16,7 +16,7 @@ contract SimplePool is
     
     constructor(
         address registry,
-        NftId instanceNftId,
+        NftId productNftId,
         address token,
         IAuthorization authorization,
         address initialOwner
@@ -24,7 +24,7 @@ contract SimplePool is
     {
         initialize(
             registry,
-            instanceNftId,
+            productNftId,
             token,
             authorization,
             initialOwner
@@ -33,7 +33,7 @@ contract SimplePool is
 
     function initialize(
         address registry,
-        NftId instanceNftId,
+        NftId productNftId,
         address token,
         IAuthorization authorization,
         address initialOwner
@@ -44,7 +44,7 @@ contract SimplePool is
     {
         _initializeBasicPool(
             registry,
-            instanceNftId,
+            productNftId,
             authorization,
             token,
             "SimplePool",

package/contracts/{example_components → examples}/unpermissioned/SimpleProduct.sol

@@ -32,25 +32,25 @@ contract SimpleProduct is
 
     constructor(
         address registry,
-        NftId instanceNftid,
+        NftId instanceNftId,
         IAuthorization authorization,
         address initialOwner,
         address token,
         bool isInterceptor,
-        address pool,
-        address distribution
+        bool hasDistribution,
+        uint8 numberOfOracles
     )
     {
         initialize(
             registry,
-            instanceNftid,
+            instanceNftId,
             authorization,
             initialOwner,
             "SimpleProduct",
             token,
             isInterceptor,
-            pool,
-            distribution); 
+            hasDistribution,
+            numberOfOracles); 
     }
 
 
@@ -62,8 +62,8 @@ contract SimpleProduct is
         string memory name,
         address token,
         bool isInterceptor,
-        address pool,
-        address distribution
+        bool hasDistribution,
+        uint8 numberOfOracles
     )
         public
         virtual
@@ -77,8 +77,8 @@ contract SimpleProduct is
             name,
             token,
             isInterceptor,
-            pool,
-            distribution); 
+            hasDistribution,
+            numberOfOracles); 
 
         _oracleService = IOracleService(_getServiceAddress(ORACLE()));
     }

package/contracts/instance/IInstance.sol

@@ -10,6 +10,7 @@ import {InstanceReader} from "./InstanceReader.sol";
 import {InstanceStore} from "./InstanceStore.sol";
 import {IRegisterable} from "../shared/IRegisterable.sol";
 import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
+import {NftId} from "../type/NftId.sol";
 import {RoleId} from "../type/RoleId.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {UFixed} from "../type/UFixed.sol";
@@ -38,6 +39,9 @@ interface IInstance is
         uint64 requestsCount;
     }
 
+    /// @dev Register a product with the instance.
+    function registerProduct(address product) external returns (NftId productNftId);
+
     function createRole(string memory roleName, string memory adminName) external returns (RoleId roleId, RoleId admin);
     function grantRole(RoleId roleId, address account) external;
     function revokeRole(RoleId roleId, address account) external;
@@ -55,7 +59,6 @@ interface IInstance is
     function withdrawStakingRewardReserves(Amount dipAmount) external returns (Amount newBalance);
 
     // get instance release and supporting contracts
-    function getMajorVersion() external pure returns (VersionPart majorVersion);
     function getInstanceReader() external view returns (InstanceReader);
     function getBundleSet() external view returns (BundleSet);
     function getInstanceAdmin() external view returns (InstanceAdmin);

package/contracts/instance/IInstanceService.sol

@@ -68,25 +68,5 @@ interface IInstanceService is IService {
     /// @dev Defunds the staking reward reserves for the specified target.
     function withdrawStakingRewardReserves(Amount dipAmount) external returns (Amount newBalance);
 
-    /// @dev Sets up the component authorization for the specified instance.
-    /// The authorization is based on the authz specification provided by the component via getAuthorization.
-    function initializeAuthorization(NftId instanceNftId, IInstanceLinkedComponent component) external;
-
-    function createComponentTarget(
-        NftId instanceNftId,
-        address targetAddress,
-        string memory targetName,
-        bytes4[][] memory selectors,
-        RoleId[] memory roles
-    ) external;
-
-    function createGifTarget(
-        NftId instanceNftId,
-        address targetAddress,
-        string memory targetName,
-        bytes4[][] memory selectors,
-        RoleId[] memory roles
-    ) external;
-
     function setComponentLocked(bool locked) external;
 }