@etherisc/gif-next 0.0.2-d5b7b78-706 → 0.0.2-d5fac82-078

package/contracts/{components → shared}/Component.sol

@@ -1,25 +1,26 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 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 {IComponent} from "./IComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
-import {IProductService} from "../instance/service/IProductService.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IInstance} from "../instance/IInstance.sol";
-import {InstanceAccessManager} from "../instance/InstanceAccessManager.sol";
+import {InstanceAdmin} from "../instance/InstanceAdmin.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId} from "../types/NftId.sol";
-import {ObjectType, INSTANCE, PRODUCT} from "../types/ObjectType.sol";
-import {VersionPart} from "../types/Version.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, INSTANCE, PRODUCT} from "../type/ObjectType.sol";
+import {VersionPart} from "../type/Version.sol";
 import {Registerable} from "../shared/Registerable.sol";
-import {RoleId, RoleIdLib} from "../types/RoleId.sol";
+import {RoleId, RoleIdLib} from "../type/RoleId.sol";
 import {IAccess} from "../instance/module/IAccess.sol";
-import {VersionPart} from "../types/Version.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {VersionPart} from "../type/Version.sol";
 
 // TODO discuss to inherit from oz accessmanaged
 // then add (Distribution|Pool|Product)Upradeable that also intherit from Versionable
@@ -90,17 +91,32 @@ abstract contract Component is
         $._wallet = address(this);
         $._token = IERC20Metadata(token);
 
+        registerInterface(type(IAccessManaged).interfaceId);
         registerInterface(type(IComponent).interfaceId);
     }
 
-    function lock() external onlyOwner override {
+    function lock() external onlyOwner {
         IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(true);
     }
     
-    function unlock() external onlyOwner override {
+    function unlock() external onlyOwner {
         IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(false);
     }
 
+    function approveTokenHandler(uint256 spendingLimitAmount) external onlyOwner {
+        IComponents.ComponentInfo memory info = getComponentInfo();
+
+        if(info.wallet != address(this)) {
+            revert ErrorComponentWalletNotComponent();
+        }
+
+        info.token.approve(
+            address(info.tokenHandler),
+            spendingLimitAmount);
+
+        emit LogComponentTokenHandlerApproved(spendingLimitAmount);
+    }
+
     function setWallet(address newWallet)
         external
         override
@@ -195,6 +211,10 @@ abstract contract Component is
         return _getComponentStorage()._token;
     }
 
+    function getTokenHandler() public view returns (TokenHandler tokenHandler) {
+        return getComponentInfo().tokenHandler;
+    }
+
     function isNftInterceptor() public view override returns(bool isInterceptor) {
         return _getComponentStorage()._isNftInterceptor;
     }

package/contracts/shared/ComponentService.sol

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IComponent} from "./IComponent.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IRegistryService} from "../registry/IRegistryService.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {IAccess} from "../instance/module/IAccess.sol";
+import {ObjectType, INSTANCE, REGISTRY} from "../type/ObjectType.sol";
+import {NftId} from "../type/NftId.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+import {Service} from "../shared/Service.sol";
+import {InstanceService} from "../instance/InstanceService.sol";
+import {InstanceAdmin} from "../instance/InstanceAdmin.sol";
+
+abstract contract ComponentService is
+    Service
+{
+
+    error ErrorComponentServiceNotComponent(address component);
+    error ErrorComponentServiceInvalidType(address component, ObjectType requiredType, ObjectType componentType);
+    error ErrorComponentServiceSenderNotOwner(address component, address initialOwner, address sender);
+    error ErrorComponentServiceExpectedRoleMissing(NftId instanceNftId, RoleId requiredRole, address sender);
+    error ErrorComponentServiceComponentLocked(address component);
+    error ErrorComponentServiceSenderNotService(address sender);
+    error ErrorComponentServiceComponentTypeInvalid(address component, ObjectType expectedType, ObjectType foundType);
+
+    // view functions
+
+    function getRegistryService() public view virtual returns (IRegistryService) {
+        return IRegistryService(_getServiceAddress(REGISTRY()));
+    }
+
+    function getInstanceService() public view returns (InstanceService) {
+        return InstanceService(_getServiceAddress(INSTANCE()));
+    }
+
+    // internal functions
+    function _checkComponentForRegistration(
+        address componentAddress,
+        ObjectType requiredType,
+        RoleId requiredRole
+    )
+        internal
+        view
+        returns (
+            IComponent component,
+            address owner,
+            IInstance instance,
+            NftId instanceNftId
+        )
+    {
+        // component may only be registerd by initial owner of component
+        owner = msg.sender;
+
+        // check this is a component
+        component = IComponent(componentAddress);
+        if(!component.supportsInterface(type(IComponent).interfaceId)) {
+            revert ErrorComponentServiceNotComponent(componentAddress);
+        }
+
+        // check component is of required type
+        IRegistry.ObjectInfo memory componentInfo = component.getInitialInfo();
+        if(componentInfo.objectType != requiredType) {
+            revert ErrorComponentServiceInvalidType(componentAddress, requiredType, componentInfo.objectType);
+        }
+
+        // check msg.sender is component owner
+        address initialOwner = componentInfo.initialOwner;
+        if(owner != initialOwner) {
+            revert ErrorComponentServiceSenderNotOwner(componentAddress, componentInfo.initialOwner, owner);
+        }
+
+        // check instance has assigned required role to owner
+        instanceNftId = componentInfo.parentNftId;
+        instance = _getInstance(instanceNftId);
+        if(!instance.getInstanceAdmin().hasRole(requiredRole, owner)) {
+            revert ErrorComponentServiceExpectedRoleMissing(instanceNftId, requiredRole, owner);
+        }
+    }
+
+    // internal view functions
+    function _getAndVerifyCallingComponentAndInstance(
+        ObjectType expectedType // assume always of `component` type
+    )
+        internal
+        view
+        returns(
+            NftId componentNftId,
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        )
+    {
+        componentNftId = getRegistry().getNftId(msg.sender);
+        (componentInfo, instance) = _getAndVerifyComponentInfoAndInstance(componentNftId, expectedType);
+
+        // locked component can not call services
+        if (instance.getInstanceAdmin().isTargetLocked(componentInfo.objectAddress)) {
+            revert IAccess.ErrorIAccessTargetLocked(componentInfo.objectAddress);
+        }
+    }
+
+    function _getAndVerifyComponentInfoAndInstance(
+        NftId componentNftId,
+        ObjectType expectedType // assume always of `component` type
+    )
+        internal
+        view
+        returns(
+            IRegistry.ObjectInfo memory componentInfo, 
+            IInstance instance
+        )
+    {
+        componentInfo = getRegistry().getObjectInfo(componentNftId);
+        if(componentInfo.objectType != expectedType) {
+            revert ErrorComponentServiceComponentTypeInvalid(
+                componentInfo.objectAddress, 
+                expectedType, 
+                componentInfo.objectType);
+        }
+
+        instance = _getInstance(componentInfo.parentNftId);
+    }
+    // assume componentNftId is always of `instance` type
+    function _getInstance(NftId instanceNftId) internal view returns (IInstance) {
+        return IInstance(
+            getRegistry().getObjectInfo(
+                instanceNftId).objectAddress);
+    }
+    // assume componentNftId is always of `component` type
+    /*function _getInstanceForComponent(NftId componentNftId) internal view returns (IInstance) {
+        NftId instanceNftId = getRegistry().getObjectInfo(componentNftId).parentNftId;
+        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        return IInstance(instanceAddress);
+    }*/
+
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, getVersion().toMajorPart());
+    }
+}

package/contracts/shared/IAccessManagerExtended.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAccessManager.sol)
+
+pragma solidity ^0.8.20;
+
+import {IAccessManager} from "@openzeppelin/contracts/access/manager/IAccessManager.sol";
+
+import {Timestamp} from "../type/Timestamp.sol";
+
+interface IAccessManagerExtended is IAccessManager {
+    // Structure that stores the details for a target contract.
+    struct TargetInfo {
+        address taddress;
+        //IAccess.Type ttype;
+        string name;
+        Timestamp createdAt;
+        //Timestamp updatedAt;
+    }
+
+    // Structure that stores the details of a role.
+    struct RoleInfo {
+        uint64 id;
+        //IAccess.Type rtype;
+        string name;
+        Timestamp createdAt;
+    }
+
+    event LogRoleCreation(uint64 roleId, string name);// IAccess.Type rtype);
+    event LogTargetCreation(address target, string name);// IAccess.Type ttype);
+
+    error AccessManagerRoleIdNotExists(uint64 roleId);
+    error AccessManagerRoleIdAlreadyExists(uint64 roleId);
+    error AccessManagerRoleNameAlreadyExists(uint64 newRoleId, uint64 existingRoleId, string duplicateName);
+    error AccessManagerRoleIdZero();
+    error AccessManagerRoleNameEmpty(uint64 roleId);
+    error AccessManagerRoleIdTooBig(uint64 roleId);
+
+    error AccessManagerTargetAlreadyExists(address target);
+    error AccessManagerTargetNotExists(address target);
+    error AccessManagerTargetNameAlreadyExists(address newTarget, address existingTarget, string duplicateName);
+    error AccessManagerTargetAddressZero();
+    error AccessManagerTargetNameEmpty(address target);
+    error AccessManagerTargetAuthorityInvalid(address target, address targetAuthority);
+
+    function getRoleMembers(uint64 roleId) external view returns (uint256 numberOfMembers);
+
+    function getRoleMember(uint64 roleId, uint256 idx) external view returns (address member);
+
+    function getRoleId(uint256 idx) external view returns (uint64 roleId);
+
+    // TODO returns ADMIN_ROLE id for non existent name
+    function getRoleId(string memory name) external view returns (uint64 roleId);
+
+    function getRoles() external view returns (uint256 numberOfRoles);
+
+    function isRoleExists(uint64 roleId) external view returns (bool exists);
+
+    function getRoleInfo(uint64 roleId) external view returns (RoleInfo memory);
+
+    function isRoleNameExists(string memory name) external view returns (bool);
+
+    function isTargetExists(address target) external view returns (bool);
+
+    function isTargetNameExists(string memory name) external view returns (bool);
+    
+    function getTargetAddress(string memory name) external view returns(address targetAddress);
+
+    function getTargetInfo(address target) external view returns (TargetInfo memory);
+
+
+    function createRole(uint64 roleId, string memory roleName/*, IAccess.Type rtype*/) external;
+
+    function createTarget(address target, string memory name/*, IAccess.Type.Custom*/) external;
+}

package/contracts/shared/IAccessManagerExtendedWithDisable.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {IAccessManagerExtended} from "./IAccessManagerExtended.sol";
+
+import {Timestamp} from "../type/Timestamp.sol";
+import {VersionPart} from "../type/Version.sol";
+
+interface IAccessManagerExtendedWithDisable is IAccessManagerExtended {
+
+    error AccessManagerDisabled();
+
+    function disable() external;
+    function enable() external;
+    function getVersion() external view returns (VersionPart version);
+}

package/contracts/{components → shared}/IComponent.sol

@@ -1,22 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IInstance} from "../instance/IInstance.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
-import {IProductService} from "../instance/service/IProductService.sol";
+import {IProductService} from "../product/IProductService.sol";
 import {IRegisterable} from "../shared/IRegisterable.sol";
 import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
-import {NftId} from "../types/NftId.sol";
-import {ObjectType} from "../types/ObjectType.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType} from "../type/ObjectType.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
 
 /// @dev component base class
 /// component examples are product, distribution, pool and oracle
 interface IComponent is 
     IRegisterable,
-    ITransferInterceptor
+    ITransferInterceptor,
+    IAccessManaged
 {
     error ErrorComponentNotChainNft(address caller);
     error ErrorComponentNotProductService(address caller);
@@ -27,9 +30,13 @@ interface IComponent is
     error ErrorComponentWalletAddressIsSameAsCurrent();
     error ErrorComponentWalletAllowanceTooSmall(address oldWallet, address newWallet, uint256 allowance, uint256 balance);
 
+    error ErrorComponentWalletNotComponent();
+
     event LogComponentWalletAddressChanged(address oldWallet, address newWallet);
     event LogComponentWalletTokensTransferred(address from, address to, uint256 amount);
 
+    event LogComponentTokenHandlerApproved(uint256 limit);
+
     /// @dev locks component to disable functions that may change state related to this component, the only exception is function "unlock"
     /// only component owner (nft holder) is authorizes to call this function
     function lock() external;
@@ -38,6 +45,11 @@ interface IComponent is
     /// only component owner (nft holder) is authorizes to call this function
     function unlock() external;
 
+    /// @dev approves token hanlder to spend up to the specified amount of tokens
+    /// reverts if component wallet is not component itself
+    /// only component owner (nft holder) is authorizes to call this function
+    function approveTokenHandler(uint256 spendingLimitAmount) external;
+
     /// @dev sets the wallet address for the component
     /// if the current wallet has tokens, these will be transferred
     /// if the new wallet address is externally owned, an approval from the 
@@ -47,6 +59,9 @@ interface IComponent is
     /// @dev only product service may set product nft id during registration of product setup
     function setProductNftId(NftId productNftId) external;
 
+    /// @dev defines the instance to which this component is linked to
+    function getInstance() external view returns (IInstance instance);
+
     /// @dev returns the name of this component
     /// to successfully register the component with an instance the name MUST be unique in the linked instance
     function getName() external view returns (string memory name);
@@ -54,8 +69,9 @@ interface IComponent is
     /// @dev defines which ERC20 token is used by this component
     function getToken() external view returns (IERC20Metadata token);
 
-    /// @dev defines the instance to which this component is linked to
-    function getInstance() external view returns (IInstance instance);
+    /// @dev returns token handler for this component
+    /// only registered components return a non zero token handler
+    function getTokenHandler() external view returns (TokenHandler tokenHandler);
 
     /// @dev defines the wallet address used to hold the ERC20 tokens related to this component
     /// the default address is the component token address

package/contracts/shared/INftOwnable.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.20;
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 import {IRegistryLinked} from "./IRegistryLinked.sol";
-import {NftId} from "../types/NftId.sol";
+import {NftId} from "../type/NftId.sol";
 
 interface INftOwnable is
     IERC165,

package/contracts/shared/IPolicyHolder.sol

@@ -4,23 +4,37 @@ pragma solidity ^0.8.20;
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
 
-import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId} from "../types/NftId.sol";
-import {NumberId} from "../types/NumberId.sol";
+import {Amount} from "../type/Amount.sol";
+import {ClaimId} from "../type/ClaimId.sol";
+import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
+import {NftId} from "../type/NftId.sol";
+import {PayoutId} from "../type/PayoutId.sol";
 
 /// @dev generic interface for contracts that need to hold policies and receive payouts
 /// GIF will notify policy holder contracts for policy creation and payout execution
-/// 
+interface IPolicyHolder is
+    IERC165,
+    IERC721Receiver,
+    IRegistryLinked
+{
 
-interface IPolicyHolder is IERC165, IERC721Receiver {
+    /// @dev callback function that will be called after successful policy activation
+    /// active policies may open claims under the activated policy
+    function policyActivated(NftId policyNftId) external;
 
-    /// @dev callback function that will be called after successful policy creation
-    function policyCreatedCallback(NftId policyNftId) external;
+    /// @dev callback function to indicate the specified policy has expired
+    /// expired policies may no longer open claims
+    /// it is optional for products to notifiy policy holder of expired claims
+    function policyExpired(NftId policyNftId) external;
+
+    /// @dev callback function to notify the confirmation of the specified claim
+    /// active policies may open claims under the activated policy
+    function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external;
 
     /// @dev callback function that will be called after a successful payout
-    function payoutExecutedCallback(NftId policyNftId, NumberId payoutId, address beneficiary, uint256 amount) external;
+    function payoutExecuted(NftId policyNftId, PayoutId payoutId, address beneficiary, Amount amount) external;
 
-    /// @dev determines beneficiary address that will be used in payouts targeting this contract
+    /// @dev determines policy and claim specific beneficiary address
     /// returned address will override GIF default where the policy nft holder is treated as beneficiary
-    function getBeneficiary(NftId policyId, NumberId claimId) external view returns (address beneficiary);
+    function getBeneficiary(NftId policyNftId, ClaimId claimId) external view returns (address beneficiary);
 }

package/contracts/shared/IRegistryLinked.sol

@@ -8,5 +8,4 @@ interface IRegistryLinked {
     error ErrorNotRegistry(address registryAddress);
 
     function getRegistry() external view returns (IRegistry);
-    function getRegistryAddress() external view returns (address);
 }

package/contracts/shared/IService.sol

@@ -1,18 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {VersionPart} from "../types/Version.sol";
-import {ObjectType} from "../types/ObjectType.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 
 import {IRegisterable} from "./IRegisterable.sol";
 import {IVersionable} from "./IVersionable.sol";
+import {ObjectType} from "../type/ObjectType.sol";
 
 interface IService is 
     IRegisterable,
-    IVersionable
+    IVersionable,
+    IAccessManaged
 {
-    error ErrorIServiceCallerUnknown(address caller);
-    
+    error ErrorServiceNotImplemented();
+
     function getDomain() external pure returns(ObjectType serviceDomain);
-    function getMajorVersion() external view returns(VersionPart majorVersion);
 }

package/contracts/shared/IVersionable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Version} from "../types/Version.sol";
+import {Version} from "../type/Version.sol";
 
 /// IMPORTANT
 // Upgradeable contract MUST:

package/contracts/shared/NftOwnable.sol

@@ -1,14 +1,12 @@
 // 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
+abstract contract NftOwnable is
     ERC165,
     RegistryLinked,
     INftOwnable
@@ -59,19 +57,18 @@ contract NftOwnable is
         public
         virtual
     {
-        NftOwnableStorage storage $ = _getNftOwnableStorage();
-
-        if ($._nftId.gtz()) {
-            revert ErrorNftOwnableAlreadyLinked($._nftId);
-        }
-
-        address contractAddress = address(this);
-
-        if (!getRegistry().isRegistered(contractAddress)) {
-            revert ErrorNftOwnableContractNotRegistered(contractAddress);
-        }
+        _linkToNftOwnable(address(this));
+    }
 
-        $._nftId = getRegistry().getNftId(contractAddress);
+    /// @dev links this contract to nft associated with provided address
+    function linkToNftOwnable(
+        address nftOwnableAddress
+    )
+        public
+        onlyOwner
+        returns (NftId)
+    {
+        return _linkToNftOwnable(nftOwnableAddress);
     }
 
     function getNftId() public view virtual override returns (NftId) {

package/contracts/shared/PolicyHolder.sol

@@ -5,11 +5,12 @@ 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, ClaimIdLib} 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} from "../type/PayoutId.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
 
 /// @dev template implementation for IPolicyHolder
@@ -22,33 +23,43 @@ contract PolicyHolder is
     // 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(ClaimId claimId => address beneficiary)) _beneficiary;
     }
 
     function initializePolicyHolder(
-        address registryAddress
+        address registryAddress,
+        address beneficiaryDefault
     )
         public
         virtual
         onlyInitializing()
     {
         initializeRegistryLinked(registryAddress);
+        registerInterface(type(IPolicyHolder).interfaceId);
     }
 
     /// @dev empty default implementation
-    function policyCreatedCallback(NftId policyNftId) external virtual { }
+    function policyActivated(NftId policyNftId) external {}
 
     /// @dev empty default implementation
-    function payoutExecutedCallback(NftId policyNftId, NumberId payoutId, address beneficiary, uint256 amount) external virtual { }
+    function policyExpired(NftId policyNftId) external {}
 
-    /// @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
+    /// @dev empty default implementation
+    function claimConfirmed(NftId policyNftId, ClaimId claimId, Amount amount) external {}
+
+    /// @dev empty default implementation
+    function payoutExecuted(NftId policyNftId, PayoutId payoutId, address beneficiary, Amount amount) external {}
+
+    /// @dev returns claim specific beneficiary
+    /// when no such beneficiary is defined the policy specific beneficiary is returned
+    function getBeneficiary(NftId policyNftId, ClaimId claimId) external virtual view returns (address beneficiary) {
+        beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][claimId];
+
+        // fallback to claim independent beneficiary
+        if(beneficiary == address(0) && claimId.gtz()) {
+            beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][ClaimIdLib.zero()];
+        }
     }
 
     //--- IERC165 functions ---------------// 
@@ -65,12 +76,14 @@ contract PolicyHolder is
         return IERC721Receiver.onERC721Received.selector;
     }
 
-    function _setBeneficiary(address beneficiary) internal {
-
+    /// @dev sets policy specific beneficiary (used when no claim specific beneficiary is defined)
+    function _setBeneficiary(NftId policyNftId, address beneficiary) internal {
+        _setBeneficiary(policyNftId, ClaimIdLib.zero(), beneficiary);
     }
 
-    function _setBeneficiary(NftId policyId, address beneficiary) internal {
-
+    /// @dev sets policy and claim specific beneficiary
+    function _setBeneficiary(NftId policyNftId, ClaimId claimId, address beneficiary) internal {
+        _getPolicyHolderStorage()._beneficiary[policyNftId][claimId] = beneficiary;
     }
 
     function _getPolicyHolderStorage() private pure returns (PolicyHolderStorage storage $) {