@etherisc/gif-next 0.0.2-bafc958-412 → 0.0.2-bb3faee-097

package/contracts/examples/fire/FireProduct.sol

@@ -1,29 +1,32 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
 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 {FeeLib} from "../../type/Fee.sol";
 import {IAuthorization} from "../../authorization/IAuthorization.sol";
-import {IOracleService} from "../../oracle/IOracleService.sol";
-import {ORACLE} from "../../type/ObjectType.sol";
-import {NftId} from "../../type/NftId.sol";
+import {IComponents} from "../../instance/module/IComponents.sol";
+import {IPolicy} from "../../instance/module/IPolicy.sol";
+import {NftId, NftIdLib} from "../../type/NftId.sol";
 import {PayoutId} from "../../type/PayoutId.sol";
-import {ReferralId, ReferralLib} from "../../type/Referral.sol";
-import {RequestId} from "../../type/RequestId.sol";
+import {POLICY, BUNDLE} from "../../type/ObjectType.sol";
+import {ReferralLib} from "../../type/Referral.sol";
 import {RiskId, RiskIdLib} from "../../type/RiskId.sol";
 import {Seconds} from "../../type/Seconds.sol";
-import {StateId} from "../../type/StateId.sol";
 import {Timestamp, TimestampLib} from "../../type/Timestamp.sol";
 import {UFixed, UFixedLib} from "../../type/UFixed.sol";
 
-uint64 constant SPECIAL_ROLE_INT = 11111;
-
+// 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);
 }
@@ -35,37 +38,53 @@ function ONE_YEAR() pure returns (Seconds) {
 contract FireProduct is 
     BasicProduct
 {
-    string[] _cities;
+    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);
-        initializeCity("London");
     }
 
     function _initialize(
         address registry,
-        NftId instanceNftid,
+        NftId instanceNftId,
         string memory componentName,
-        address token,
-        address pool,
         IAuthorization authorization,
         address initialOwner
     )
@@ -74,14 +93,41 @@ contract FireProduct is
     {
         _initializeBasicProduct(
             registry,
-            instanceNftid,
-            authorization,
-            initialOwner,
+            instanceNftId,
             componentName,
-            token,
-            false,
-            pool,
-            address(0));  // no distribution
+            IComponents.ProductInfo({
+                isProcessingFundedClaims: false,
+                isInterceptingPolicyTransfers: false,
+                hasDistribution: false,
+                expectedNumberOfOracles: 0,
+                numberOfOracles: 0,
+                poolNftId: NftIdLib.zero(),
+                distributionNftId: NftIdLib.zero(),
+                oracleNftId: new NftId[](0)
+            }), 
+            IComponents.FeeInfo({
+                productFee: FeeLib.zero(),
+                processingFee: FeeLib.zero(),
+                distributionFee: FeeLib.zero(),
+                minDistributionOwnerFee: FeeLib.zero(),
+                poolFee: FeeLib.zero(),
+                stakingFee: FeeLib.zero(),
+                performanceFee: FeeLib.zero()
+            }),
+            authorization,
+            initialOwner);  // 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(
@@ -91,12 +137,12 @@ contract FireProduct is
         restricted()
     {
         if (_riskMapping[cityName].eqz()) {
-            revert(); // TODO: custom error
+            revert ErrorFireProductCityUnknown(cityName);
         }
 
-        _updateRiskState(
+        _setRiskLocked(
             _riskMapping[cityName],
-            PAUSED()
+            true
         );
     }
 
@@ -107,12 +153,12 @@ contract FireProduct is
         restricted()
     {
         if (_riskMapping[cityName].eqz()) {
-            revert(); // TODO: custom error
+            revert ErrorFireProductCityUnknown(cityName);
         }
 
-        _updateRiskState(
+        _setRiskLocked(
             _riskMapping[cityName],
-            ACTIVE()
+            false
         );
     }
 
@@ -124,15 +170,16 @@ contract FireProduct is
     ) 
         public
         view
+        onlyNftOfType(bundleNftId, BUNDLE())
         returns (Amount premiumAmount)
     {
-        RiskId riskId = _riskMapping[cityName];
-        if (riskId.eqz()) {
-            revert(); // TODO: custom error
+        RiskId risk = _riskMapping[cityName];
+        if (risk.eqz()) {
+            revert ErrorFireProductCityUnknown(cityName);
         }
         premiumAmount = calculatePremium( 
             sumInsured,
-            riskId,
+            risk,
             lifetime,
             "",
             bundleNftId,
@@ -158,7 +205,6 @@ contract FireProduct is
     }
 
     function createApplication(
-        address applicationOwner,
         string memory cityName,
         Amount sumInsured,
         Seconds lifetime,
@@ -166,14 +212,15 @@ contract FireProduct is
     )
         public
         restricted()
+        onlyNftOfType(bundleNftId, BUNDLE())
         returns (NftId policyNftId)
     {
         address applicationOwner = msg.sender;
-        RiskId riskId = initializeCity(cityName);
+        RiskId risk = initializeCity(cityName);
 
         Amount premiumAmount = calculatePremium(
             sumInsured,
-            riskId,
+            risk,
             lifetime,
             "",
             bundleNftId,
@@ -181,7 +228,7 @@ contract FireProduct is
 
         return _createApplication(
             applicationOwner,
-            riskId,
+            risk,
             sumInsured,
             premiumAmount,
             lifetime,
@@ -195,38 +242,41 @@ contract FireProduct is
         string memory cityName
     ) 
         public
-        returns (RiskId riskId) 
+        returns (RiskId risk) 
     {
         if (! _riskMapping[cityName].eqz()) {
             return _riskMapping[cityName];
         }
         _cities.push(cityName);
-        riskId = RiskIdLib.toRiskId(cityName);
-        _createRisk(riskId, "");
-        _riskMapping[cityName] = riskId;
+        risk = _createRisk(bytes32(abi.encodePacked(cityName)), "");
+        _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 applicationNftId,
-        bool requirePremiumPayment,
+        NftId policyNftId,
         Timestamp activateAt
-    ) public {
-        // TODO: implement createPolicy
-
-        // _createPolicy(applicationNftId, activateAt);
-        // if (requirePremiumPayment == true) {
-        //     _collectPremium(applicationNftId, activateAt);
-        // }
+    ) 
+        public 
+        restricted()
+        onlyOwner()
+        onlyNftOfType(policyNftId, POLICY())
+    {
+        _createPolicy(policyNftId, activateAt, AmountLib.max());
+        _collectPremium(policyNftId, activateAt);
     }
 
+    /// @dev Decline the policy application
     function decline(
         NftId policyNftId
     ) 
         public 
         restricted()
+        onlyOwner()
+        onlyNftOfType(policyNftId, POLICY())
     {
-        // TODO: implement decline
-        // _decline(policyNftId);
+        _decline(policyNftId);
     }
 
     function expire(
@@ -235,10 +285,11 @@ contract FireProduct is
     ) 
         public 
         restricted()
+        onlyOwner()
+        onlyNftOfType(policyNftId, POLICY())
         returns (Timestamp)
     {
-        // TODO: implement expire
-        // return _expire(policyNftId, expireAt);
+        return _expire(policyNftId, expireAt);
     }
 
     function close(
@@ -246,71 +297,137 @@ contract FireProduct is
     ) 
         public 
         restricted()
+        onlyOwner()
+        onlyNftOfType(policyNftId, POLICY())
     {
-        // TODO: implement close
-        // _close(policyNftId);
+        _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.current()) {
+            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,
-        Amount claimAmount,
-        bytes memory submissionData
+        uint256 fireId
     ) 
         public 
         restricted()
-        returns (ClaimId) 
+        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
     {
-        // TODO: implement submitClaim
-        // return _submitClaim(policyNftId, claimAmount, submissionData);
+        // 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];
 
-        // TODO: check if fire was reported in the city
-        // TODO: if yes, process payout and close claimn
-        // TODO: if no, decline claim
+        // 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);
+        }
     }
 
-    // TODO: no longer needed? -> remove
-    // function confirmClaim(
-    //     NftId policyNftId,
-    //     ClaimId claimId,
-    //     Amount confirmedAmount,
-    //     bytes memory processData
-    // ) public {
-    //     // TODO: implement confirmClaim
-    //     // _confirmClaim(policyNftId, claimId, confirmedAmount, processData);
-    // }
-
-    // TODO: no longer needed? -> remove
-    // function declineClaim(
-    //     NftId policyNftId,
-    //     ClaimId claimId,
-    //     bytes memory processData
-    // ) public {
-    //     // TODO: implement declineClaim
-    //     // _declineClaim(policyNftId, claimId, processData);
-    // }
-
-    // TODO: no longer needed? -> remove
-    // function createPayout(
-    //     NftId policyNftId,
-    //     ClaimId claimId,
-    //     Amount amount,
-    //     bytes memory data
-    // ) public returns (PayoutId) {
-    //     return _createPayout(policyNftId, claimId, amount, data);
-    // }
-
-    // TODO: add method to report fire per city with a percentage of payout
+    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;
+        }
 
-    
-    // TODO: no longer needed? -> remove
-    // function processPayout(
-    //     NftId policyNftId,
-    //     PayoutId payoutId
-    // ) public {
-        // TODO: implement process all pending payouts for a risk - arguments cityname and payout percentage
-    //     _processPayout(policyNftId, payoutId);
-    // }
+        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);
+        }
+    }
 
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external restricted() onlyOwner() { _approveTokenHandler(token, amount); }
+    function setLocked(bool locked) external onlyOwner() { _setLocked(locked); }
+    function setWallet(address newWallet) external restricted() onlyOwner() { _setWallet(newWallet); }
 }

package/contracts/examples/fire/FireProductAuthorization.sol

@@ -2,6 +2,9 @@
 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
@@ -12,5 +15,31 @@ contract FireProductAuthorization
         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(getMainTargetName(), PUBLIC_ROLE());
+        // fully public functions
+        _authorize(functions, FireProduct.approveTokenHandler.selector, "approveTokenHandler");
+        _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

@@ -9,7 +9,7 @@ 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**9 * 6**DECIMALS; // 1 Billion 1'000'000'000
+    uint256 public constant INITIAL_SUPPLY = 10**12 * 10**DECIMALS; // 1'000'000'000'000
     
     constructor()
         ERC20(NAME, SYMBOL)

package/contracts/examples/unpermissioned/SimpleDistribution.sol

@@ -1,9 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Amount} from "../../type/Amount.sol";
 import {BasicDistribution} from "../../distribution/BasicDistribution.sol";
 import {IAuthorization} from "../../authorization/IAuthorization.sol";
 import {NftId} from "../../type/NftId.sol";
+import {ReferralId} from "../../type/Referral.sol";
+import {Timestamp, TimestampLib} from "../../type/Timestamp.sol";
+import {UFixed, UFixedLib} from "../../type/UFixed.sol";
 
 
 contract SimpleDistribution is
@@ -12,28 +18,25 @@ contract SimpleDistribution is
     
     constructor(
         address registry,
-        NftId instanceNftId,
+        NftId productNftId,
         IAuthorization authorization,
-        address initialOwner,
-        address token
+        address initialOwner
     ) 
     {
         initialize(
             registry,
-            instanceNftId,
+            productNftId,
             authorization,
             initialOwner,
-            "SimpleDistribution",
-            token);
+            "SimpleDistribution");
     }
 
     function initialize(
         address registry,
-        NftId instanceNftId,
+        NftId productNftId,
         IAuthorization authorization,
         address initialOwner,
-        string memory name,
-        address token
+        string memory name
     )
         public
         virtual
@@ -41,10 +44,38 @@ contract SimpleDistribution is
     {
         _initializeBasicDistribution(
             registry,
-            instanceNftId,
+            productNftId,
             authorization,
             initialOwner,
-            name,
-            token);
+            name);
     }
+
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external restricted() onlyOwner() { _approveTokenHandler(token, amount); }
+    function setLocked(bool locked) external onlyOwner() { _setLocked(locked); }
+    function setWallet(address newWallet) external restricted() onlyOwner() { _setWallet(newWallet); }
+
+    /**
+     * @dev create referral codes. This is required for testing only to provide a distributor that is not the message sender. 
+     */
+    function createReferral2(
+        NftId distributorNftId,
+        string memory code,
+        UFixed discountPercentage,
+        uint32 maxReferrals,
+        Timestamp expiryAt,
+        bytes memory data
+    )
+        external
+        virtual
+        returns (ReferralId referralId)
+    {
+        return _createReferral(
+            distributorNftId,
+            code,
+            discountPercentage,
+            maxReferrals,
+            expiryAt,
+            data); // data
+    }
+
 }

package/contracts/examples/unpermissioned/SimpleDistributionAuthorization.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {BasicDistributionAuthorization} from "../../distribution/BasicDistributionAuthorization.sol";
+import {IAccess} from "../../authorization/IAccess.sol";
+import {PUBLIC_ROLE} from "../../type/RoleId.sol";
+import {SimpleDistribution} from "./SimpleDistribution.sol";
+
+contract SimpleDistributionAuthorization
+    is BasicDistributionAuthorization
+{
+    constructor(string memory componentName)
+        BasicDistributionAuthorization(componentName)
+    {}
+
+    function _setupTargetAuthorizations()
+        internal
+        virtual override
+    {
+        super._setupTargetAuthorizations();
+
+        // authorize public role (open access to any account, only allows to lock target)
+        IAccess.FunctionInfo[] storage functions;
+        functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
+        _authorize(functions, SimpleDistribution.approveTokenHandler.selector, "approveTokenHandler");
+        _authorize(functions, SimpleDistribution.setWallet.selector, "setWallet");
+    }
+}