@etherisc/gif-next 0.0.2-dc95063-418 → 0.0.2-dd0e295-160

package/contracts/{instance/base → shared}/Lifecycle.sol

@@ -3,9 +3,9 @@ pragma solidity ^0.8.20;
 
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
-import {NftId} from "../../types/NftId.sol";
-import {ObjectType, COMPONENT, BUNDLE, POLICY, RISK} from "../../types/ObjectType.sol";
-import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, UNDERWRITTEN, REVOKED, DECLINED} from "../../types/StateId.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, COMPONENT, BUNDLE, POLICY, REQUEST, RISK, CLAIM, PAYOUT} from "../type/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID, FULFILLED, FAILED, CANCELLED} from "../type/StateId.sol";
 import {ILifecycle} from "./ILifecycle.sol";
 
 contract Lifecycle is
@@ -25,7 +25,9 @@ contract Lifecycle is
         _setupBundleLifecycle();
         _setupComponentLifecycle();
         _setupPolicyLifecycle();
+        _setupClaimAndPayoutLifecycle();
         _setupRiskLifecycle();
+        _setupRequestLifecycle();
     }
 
     function hasLifecycle(
@@ -95,15 +97,34 @@ contract Lifecycle is
         _initialState[POLICY()] = APPLIED();
         _isValidTransition[POLICY()][APPLIED()][REVOKED()] = true;
         _isValidTransition[POLICY()][APPLIED()][DECLINED()] = true;
-        _isValidTransition[POLICY()][APPLIED()][UNDERWRITTEN()] = true;
-        _isValidTransition[POLICY()][UNDERWRITTEN()][ACTIVE()] = true;
+        _isValidTransition[POLICY()][APPLIED()][COLLATERALIZED()] = true;
+        _isValidTransition[POLICY()][APPLIED()][ACTIVE()] = true;
+        _isValidTransition[POLICY()][COLLATERALIZED()][ACTIVE()] = true;
         _isValidTransition[POLICY()][ACTIVE()][CLOSED()] = true;
     }
 
+    function _setupClaimAndPayoutLifecycle() internal {
+        _initialState[CLAIM()] = SUBMITTED();
+        _isValidTransition[CLAIM()][SUBMITTED()][CONFIRMED()] = true;
+        _isValidTransition[CLAIM()][SUBMITTED()][DECLINED()] = true;
+        _isValidTransition[CLAIM()][CONFIRMED()][CLOSED()] = true;
+
+        _initialState[PAYOUT()] = EXPECTED();
+        _isValidTransition[PAYOUT()][EXPECTED()][PAID()] = true;
+    }
+
     function _setupRiskLifecycle() internal {
         _initialState[RISK()] = ACTIVE();
         _isValidTransition[RISK()][ACTIVE()][PAUSED()] = true;
         _isValidTransition[RISK()][PAUSED()][ACTIVE()] = true;
         _isValidTransition[RISK()][PAUSED()][ARCHIVED()] = true;
     }
+
+    function _setupRequestLifecycle() internal {
+        _initialState[REQUEST()] = ACTIVE();
+        _isValidTransition[REQUEST()][ACTIVE()][FULFILLED()] = true;
+        _isValidTransition[REQUEST()][ACTIVE()][FAILED()] = true;
+        _isValidTransition[REQUEST()][FAILED()][FULFILLED()] = true;
+        _isValidTransition[REQUEST()][ACTIVE()][CANCELLED()] = true;
+    }
 }

package/contracts/shared/NftIdSetManager.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {LibNftIdSet} from "../type/NftIdSet.sol";
+import {NftId} from "../type/NftId.sol";
+
+contract NftIdSetManager {
+
+    error ErrorNftIdSetManagerNotOwner(address owner, address sender);
+    error ErrorNftIdSetManagerOwnerAlreadySet(address owner);
+    error ErrorNftIdSetManagerNftIdInvalid(NftId objectNftId);
+    error ErrorNftIdSetManagerAlreadyAdded(NftId objectNftId);
+
+    LibNftIdSet.Set private _allObjects;
+    LibNftIdSet.Set private _activeObjects;
+    address private _owner;
+
+    modifier onlyOwner() {
+        if(msg.sender != _owner) {
+            revert ErrorNftIdSetManagerNotOwner(_owner, msg.sender);
+        }
+        _;
+    }
+
+    constructor() {
+        _owner = msg.sender;
+    }
+
+    function add(NftId objectNftId) external onlyOwner {
+        LibNftIdSet.add(_allObjects, objectNftId);
+        LibNftIdSet.add(_activeObjects, objectNftId);
+    }
+
+    function activate(NftId componentNftId, NftId objectNftId) external onlyOwner {
+        LibNftIdSet.add(_activeObjects, objectNftId);
+    }
+
+    function deactivate(NftId componentNftId, NftId objectNftId) external onlyOwner {
+        LibNftIdSet.remove(_activeObjects, objectNftId);
+    }
+
+    function nftIds() external view returns (uint256 ids) {
+        return LibNftIdSet.size(_allObjects);
+    }
+
+    function getNftId(uint256 idx) external view returns (NftId) {
+        return LibNftIdSet.getElementAt(_allObjects, idx);
+    }
+
+    function exists(NftId objectNftId) external view returns (bool) {
+        return LibNftIdSet.contains(_allObjects, objectNftId);
+    }
+
+    function activeNftIds() external view returns (uint256 ids) {
+        return LibNftIdSet.size(_activeObjects);
+    }
+
+    function getActiveNftId(uint256 idx) external view returns (NftId) {
+        return LibNftIdSet.getElementAt(_activeObjects, idx);
+    }
+
+    function isActive(NftId objectNftId) external view returns (bool) {
+        return LibNftIdSet.contains(_activeObjects, objectNftId);
+    }
+}

package/contracts/shared/NftOwnable.sol

@@ -1,11 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-// import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
-
 import {ERC165} from "./ERC165.sol";
 import {INftOwnable} from "./INftOwnable.sol";
-import {NftId} from "../types/NftId.sol";
+import {NftId} from "../type/NftId.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
 
 contract NftOwnable is
@@ -58,20 +56,9 @@ contract NftOwnable is
     function linkToRegisteredNftId()
         public
         virtual
+        returns (NftId nftId)
     {
-        NftOwnableStorage storage $ = _getNftOwnableStorage();
-
-        if ($._nftId.gtz()) {
-            revert ErrorNftOwnableAlreadyLinked($._nftId);
-        }
-
-        address contractAddress = address(this);
-
-        if (!getRegistry().isRegistered(contractAddress)) {
-            revert ErrorNftOwnableContractNotRegistered(contractAddress);
-        }
-
-        $._nftId = getRegistry().getNftId(contractAddress);
+        return _linkToNftOwnable(address(this));
     }
 
     function getNftId() public view virtual override returns (NftId) {

package/contracts/shared/PolicyHolder.sol

@@ -5,50 +5,69 @@ import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {ERC165} from "./ERC165.sol";
 import {IPolicyHolder} from "./IPolicyHolder.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId} from "../types/NftId.sol";
-import {NumberId} from "../types/NumberId.sol";
+import {NftId} from "../type/NftId.sol";
+import {PayoutId, PayoutIdLib} from "../type/PayoutId.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
 
 /// @dev template implementation for IPolicyHolder
 contract PolicyHolder is
     ERC165,
-    RegistryLinked,
+    RegistryLinked, // TODO need upgradeable version
     IPolicyHolder
 {
     // keccak256(abi.encode(uint256(keccak256("etherisc.storage.PolicyHolder")) - 1)) & ~bytes32(uint256(0xff));
     // TODO fix address
     bytes32 public constant POLICY_HOLDER_STORAGE_LOCATION_V1 = 0x07ebcf49758b6ed3af50fa146bec0abe157c0218fe65dc0874c286e9d5da4f00;
 
-    // TODO uncomment/fix/refactor
     struct PolicyHolderStorage {
-        // mapping(NftId policyId => mapping(NumberId claimId => address beneficiary)) private _claimBeneficiary;
-        // mapping(NftId policyId => address beneficiary) private _beneficiary;
-        bool dummy;
+        mapping(NftId policyId => mapping(PayoutId payoutId => address beneficiary)) _beneficiary;
+        address _beneficiaryDefault;
     }
 
     function initializePolicyHolder(
-        address registryAddress
+        address registryAddress,
+        address beneficiaryDefault
     )
         public
         virtual
         onlyInitializing()
     {
         initializeRegistryLinked(registryAddress);
+
+        _getPolicyHolderStorage()._beneficiaryDefault = beneficiaryDefault;
+
+        registerInterface(type(IPolicyHolder).interfaceId);
     }
 
     /// @dev empty default implementation
-    function policyCreatedCallback(NftId policyNftId) external virtual { }
+    function requestPayout(NftId requestingPolicyNftId, Amount requestedPayoutAmount) external { }
+
+    /// @dev empty default implementation
+    function policyActivated(NftId policyNftId) external {}
+
+    /// @dev empty default implementation
+    function policyExpired(NftId policyNftId) external {}
+
+    /// @dev empty default implementation
+    function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external {}
 
     /// @dev empty default implementation
-    function payoutExecutedCallback(NftId policyNftId, NumberId payoutId, address beneficiary, uint256 amount) external virtual { }
+    function payoutExecuted(NftId policyNftId, PayoutId payoutId, address beneficiary, Amount amount) external {}
+
+    /// @dev returns payout specific beneficiary
+    /// when no such beneficiary is defined the policy specific beneficiary is returned
+    function getBeneficiary(NftId policyNftId, PayoutId payoutId) external virtual view returns (address beneficiary) {
+        beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][payoutId];
 
-    /// @dev determines beneficiary address that will be used in payouts targeting this contract
-    /// returned address will override GIF default where the policy nft holder is treated as beneficiary
-    function getBeneficiary(NftId policyId, NumberId claimId) external virtual view returns (address beneficiary) { 
-        // TODO add implementation
+        // fallback to claim independent beneficiary
+        if(beneficiary == address(0) && payoutId.gtz()) {
+            beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][PayoutIdLib.zero()];
+        }
     }
 
     //--- IERC165 functions ---------------// 
@@ -65,12 +84,14 @@ contract PolicyHolder is
         return IERC721Receiver.onERC721Received.selector;
     }
 
-    function _setBeneficiary(address beneficiary) internal {
-
+    /// @dev sets policy specific beneficiary (used when no payout specific beneficiary is defined)
+    function _setBeneficiary(NftId policyNftId, address beneficiary) internal {
+        _setBeneficiary(policyNftId, PayoutIdLib.zero(), beneficiary);
     }
 
-    function _setBeneficiary(NftId policyId, address beneficiary) internal {
-
+    /// @dev sets policy and claim specific beneficiary
+    function _setBeneficiary(NftId policyNftId, PayoutId payoutId, address beneficiary) internal {
+        _getPolicyHolderStorage()._beneficiary[policyNftId][payoutId] = beneficiary;
     }
 
     function _getPolicyHolderStorage() private pure returns (PolicyHolderStorage storage $) {

package/contracts/shared/ProxyManager.sol

@@ -3,14 +3,15 @@ pragma solidity ^0.8.20;
 
 import {ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
-import {Blocknumber, blockNumber} from "../types/Blocknumber.sol";
+import {Blocknumber, blockNumber} from "../type/Blocknumber.sol";
 import {IVersionable} from "./IVersionable.sol";
 import {NftOwnable} from "./NftOwnable.sol";
 import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
 import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
-import {Timestamp, TimestampLib} from "../types/Timestamp.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
 import {UpgradableProxyWithAdmin} from "./UpgradableProxyWithAdmin.sol";
-import {Version, VersionLib} from "../types/Version.sol";
+import {Version, VersionLib} from "../type/Version.sol";
+import {NftId} from "../type/NftId.sol";
 
 /// @dev manages proxy deployments for upgradable contracs of type IVersionable
 contract ProxyManager is
@@ -79,6 +80,31 @@ contract ProxyManager is
         emit LogProxyManagerVersionableDeployed(address(_proxy), initialImplementation);
     }
 
+    function deployDetermenistic(address initialImplementation, bytes memory initializationData, bytes32 salt)
+        public
+        virtual
+        onlyOwner()
+        returns (IVersionable versionable)
+    {
+        if (_versions.length > 0) {
+            revert ErrorProxyManagerAlreadyDeployed();
+        }
+
+        address currentProxyOwner = getOwner();
+        address initialProxyAdminOwner = address(this);
+
+        _proxy = new UpgradableProxyWithAdmin{salt: salt}(
+            initialImplementation,
+            initialProxyAdminOwner,
+            getDeployData(currentProxyOwner, initializationData)
+        );
+
+        versionable = IVersionable(address(_proxy));
+        _updateVersionHistory(versionable.getVersion(), initialImplementation, currentProxyOwner);
+
+        emit LogProxyManagerVersionableDeployed(address(_proxy), initialImplementation);
+    }
+
     /// @dev upgrade existing contract
     function upgrade(address newImplementation, bytes memory upgradeData)
         public
@@ -106,6 +132,10 @@ contract ProxyManager is
 
     }
 
+    function linkToProxy() public returns (NftId) {
+        return _linkToNftOwnable(address(_proxy));
+    }
+
     function getDeployData(address proxyOwner, bytes memory deployData) public pure returns (bytes memory data) {
         return abi.encodeWithSelector(
             IVersionable.initializeVersionable.selector, 
@@ -119,7 +149,7 @@ contract ProxyManager is
             upgradeData);
     }
 
-    function getProxy() public returns (UpgradableProxyWithAdmin) {
+    function getProxy() public view returns (UpgradableProxyWithAdmin) {
         return _proxy;
     }
 

package/contracts/shared/Registerable.sol

@@ -3,13 +3,12 @@ pragma solidity ^0.8.20;
 
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
-import {NftId, zeroNftId} from "../types/NftId.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
 import {NftOwnable} from "../shared/NftOwnable.sol";
-import {ObjectType} from "../types/ObjectType.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegisterable} from "./IRegisterable.sol";
-import {Versionable} from "./Versionable.sol";
 
 contract Registerable is
     NftOwnable,
@@ -25,12 +24,6 @@ contract Registerable is
         bytes _data;
     }
 
-    function _getRegisterableStorage() private pure returns (RegisterableStorage storage $) {
-        assembly {
-            $.slot := REGISTERABLE_LOCATION_V1
-        }
-    }
-
     function initializeRegisterable(
         address registryAddress,
         NftId parentNftId,
@@ -47,7 +40,11 @@ contract Registerable is
             initialOwner,
             registryAddress);
 
-        RegisterableStorage storage $ = _getRegisterableStorage();
+        RegisterableStorage storage $;
+        assembly {
+            $.slot := REGISTERABLE_LOCATION_V1
+        }
+
         $._parentNftId = parentNftId;
         $._objectType = objectType;
         $._isInterceptor = isInterceptor;
@@ -61,9 +58,13 @@ contract Registerable is
         virtual 
         returns (IRegistry.ObjectInfo memory info) 
     {
-        RegisterableStorage memory $ = _getRegisterableStorage();
+        RegisterableStorage storage $;
+        assembly {
+            $.slot := REGISTERABLE_LOCATION_V1
+        }
+
         info = IRegistry.ObjectInfo(
-            zeroNftId(),
+            NftIdLib.zero(),
             $._parentNftId,
             $._objectType,
             $._isInterceptor,

package/contracts/shared/RegistryLinked.sol

@@ -40,9 +40,4 @@ contract RegistryLinked is
     function getRegistry() public view returns (IRegistry) {
         return _registry;
     }
-
-
-    function getRegistryAddress() public view returns (address) {
-        return address(_registry);
-    }
 }

package/contracts/shared/Service.sol

@@ -1,44 +1,34 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {ObjectType, SERVICE} from "../types/ObjectType.sol";
-import {NftId, zeroNftId} from "../types/NftId.sol";
-import {Version, VersionPart, VersionLib, VersionPartLib} from "../types/Version.sol";
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
-import {Versionable} from "./Versionable.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
 import {IService} from "./IService.sol";
 import {IVersionable} from "./IVersionable.sol";
-import {Versionable} from "./Versionable.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, REGISTRY, SERVICE} from "../type/ObjectType.sol";
 import {Registerable} from "./Registerable.sol";
-
-import {IRegistry} from "../registry/IRegistry.sol";
+import {RoleId, RoleIdLib} from "../type/RoleId.sol";
+import {Version, VersionPart, VersionLib, VersionPartLib} from "../type/Version.sol";
+import {Versionable} from "./Versionable.sol";
 
 
 /// @dev service base contract
 abstract contract Service is 
     Registerable,
     Versionable,
+    AccessManagedUpgradeable,
     IService
 {
-    function getDomain() public pure virtual override returns(ObjectType);
 
-    // version major version MUST be consistent with major version of getVersion()
-    function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
-        return VersionPartLib.toVersionPart(3); 
-    }
+    uint8 private constant GIF_MAJOR_VERSION = 3;
 
-    // from Versionable
-    function getVersion()
-        public 
-        pure 
-        virtual override (IVersionable, Versionable)
-        returns(Version)
-    {
-        return VersionLib.toVersion(3,0,0);
-    }
 
     function initializeService(
         address registry, 
+        address authority, // real authority for registry service adress(0) for other services
         address initialOwner
     )
         public
@@ -53,6 +43,41 @@ abstract contract Service is
             initialOwner, 
             ""); // data
 
+        // externally provided authority
+        if(authority != address(0)) {
+            __AccessManaged_init(authority);
+        } else {
+            address registryServiceAddress = _getServiceAddress(REGISTRY());
+
+            // copy authority from already registered registry services
+            __AccessManaged_init(IAccessManaged(registryServiceAddress).authority());
+        }
+
+        registerInterface(type(IAccessManaged).interfaceId);
         registerInterface(type(IService).interfaceId);
     }
+
+    function getDomain() external virtual pure returns(ObjectType serviceDomain) {
+        return _getDomain();
+    }
+
+    function getRoleId() external virtual pure returns(RoleId serviceRoleId) {
+        return RoleIdLib.roleForTypeAndVersion(_getDomain(), VersionPartLib.toVersionPart(GIF_MAJOR_VERSION));
+    }
+
+    // from Versionable
+    function getVersion()
+        public 
+        pure 
+        virtual override (IVersionable, Versionable)
+        returns(Version)
+    {
+        return VersionLib.toVersion(GIF_MAJOR_VERSION,0,0);
+    }
+
+    function _getDomain() internal virtual pure returns (ObjectType);
+
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, VersionPartLib.toVersionPart(GIF_MAJOR_VERSION));
+    }
 }

package/contracts/shared/TokenHandler.sol

@@ -4,7 +4,10 @@ pragma solidity ^0.8.20;
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
+import {Amount} from "../type/Amount.sol";
+
 /// @dev token specific transfer helper
+/// a default token contract is provided via contract constructor
 /// relies internally on oz SafeERC20.safeTransferFrom
 contract TokenHandler {
     IERC20Metadata private _token;
@@ -13,16 +16,38 @@ contract TokenHandler {
         _token = IERC20Metadata(token);
     }
 
+    /// @dev transfer amount default tokens 
     function transfer(
         address from,
         address to,
-        uint256 amount
+        Amount amount
+    )
+        external
+    {
+        SafeERC20.safeTransferFrom(
+            _token, 
+            from, 
+            to, 
+            amount.toInt());
+    }
+
+    /// @dev transfer amount of the specified token
+    function safeTransferFrom(
+        address token,
+        address from,
+        address to,
+        Amount amount
     )
         external
     {
-        SafeERC20.safeTransferFrom(_token, from, to, amount);
+        SafeERC20.safeTransferFrom(
+            IERC20Metadata(token), 
+            from, 
+            to, 
+            amount.toInt());
     }
 
+    /// @dev returns the default token defined for this TokenHandler
     function getToken()
         external
         view 

package/contracts/shared/Versionable.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.20;
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 import {IVersionable} from "./IVersionable.sol";
-import {Version, VersionLib} from "../types/Version.sol";
+import {Version, VersionLib} from "../type/Version.sol";
 
 
 abstract contract Versionable is