@etherisc/gif-next 0.0.2-c8cedfe-604 → 0.0.2-c9577b6-545

package/contracts/examples/fire/FirePoolAuthorization.sol

@@ -0,0 +1,34 @@
+
+
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {BasicPoolAuthorization} from "../../pool/BasicPoolAuthorization.sol";
+import {FirePool} from "./FirePool.sol";
+import {IAccess} from "../../../contracts/authorization/IAccess.sol";
+import {PUBLIC_ROLE} from "../../../contracts/type/RoleId.sol";
+
+contract FirePoolAuthorization
+    is BasicPoolAuthorization
+{
+
+    constructor(string memory poolName)
+        BasicPoolAuthorization(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());
+        // TODO: FirePool.createBundle must require a custom role (e.g. INVESTOR) instead of PUBLIC_ROLE
+        _authorize(functions, FirePool.createBundle.selector, "createBundle");
+    }
+
+}
+

package/contracts/examples/fire/FireProduct.sol

@@ -0,0 +1,411 @@
+// 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,
+            pool,
+            address(0));  // no distribution
+    }
+    
+    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,45 @@
+// 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 {PRODUCT_OWNER_ROLE, 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"); 
+
+        functions = _authorizeForTarget(getTargetName(), PRODUCT_OWNER_ROLE());
+        // 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/examples/unpermissioned/SimpleDistribution.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {BasicDistribution} from "../../distribution/BasicDistribution.sol";
+import {IAuthorization} from "../../authorization/IAuthorization.sol";
+import {NftId} from "../../type/NftId.sol";
+
+
+contract SimpleDistribution is
+    BasicDistribution
+{
+    
+    constructor(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        address token
+    ) 
+    {
+        initialize(
+            registry,
+            instanceNftId,
+            authorization,
+            initialOwner,
+            "SimpleDistribution",
+            token);
+    }
+
+    function initialize(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name,
+        address token
+    )
+        public
+        virtual
+        initializer()
+    {
+        _initializeBasicDistribution(
+            registry,
+            instanceNftId,
+            authorization,
+            initialOwner,
+            name,
+            token);
+    }
+}

package/contracts/examples/unpermissioned/SimpleOracle.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAuthorization} from "../../authorization/IAuthorization.sol";
+import {NftId} from "../../type/NftId.sol";
+import {BasicOracle} from "../../oracle/BasicOracle.sol";
+import {RequestId} from "../../type/RequestId.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
+
+contract SimpleOracle is
+    BasicOracle
+{
+
+    string public constant ANSWER_SYNC = "oracle constant sync answer";
+
+    struct SimpleRequest {
+        bool synchronous;
+        string text;
+    }
+
+    struct SimpleResponse {
+        bool revertInCall;
+        Timestamp revertUntil;
+        string text;
+    }
+
+    event LogSimpleOracleRequestReceived(RequestId requestId, NftId requesterId, bool synchronous, string requestText);
+    event LogSimpleOracleCancellingReceived(RequestId requestId);
+
+    event LogSimpleOracleAsyncResponseSent(RequestId requestId, string responseText);
+    event LogSimpleOracleSyncResponseSent(RequestId requestId, string responseText);
+
+    constructor(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        address token
+    ) 
+    {
+        initialize(
+            registry,
+            instanceNftId,
+            authorization,
+            initialOwner,
+            "SimpleOracle",
+            token
+        );
+    }
+
+    function initialize(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name,
+        address token
+    )
+        public
+        virtual
+        initializer()
+    {
+        _initializeBasicOracle(
+            registry,
+            instanceNftId,
+            authorization,
+            initialOwner,
+            name,
+            token);
+    }
+
+    /// @dev use case specific handling of oracle requests
+    /// for now only log is emitted to verify that request has been received by oracle component 
+    function _request(
+        RequestId requestId,
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    )
+        internal
+        virtual override
+    {
+        SimpleRequest memory request = abi.decode(requestData, (SimpleRequest));
+
+        if (request.synchronous) {
+            _respondSync(requestId);
+        }
+
+        emit LogSimpleOracleRequestReceived(requestId, requesterId, request.synchronous, request.text);
+    }
+
+
+    /// @dev use case specific handling of oracle requests
+    /// for now only log is emitted to verify that cancelling has been received by oracle component 
+    function _cancel(
+        RequestId requestId
+    )
+        internal
+        virtual override
+    {
+        emit LogSimpleOracleCancellingReceived(requestId);
+    }
+
+
+    function respondAsync(
+        RequestId requestId,
+        string memory responseText,
+        bool revertInCall,
+        Timestamp revertUntil
+    )
+        external
+        // permissionless, no restricted() for now
+    {
+        bytes memory responseData = abi.encode(
+            SimpleResponse(
+                revertInCall, 
+                revertUntil,
+                responseText));
+
+        _respond(requestId, responseData);
+
+        emit LogSimpleOracleAsyncResponseSent(requestId, responseText);
+    }
+
+
+    function _respondSync(
+        RequestId requestId
+    )
+        internal
+    {
+        bytes memory responseData = abi.encode(ANSWER_SYNC);
+        _respond(requestId, responseData);
+
+        emit LogSimpleOracleSyncResponseSent(requestId, ANSWER_SYNC);
+    }
+
+}