@etherisc/gif-next 0.0.2-77c72ae-504 → 0.0.2-782e47c-610

package/contracts/instance/{ObjectManager.sol → base/ObjectSet.sol}

@@ -3,39 +3,34 @@ pragma solidity ^0.8.20;
 
 import {Cloneable} from "./Cloneable.sol";
 
-import {IInstance} from "./IInstance.sol";
-import {INSTANCE} from "../types/ObjectType.sol";
-import {InstanceReader} from "./InstanceReader.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {LibNftIdSet} from "../types/NftIdSet.sol";
-import {NftId} from "../types/NftId.sol";
-
-contract ObjectManager is
+import {IInstance} from "../IInstance.sol";
+import {INSTANCE} from "../../type/ObjectType.sol";
+import {InstanceReader} from "../InstanceReader.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
+import {LibNftIdSet} from "../../type/NftIdSet.sol";
+import {NftId} from "../../type/NftId.sol";
+
+contract ObjectSet is
     Cloneable
 {
 
-    event LogObjectManagerInitialized(address instance);
+    event LogObjectSetInitialized(address instance);
 
-    error ErrorObjectManagerNftIdInvalid(NftId instanceNftId);
-    error ErrorObjectManagerAlreadyAdded(NftId componentNftId, NftId objectNftId);
+    error ErrorObjectSetNftIdInvalid(NftId instanceNftId);
 
     mapping(NftId compnentNftId => LibNftIdSet.Set objects) internal _activeObjects;
     mapping(NftId compnentNftId => LibNftIdSet.Set objects) internal _allObjects;
-    IInstance internal _instance; // store instance address -> more flexible, instance may not be registered during ObjectManager initialization
-
-    /// @dev call to initialize MUST be made in the same transaction as cloning of the contract
-    function initialize(
-        address authority,
-        address registry,
-        address instance
-    )
-        external 
-    {
-        initialize(authority, registry);
+    IInstance internal _instance; // store instance address -> more flexible, instance may not be registered during ObjectSet initialization
 
-        _instance = IInstance(instance);
+    /// @dev This initializer needs to be called from the instance itself.
+    function initialize() 
+        external
+        initializer()
+    {
+        _instance = IInstance(msg.sender);
+        __Cloneable_init(_instance.authority(), address(_instance.getRegistry()));
         
-        emit LogObjectManagerInitialized(instance);
+        emit LogObjectSetInitialized(address(_instance));
     }
 
     function getInstance() external view returns (IInstance) {

package/contracts/instance/module/IAccess.sol

@@ -3,45 +3,44 @@ pragma solidity ^0.8.20;
 
 import {ShortString, ShortStrings} from "@openzeppelin/contracts/utils/ShortStrings.sol";
 
-import {RoleId} from "../../types/RoleId.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
+import {NftId} from "../../type/NftId.sol";
+import {RoleId} from "../../type/RoleId.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
 
 interface IAccess {
 
+    enum Type {
+        NotInitialized,
+        Core,
+        Gif,
+        Custom        
+    }
+
     struct RoleInfo {
         ShortString name;
-        bool isCustom;
-        bool isLocked;
+        Type rtype;
+        //bool isLocked;
+        RoleId admin;
         Timestamp createdAt;
         Timestamp updatedAt;
     }
 
     struct TargetInfo {
         ShortString name;
-        bool isCustom;
+        Type ttype;
         bool isLocked;
         Timestamp createdAt;
         Timestamp updatedAt;
     }
 
-    error ErrorIAccessRoleIdInvalid(RoleId roleId);
     error ErrorIAccessRoleIdTooBig(RoleId roleId);
     error ErrorIAccessRoleIdTooSmall(RoleId roleId);
-    error ErrorIAccessRoleIdAlreadyExists(RoleId roleId, ShortString name);
-    error ErrorIAccessRoleIdNotActive(RoleId roleId);
-    error ErrorIAccessRoleNameEmpty(RoleId roleId);
-    error ErrorIAccessRoleNameNotUnique(RoleId roleId, ShortString name);
-    error ErrorIAccessRoleInvalidUpdate(RoleId roleId, bool isCustom);
-    error ErrorIAccessRoleIsCustomIsImmutable(RoleId roleId, bool isCustom, bool isCustomExisting);
-    error ErrorIAccessGrantNonexstentRole(RoleId roleId);
-    error ErrorIAccessRevokeNonexstentRole(RoleId roleId); 
-    error ErrorIAccessRenounceNonexstentRole(RoleId roleId);
+    error ErrorIAccessRoleTypeInvalid(RoleId roleId, Type rtype);
 
     error ErrorIAccessTargetAddressZero();
-    error ErrorIAccessTargetDoesNotExist(ShortString name);
-    error ErrorIAccessTargetAddressDoesNotExist(address target);
-    error ErrorIAccessTargetExists(address target, ShortString name);
-    error ErrorIAccessTargetNameEmpty(address target);
-    error ErrorIAccessTargetNameExists(address target, address existingTarget, ShortString name);
+    error ErrorIAccessTargetTypeInvalid(address target, Type ttype);
     error ErrorIAccessTargetLocked(address target);
+    error ErrorIAccessTargetNotRegistered(address target);
+    error ErrorIAccessTargetAuthorityInvalid(address target, address targetAuthority);
+    error ErrorIAccessTargetInstanceMismatch(address target, NftId targetParentNftId, NftId instanceNftId);
 }

package/contracts/instance/module/IBundle.sol

@@ -1,20 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
-import {Fee} from "../../types/Fee.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
+import {Amount} from "../../type/Amount.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Fee} from "../../type/Fee.sol";
+import {Seconds} from "../../type/Seconds.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
 
 interface IBundle {
+
     struct BundleInfo {
         NftId poolNftId;
         Fee fee; // bundle fee on net premium amounts
         bytes filter; // required conditions for applications to be considered for collateralization by this bundle
-        uint256 capitalAmount; // net investment capital + net premiums - payouts
-        uint256 lockedAmount; // capital amount linked to collateralizaion of non-closed policies (<= balance)
-        uint256 balanceAmount; // total amount of funds: capitalAmount + fees (balance >= captial)
-        uint256 lifetime;
-        Timestamp expiredAt; // no new policies
+        Timestamp activatedAt; 
+        Timestamp expiredAt; // no new policies starting with this timestamp
         Timestamp closedAt; // no open policies, locked amount = 0
     }
 }

package/contracts/instance/module/{ISetup.sol → IComponents.sol}

@@ -3,45 +3,44 @@ pragma solidity ^0.8.20;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
-import {Fee} from "../../types/Fee.sol";
-import {NftId} from "../../types/NftId.sol";
-import {UFixed} from "../../types/UFixed.sol";
+import {Amount} from "../../type/Amount.sol";
+import {Fee} from "../../type/Fee.sol";
+import {NftId} from "../../type/NftId.sol";
+import {RoleId} from "../../type/RoleId.sol";
 import {TokenHandler} from "../../shared/TokenHandler.sol";
+import {UFixed} from "../../type/UFixed.sol";
 
-interface ISetup {
-    struct ProductSetupInfo {
+interface IComponents {
+
+    struct ComponentInfo {
+        string name; // component name (needs to be unique per instance)
+        NftId productNftId;
         IERC20Metadata token;
         TokenHandler tokenHandler;
+        address wallet;
+        bytes data; // will hold component type specific additional info (eg encoded pool info)
+    }
+
+    struct ProductInfo {
         NftId distributionNftId;
         NftId poolNftId;
-        Fee distributionFee; // default distribution fee (no referral id)
         Fee productFee; // product fee on net premium
-        Fee processingFee; // product fee on payout amounts
+        Fee processingFee; // product fee on payout amounts        
+        Fee distributionFee; // distribution fee for sales that do not include commissions
+        Fee minDistributionOwnerFee; // min fee required by distribution owner (not including commissions for distributors)
         Fee poolFee; // pool fee on net premium
         Fee stakingFee; // pool fee on staked capital from investor
         Fee performanceFee; // pool fee on profits from capital investors
-        bool isIntercepting; // intercepts nft transfers (for products)
-        address wallet;
     }
 
-    struct DistributionSetupInfo {
-        NftId productNftId;
-        TokenHandler tokenHandler;
-        Fee distributionFee; // default distribution fee (no referral id)
-        address wallet;
-    }
 
-    struct PoolSetupInfo {
-        NftId productNftId;
-        TokenHandler tokenHandler;
+    struct PoolInfo {
+        Amount maxBalanceAmount; // max balance amount allowed for pool
+        RoleId bundleOwnerRole; // the required role for bundle owners
         bool isInterceptingBundleTransfers; // intercepts nft transfers for bundles
         bool isExternallyManaged; // funding bundles is restricted to book keeping, actual funds may be provided as needed to support payouts
         bool isVerifyingApplications; // underwriting requires the pool component checks/confirms the applications 
         UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
         UFixed retentionLevel; // amount of collateral held in pool (default 100%)
-        Fee poolFee; // pool fee on net premium
-        Fee stakingFee; // pool fee on staked capital from investor
-        Fee performanceFee; // pool fee on profits from capital investors
-        address wallet;
     }
 }

package/contracts/instance/module/IDistribution.sol

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {DistributorType} from "../../types/DistributorType.sol";
-import {NftId} from "../../types/NftId.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
-import {UFixed} from "../../types/UFixed.sol";
+import {Amount} from "../../type/Amount.sol";
+import {DistributorType} from "../../type/DistributorType.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
+import {UFixed} from "../../type/UFixed.sol";
 
 interface IDistribution {
 
@@ -24,6 +25,7 @@ interface IDistribution {
         DistributorType distributorType;
         bool active;
         bytes data;
+        uint32 numPoliciesSold;
     }
 
     struct ReferralInfo {   

package/contracts/instance/module/IPolicy.sol

@@ -1,29 +1,62 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
-import {ClaimId} from "../../types/ClaimId.sol";
-import {ReferralId} from "../../types/Referral.sol";
-import {RiskId} from "../../types/RiskId.sol";
-import {Timestamp} from "../../types/Timestamp.sol";
+import {Amount} from "../../type/Amount.sol";
+import {NftId} from "../../type/NftId.sol";
+import {ClaimId} from "../../type/ClaimId.sol";
+import {ReferralId} from "../../type/Referral.sol";
+import {RiskId} from "../../type/RiskId.sol";
+import {Seconds} from "../../type/Seconds.sol";
+import {Timestamp} from "../../type/Timestamp.sol";
 
 interface IPolicy {
 
+    struct PremiumInfo {
+        // premium splitting per target wallet
+        Amount productFeeAmount;
+        Amount distributionFeeAndCommissionAmount;
+        Amount poolPremiumAndFeeAmount;
+
+        // detailed positions
+        // this is the net premium calculated by the product 
+        Amount netPremiumAmount;
+        // fullPremium = netPremium + all fixed amounts + all variable amounts (excl commission and minDistribtuionOwnerFee variable part)
+        Amount fullPremiumAmount;
+        // effective premium = fullPremium - discount 
+        Amount premiumAmount;
+        Amount productFeeFixAmount;
+        Amount poolFeeFixAmount;
+        Amount bundleFeeFixAmount;
+        Amount distributionFeeFixAmount;
+        Amount productFeeVarAmount;
+        Amount poolFeeVarAmount;
+        Amount bundleFeeVarAmount;
+        Amount distributionFeeVarAmount;
+        Amount distributionOwnerFeeFixAmount;
+        // this is the remaining amount when the commission and discount are subtracted from the distribution fee variable part (must be at least the minDistributionOwnerFee)
+        Amount distributionOwnerFeeVarAmount;
+        // this value is based on distributor type referenced in the referral 
+        Amount commissionAmount;
+        // this is based on referral used
+        Amount discountAmount;
+    }
+
     /// @dev policy data for the full policy lifecycle
     struct PolicyInfo {
         NftId productNftId;
         NftId bundleNftId;
         ReferralId referralId;
         RiskId riskId;
-        uint256 sumInsuredAmount;
-        uint256 premiumAmount;
-        uint256 premiumPaidAmount;
-        uint256 lifetime;
+        Amount sumInsuredAmount;
+        Amount premiumAmount; // expected premium at application time
+        Seconds lifetime;
+        // policy application data, no changes after applying for a policy
         bytes applicationData;
-        bytes policyData;
+        bytes processData;
         uint16 claimsCount;
         uint16 openClaimsCount;
-        uint256 payoutAmount;
+        Amount claimAmount; // sum of confirmed claim amounts (max = sum insured amount)
+        Amount payoutAmount; // sum of payouts (max = sum confirmed claim amountst)
         Timestamp activatedAt; // time of underwriting
         Timestamp expiredAt; // no new claims (activatedAt + lifetime)
         Timestamp closedAt; // no locked capital (or declinedAt)
@@ -31,17 +64,21 @@ interface IPolicy {
 
     // claimId neeeds to be encoded policyNftId:claimId combination
     struct ClaimInfo {
-        uint256 claimAmount;
-        uint256 paidAmount;
-        bytes data;
-        Timestamp closedAt; // payoment of confirmed claim amount (or declinedAt)
+        Amount claimAmount;
+        Amount paidAmount;
+        uint8 payoutsCount;
+        uint8 openPayoutsCount;
+        bytes submissionData; // use case specific claim submission data, no changes after submitting the claim
+        bytes processData; // use case specific data that may include information supporting confirm or decline
+        Timestamp closedAt; // payment of confirmed claim amount (or declinedAt)
     }
 
     // claimId neeeds to be encoded policyNftId:claimId combination
     struct PayoutInfo {
         ClaimId claimId;
-        uint256 amount;
-        bytes data;
-        Timestamp paidAt; // payoment of confirmed claim amount (or declinedAt)
+        Amount amount;
+        address beneficiary; // for address(0) beneficiary is policy nft owner
+        bytes data; // use case specific supporting data
+        Timestamp paidAt; // timestamp for actual payout
     }
 }

package/contracts/instance/module/IRisk.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../../types/NftId.sol";
+import {NftId} from "../../type/NftId.sol";
 
 interface IRisk {
     struct RiskInfo {

package/contracts/{test/Usdc.sol → mock/Dip.sol}

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
-contract USDC is ERC20 {
+contract Dip is ERC20 {
 
     // https://etherscan.io/token/0xc719d010b63e5bbf2c0551872cd5316ed26acd83#readContract
-    string public constant NAME = "USDC - DUMMY";
-    string public constant SYMBOL = "USDC";
-    uint8 public constant DECIMALS = 6;
+    string public constant NAME = "Decentralized Insurance Protocol - DUMMY";
+    string public constant SYMBOL = "DIP";
+    uint8 public constant DECIMALS = 18;
     uint256 public constant INITIAL_SUPPLY = 10**9 * 10**DECIMALS; // 1 Billion 1'000'000'000
     // decimals == 18 (openzeppelin erc20 default)
     constructor()

package/contracts/oracle/BasicOracle.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAuthorization} from "../../contracts/authorization/IAuthorization.sol";
+import {NftId} from "../../contracts/type/NftId.sol";
+import {Oracle} from "../../contracts/oracle/Oracle.sol";
+import {RequestId} from "../../contracts/type/RequestId.sol";
+
+contract BasicOracle is
+    Oracle
+{
+
+    /// Function to provide reponse data releated to request id.
+    function respond(
+        RequestId requestId,
+        bytes memory responseData
+    )
+        external
+        virtual
+        restricted()
+    {
+        _respond(requestId, responseData);
+    }
+
+    function _initializeBasicOracle(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name,
+        address token
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+
+        _initializeOracle(
+            registry,
+            instanceNftId,
+            authorization,
+            initialOwner,
+            name,
+            token,
+            "",
+            "");
+    }
+}

package/contracts/oracle/BasicOracleAuthorization.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Authorization} from "../authorization/Authorization.sol";
+import {BasicOracle} from "./BasicOracle.sol"; 
+import {ORACLE} from "../type/ObjectType.sol";
+import {IAccess} from "../authorization/IAccess.sol";
+import {IOracle} from "./IOracle.sol"; 
+import {PUBLIC_ROLE} from "../../contracts/type/RoleId.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+
+contract BasicOracleAuthorization
+     is Authorization
+{
+
+     constructor(string memory componentName)
+          Authorization(componentName)
+     {}
+
+     function _setupTargets()
+          internal
+          virtual override
+     {
+          // basic component target
+          _addComponentTargetWithRole(ORACLE()); 
+     }
+
+
+     function _setupTargetAuthorizations()
+          internal
+          virtual override
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getTargetName(), getServiceRole(ORACLE()));
+          _authorize(functions, IOracle.request.selector, "request");
+          _authorize(functions, IOracle.cancel.selector, "cancel");
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getTargetName(), PUBLIC_ROLE());
+          _authorize(functions, BasicOracle.respond.selector, "respond");
+     }
+}
+

package/contracts/oracle/IOracle.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {NftId} from "../type/NftId.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+
+interface IOracle {
+
+    struct RequestInfo {
+        NftId requesterNftId; // originator of the request
+        string callbackMethodName; // callback function of the requestor to call to provide response data
+        NftId oracleNftId; // responsible oracle component
+        bytes requestData; 
+        bytes responseData; 
+        Timestamp respondedAt; // response timestamp
+        Timestamp expiredAt; // expiry timestamp
+        bool isCancelled;
+    }
+
+
+    /// @dev Callback function for oracle service to notify this oracle component to retreive some oracle data.
+    function request(
+        RequestId requestId,
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    ) external;
+
+
+    /// @dev Callback function for oracle service to notify this oracle component that the specified oracle request has ben cancelled by the requestor.
+    function cancel(
+        RequestId requestId
+    ) external;
+}

package/contracts/oracle/IOracleComponent.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Fee} from "../type/Fee.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
+import {ReferralId, ReferralStatus} from "../type/Referral.sol";
+import {NftId} from "../type/NftId.sol";
+import {DistributorType} from "../type/DistributorType.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+interface IOracleComponent is IInstanceLinkedComponent {
+    error ErrorOracleNotImplemented(string methodName);
+    
+    /// @dev callback method for requesting some data from the oracle
+    function request(
+        RequestId requestId,
+        NftId requesterNftId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    ) external;
+
+
+    /// @dev callback method for cancelling the specified oracle request
+    function cancel(
+        RequestId requestId
+    ) external;
+
+
+    /// @dev returns true iff the component needs to be called when selling/renewing policis
+    function isVerifying() external view returns (bool verifying);
+}

package/contracts/oracle/IOracleService.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IService} from "../shared/IService.sol";
+import {NftId} from "../type/NftId.sol";
+import {RequestId} from "../type/RequestId.sol";
+import {StateId} from "../type/StateId.sol";
+import {Timestamp} from "../type/Timestamp.sol";
+
+
+interface IOracleService is IService {
+
+    event LogOracleServiceRequestCreated(RequestId requestId, NftId requesterNftId, NftId oracleNftId, Timestamp expiryAt);
+    event LogOracleServiceResponseProcessed(RequestId requestId, NftId oracleNftId);
+    event LogOracleServiceDeliveryFailed(RequestId requestId, address requesterAddress, string functionSignature);
+    event LogOracleServiceResponseResent(RequestId requestId, NftId requesterNftId);
+    event LogOracleServiceRequestCancelled(RequestId requestId, NftId requesterNftId);
+
+    // create request
+    error ErrorOracleServiceInstanceMismatch(NftId expectedInstanceNftId, NftId oracleInstanceNftId);
+    error ErrorOracleServiceExpiryInThePast(Timestamp blockTimestamp, Timestamp expiryAt);
+    error ErrorOracleServiceCallbackMethodNameEmpty();
+
+    // respond
+    error ErrorOracleServiceNotResponsibleOracle(RequestId requestId, NftId expectedOracleNftId, NftId oracleNftId);
+
+    // get request info
+    error ErrorOracleServiceRequestStateNotActive(RequestId requestId, StateId state);
+    error ErrorOracleServiceCallerNotResponsibleOracle(RequestId requestId, NftId oracleNftId, NftId callerNftId);
+    error ErrorOracleServiceCallerNotRequester(RequestId requestId, NftId requesterNftId, NftId callerNftId);
+    error ErrorOracleServiceRequestExpired(RequestId requestId, Timestamp expiredAt);
+    
+    /// @dev send an oracle request to the specified oracle component.
+    /// the function returns the id of the newly created request.
+    /// permissioned: only registered components may send requests to oracles.
+    function request(
+        NftId oracleNftId,
+        bytes calldata requestData,
+        Timestamp expiryAt,
+        string calldata callbackMethodName
+    ) external returns (RequestId requestId);
+
+    /// @dev respond to oracle request by oracle compnent.
+    /// the response data is amende in the request info stored with the instance.
+    /// the request state changes to FULFILLED (when calling the callback method of the requester is successful)
+    /// or to FAILED when calling the requester is not succesful.
+    /// the function returns true iff the state changes to FULFILLED.
+    /// permissioned: only the oracle component linked to the request id may call this method
+    function respond(
+        RequestId requestId,
+        bytes calldata responseData
+    ) external returns (bool success);
+
+    /// @dev re send a failed response to the requester.
+    /// only requests in state FAILED may be re sent.
+    /// the request state changes to FULFILLED when calling the callback method of the requester is successful.
+    /// permissioned: only the requester may resend a request
+    function resend(RequestId requestId) external;
+
+    /// @dev notify the oracle component that the specified request has become invalid.
+    /// only requests in state ACTIVE may be cancelled.
+    /// permissioned: only the requester may cancel a request
+    function cancel(RequestId requestId) external;
+
+}