@etherisc/gif-next 0.0.2-ceb30b2-601 → 0.0.2-cf22d7b-845

package/contracts/shared/InitializableCustom.sol

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+/**
+ * @dev This is copy of OpenZeppelin's Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
+ * Changes:
+ * 1. name is InitializableCustom
+ * 2. no longer abstract
+ * 3. have $._initializeOwner
+ * 4. have constructor where sets _initializeOwner 
+ * 5. initializer() in addition checks for _initializeOwner
+ * 6. reinitializer() is deleted
+ */
+abstract contract InitializableCustom {
+    /**
+     * @dev Storage of the initializable contract.
+     *
+     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
+     * when using with upgradeable contracts.
+     *
+     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
+     */
+    struct InitializableCustomStorage {
+        /**
+         * @dev Indicates that the contract has been initialized.
+         */
+        uint64 _initialized;
+        /**
+         * @dev Indicates that the contract is in the process of being initialized.
+         */
+        bool _initializing;
+        /**
+         * @dev Indicates address that can call function with initializer() modifier.
+         */
+        address _initializeOwner;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.InitializableCustom")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant INITIALIZABLE_CUSTOM_STORAGE = 0x46cd1d813423aaf613c34c7f348d15b2b5e71215e9145b09467e257ea2805a00;
+
+    /**
+     * @dev The contract is already initialized.
+     */
+    error InvalidInitialization();
+
+    /**
+     * @dev The contract initialization function caller is not authorized.
+     */
+    error InvalidInitializationCaller();
+
+    /**
+     * @dev The contract is not initializing.
+     */
+    error NotInitializing();
+
+    /**
+     * @dev Triggered when the contract has been initialized or reinitialized.
+     */
+    event Initialized(uint64 version);
+
+    /**
+     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
+     * `onlyInitializing` functions can be used to initialize parent contracts.
+     *
+     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
+     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
+     * production.
+     *
+     * Emits an {Initialized} event.
+     */
+    modifier initializer() virtual {
+        // solhint-disable-next-line var-name-mixedcase
+        InitializableCustomStorage storage $ = _getInitializableCustomStorage();
+
+        if($._initializeOwner != msg.sender) {
+            revert InvalidInitializationCaller();
+        }
+
+        // Cache values to avoid duplicated sloads
+        bool isTopLevelCall = !$._initializing;
+        uint64 initialized = $._initialized;
+
+        // Allowed calls:
+        // - initialSetup: the contract is not in the initializing state and no previous version was
+        //                 initialized
+        // - construction: the contract is initialized at version 1 (no reininitialization) and the
+        //                 current contract is just being deployed
+        bool initialSetup = initialized == 0 && isTopLevelCall;
+        bool construction = initialized == 1 && address(this).code.length == 0;
+
+        if (!initialSetup && !construction) {
+            revert InvalidInitialization();
+        }
+        $._initialized = 1;
+        if (isTopLevelCall) {
+            $._initializing = true;
+        }
+        _;
+        if (isTopLevelCall) {
+            $._initializing = false;
+            emit Initialized(1);
+        }
+    }
+
+    /**
+     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
+     * {initializer} and {reinitializer} modifiers, directly or indirectly.
+     */
+    modifier onlyInitializing() {
+        _checkInitializing();
+        _;
+    }
+
+    /**
+     * @dev Constructor sets the caller of protected initializer function.
+    */
+    constructor() {
+        // solhint-disable-previous-line var-name-mixedcase
+        InitializableCustomStorage storage $ = _getInitializableCustomStorage();
+        $._initializeOwner = msg.sender;
+    }
+
+    /**
+     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
+     */
+    function _checkInitializing() internal view virtual {
+        if (!_isInitializing()) {
+            revert NotInitializing();
+        }
+    }
+
+    /**
+     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
+     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
+     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
+     * through proxies.
+     *
+     * Emits an {Initialized} event the first time it is successfully executed.
+     */
+    function _disableInitializers() internal virtual {
+        // solhint-disable-next-line var-name-mixedcase
+        InitializableCustomStorage storage $ = _getInitializableCustomStorage();
+
+        if ($._initializing) {
+            revert InvalidInitialization();
+        }
+        if ($._initialized != type(uint64).max) {
+            $._initialized = type(uint64).max;
+            emit Initialized(type(uint64).max);
+        }
+    }
+
+    /**
+     * @dev Returns the highest version that has been initialized. See {reinitializer}.
+     */
+    function _getInitializedVersion() internal view returns (uint64) {
+        return _getInitializableCustomStorage()._initialized;
+    }
+
+    /**
+     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
+     */
+    function _isInitializing() internal view returns (bool) {
+        return _getInitializableCustomStorage()._initializing;
+    }
+
+    /**
+     * @dev Returns a pointer to the storage namespace.
+     */
+    // solhint-disable-next-line var-name-mixedcase
+    function _getInitializableCustomStorage() private pure returns (InitializableCustomStorage storage $) {
+        assembly {
+            $.slot := INITIALIZABLE_CUSTOM_STORAGE
+        }
+    }
+}

package/contracts/shared/InstanceLinkedComponent.sol

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import {Component} from "./Component.sol";
+import {IComponentService} from "./IComponentService.sol";
+import {IInstanceLinkedComponent} from "./IInstanceLinkedComponent.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {InstanceAdmin} from "../instance/InstanceAdmin.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, COMPONENT, INSTANCE} from "../type/ObjectType.sol";
+import {VersionPart} from "../type/Version.sol";
+import {RoleId, RoleIdLib} from "../type/RoleId.sol";
+import {IAccess} from "../instance/module/IAccess.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {VersionPart} from "../type/Version.sol";
+
+// then add (Distribution|Pool|Product)Upradeable that also intherit from Versionable
+// same pattern as for Service which is also upgradeable
+abstract contract InstanceLinkedComponent is
+    Component,
+    IInstanceLinkedComponent
+{
+    // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.component.Component.sol")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant INSTANCE_LINKED_COMPONENT_LOCATION_V1 = 0xffe3d4462bded26a47154f4b8f6db494d2f772496965791d25bd456e342b7f00;
+
+    struct InstanceLinkedComponentStorage {
+        IInstance _instance; // instance for this component
+        InstanceReader _instanceReader; // instance reader for this component
+    }
+
+    function _getInstanceLinkedComponentStorage() private pure returns (InstanceLinkedComponentStorage storage $) {
+        assembly {
+            $.slot := INSTANCE_LINKED_COMPONENT_LOCATION_V1
+        }
+    }
+
+    function initializeInstanceLinkedComponent(
+        address registry,
+        NftId instanceNftId,
+        string memory name,
+        address token,
+        ObjectType componentType,
+        bool isInterceptor,
+        address initialOwner,
+        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
+        bytes memory componentData // data that will saved with the component info in the instance store
+    )
+        public
+        virtual
+        onlyInitializing()
+    {
+        // set and check linked instance
+        InstanceLinkedComponentStorage storage $ = _getInstanceLinkedComponentStorage();
+        $._instance = IInstance(
+            IRegistry(registry).getObjectInfo(
+                instanceNftId).objectAddress);
+
+        if(!$._instance.supportsInterface(type(IInstance).interfaceId)) {
+            revert ErrorComponentNotInstance(instanceNftId);
+        }
+
+        initializeComponent(
+            $._instance.authority(), 
+            registry, 
+            instanceNftId, 
+            name, 
+            token,
+            componentType, 
+            isInterceptor, 
+            initialOwner, 
+            registryData,
+            componentData);
+
+        // set component state
+        $._instanceReader = $._instance.getInstanceReader();
+
+        registerInterface(type(IAccessManaged).interfaceId);
+        registerInterface(type(IInstanceLinkedComponent).interfaceId);
+    }
+
+    /// @dev for instance linked components the wallet address stored in the instance store.
+    /// updating needs to go throug component service
+    function _setWallet(address newWallet) internal virtual override onlyOwner {
+        IComponentService(_getServiceAddress(COMPONENT())).setWallet(newWallet);
+    }
+
+    function lock() external onlyOwner {
+        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(true);
+    }
+    
+    function unlock() external onlyOwner {
+        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(false);
+    }
+
+    function getInstance() public view override returns (IInstance instance) {
+        return _getInstanceLinkedComponentStorage()._instance;
+    }
+
+    function getProductNftId() public view override returns (NftId productNftId) {
+        return getComponentInfo().productNftId;
+    }
+
+
+    function _getComponentInfo() internal virtual override view returns (IComponents.ComponentInfo memory info) {
+        NftId componentNftId = getRegistry().getNftId(address(this));
+
+        // if registered, attempt to return component info via instance reader
+        if (componentNftId.gtz()) {
+            // component registerd with registry
+            info = _getInstanceReader().getComponentInfo(getNftId());
+
+            // check if also registered with instance
+            if (info.wallet != address(0)) {
+                return info;
+            }
+        }
+
+        // return data from component contract if not yet registered
+        return super._getComponentInfo();
+    }
+
+
+    /// @dev returns reader for linked instance
+    function _getInstanceReader() internal view returns (InstanceReader reader) {
+        return _getInstanceLinkedComponentStorage()._instanceReader;
+    }
+
+
+    /// @dev returns the service address for the specified domain
+    /// gets address via lookup from registry using the major version form the linked instance
+    function _getServiceAddress(ObjectType domain) internal view returns (address service) {
+        VersionPart majorVersion = _getInstanceLinkedComponentStorage()._instance.getMajorVersion();
+        return getRegistry().getServiceAddress(domain, majorVersion);
+    }
+}

package/contracts/shared/KeyValueStore.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../type/Blocknumber.sol";
+import {Key32, KeyId, Key32Lib} from "../type/Key32.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {StateId, ACTIVE, KEEP_STATE} from "../type/StateId.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
+
+import {Lifecycle} from "./Lifecycle.sol";
+import {IKeyValueStore} from "./IKeyValueStore.sol";
+
+contract KeyValueStore is
+    Lifecycle, 
+    IKeyValueStore
+{
+
+    mapping(Key32 key32 => Value value) private _value;
+
+    function _create(
+        Key32 key32, 
+        bytes memory data
+    )
+        internal
+    {
+        ObjectType objectType = key32.toObjectType();
+        if (objectType.eqz()) {
+            revert ErrorKeyValueStoreTypeUndefined(objectType);
+        }
+
+        Metadata storage metadata = _value[key32].metadata;
+        if (metadata.state.gtz()) {
+            revert ErrorKeyValueStoreAlreadyCreated(key32, objectType);
+        }
+
+        Blocknumber blocknumber = blockBlocknumber();
+        StateId initialState = hasLifecycle(objectType) ? getInitialState(objectType) : ACTIVE();
+
+        // set metadata
+        metadata.objectType = objectType;
+        metadata.state = initialState;
+        metadata.updatedIn = blocknumber;
+        metadata.createdIn = blocknumber;
+
+        // set data
+        _value[key32].data = data;
+
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogInfoCreated(key32.toObjectType(), key32.toKeyId(), initialState, msg.sender, tx.origin);
+    }
+
+
+    function _update(
+        Key32 key32, 
+        bytes memory data,
+        StateId state
+    ) 
+        internal
+    {
+        // update state
+        Blocknumber lastUpdatedIn = _updateState(key32, state);
+
+        // update data
+        _value[key32].data = data;
+
+        // solhint-disable-next-line avoid-tx-origin
+        emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, msg.sender, tx.origin, lastUpdatedIn);
+    }
+
+
+    function _updateState(
+        Key32 key32, 
+        StateId state
+    )
+        internal
+        returns (Blocknumber lastUpdatedIn)
+    {
+        if (state.eqz()) {
+            revert ErrorKeyValueStoreStateZero(key32);
+        }
+
+        Metadata storage metadata = _value[key32].metadata;
+        StateId stateOld = metadata.state;
+        lastUpdatedIn = metadata.updatedIn;
+
+        if (stateOld.eqz()) {
+            revert ErrorKeyValueStoreNotExisting(key32);
+        }
+
+        // update state 
+        if(state != KEEP_STATE()) {
+            checkTransition(metadata.objectType, stateOld, state);
+            metadata.state = state;
+
+            // solhint-disable-next-line avoid-tx-origin
+            emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), stateOld, state, msg.sender, tx.origin, lastUpdatedIn);
+        }
+
+        // update metadata
+        metadata.updatedIn = blockBlocknumber();
+    }
+
+    function exists(Key32 key32) public view returns (bool) {
+        return _value[key32].metadata.state.gtz();
+    }
+
+    function get(Key32 key32) public view returns (Value memory value) {
+        return _value[key32];
+    }
+
+    function getMetadata(Key32 key32) public view returns (Metadata memory metadata) {
+        return _value[key32].metadata;
+    }
+
+    function getData(Key32 key32) public view returns (bytes memory data) {
+        return _value[key32].data;
+    }
+
+    function getState(Key32 key32) public view returns (StateId state) {
+        return _value[key32].metadata.state;
+    }
+
+    function toKey32(ObjectType objectType, KeyId id) external pure override returns(Key32) {
+        return Key32Lib.toKey32(objectType, id);
+    }
+}

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, CLAIM} from "../../types/ObjectType.sol";
-import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED} from "../../types/StateId.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, COMPONENT, BUNDLE, POLICY, RISK, CLAIM, PAYOUT} from "../type/ObjectType.sol";
+import {StateId, ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID} from "../type/StateId.sol";
 import {ILifecycle} from "./ILifecycle.sol";
 
 contract Lifecycle is
@@ -25,7 +25,7 @@ contract Lifecycle is
         _setupBundleLifecycle();
         _setupComponentLifecycle();
         _setupPolicyLifecycle();
-        _setupClaimLifecycle();
+        _setupClaimAndPayoutLifecycle();
         _setupRiskLifecycle();
     }
 
@@ -97,15 +97,19 @@ contract Lifecycle is
         _isValidTransition[POLICY()][APPLIED()][REVOKED()] = true;
         _isValidTransition[POLICY()][APPLIED()][DECLINED()] = true;
         _isValidTransition[POLICY()][APPLIED()][COLLATERALIZED()] = true;
+        _isValidTransition[POLICY()][APPLIED()][ACTIVE()] = true;
         _isValidTransition[POLICY()][COLLATERALIZED()][ACTIVE()] = true;
         _isValidTransition[POLICY()][ACTIVE()][CLOSED()] = true;
     }
 
-    function _setupClaimLifecycle() internal {
+    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 {

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

@@ -3,7 +3,7 @@ pragma solidity ^0.8.20;
 
 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
@@ -56,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,41 +5,48 @@ 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 "../types/Amount.sol";
-import {ClaimId} from "../types/ClaimId.sol";
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
 import {ERC165} from "./ERC165.sol";
 import {IPolicyHolder} from "./IPolicyHolder.sol";
-import {NftId} from "../types/NftId.sol";
-import {PayoutId} from "../types/PayoutId.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 requestPayout(NftId requestingPolicyNftId, Amount requestedPayoutAmount) external { }
+
     /// @dev empty default implementation
     function policyActivated(NftId policyNftId) external {}
 
@@ -52,9 +59,15 @@ contract PolicyHolder is
     /// @dev empty default implementation
     function payoutExecuted(NftId policyNftId, PayoutId payoutId, address beneficiary, Amount amount) external {}
 
-    /// @dev returns current policy nft holder
-    function getBeneficiary(NftId policyNftId, ClaimId claimId) external virtual view returns (address beneficiary) { 
-        return getRegistry().ownerOf(policyNftId);
+    /// @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];
+
+        // fallback to claim independent beneficiary
+        if(beneficiary == address(0) && payoutId.gtz()) {
+            beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][PayoutIdLib.zero()];
+        }
     }
 
     //--- IERC165 functions ---------------// 
@@ -71,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 $) {