@etherisc/gif-next 0.0.2-cd89a0b-062 → 0.0.2-cdd6310-176

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

@@ -1,23 +1,33 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-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 {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.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 ILifecycle {
+contract Lifecycle is
+    Initializable,
+    ILifecycle
+{
     mapping(ObjectType objectType => StateId initialState)
         private _initialState;
 
     mapping(ObjectType objectType => mapping(StateId stateFrom => mapping(StateId stateTo => bool isValid)))
         private _isValidTransition;
 
-    constructor() {
+    function initializeLifecycle()
+        public
+        onlyInitializing
+    {
         _setupBundleLifecycle();
         _setupComponentLifecycle();
         _setupPolicyLifecycle();
+        _setupClaimAndPayoutLifecycle();
         _setupRiskLifecycle();
+        _setupRequestLifecycle();
     }
 
     function hasLifecycle(
@@ -78,6 +88,7 @@ contract Lifecycle is ILifecycle {
     function _setupBundleLifecycle() internal {
         _initialState[BUNDLE()] = ACTIVE();
         _isValidTransition[BUNDLE()][ACTIVE()][PAUSED()] = true;
+        _isValidTransition[BUNDLE()][ACTIVE()][CLOSED()] = true;
         _isValidTransition[BUNDLE()][PAUSED()][ACTIVE()] = true;
         _isValidTransition[BUNDLE()][PAUSED()][CLOSED()] = true;
     }
@@ -86,15 +97,34 @@ contract Lifecycle is ILifecycle {
         _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,87 +1,107 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IOwnable} from "./IOwnable.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId, zeroNftId} from "../types/NftId.sol";
+import {ERC165} from "./ERC165.sol";
+import {INftOwnable} from "./INftOwnable.sol";
+import {NftId} from "../type/NftId.sol";
+import {RegistryLinked} from "./RegistryLinked.sol";
 
 contract NftOwnable is
-    IOwnable
+    ERC165,
+    RegistryLinked,
+    INftOwnable
 {
-    error ErrorNftOwnableUnauthorized(address account);
+    // keccak256(abi.encode(uint256(keccak256("etherisc.storage.NftOwnable")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant NFT_OWNABLE_STORAGE_LOCATION_V1 = 0x07ebcf49758b6ed3af50fa146bec0abe157c0218fe65dc0874c286e9d5da4f00;
 
-    error ErrorAlreadyInitialized(address registry, NftId nftId);
-    error ErrorRegistryAlreadyInitialized(address registry);
-    error ErrorRegistryNotInitialized();
-    error ErrorRegistryAddressZero();
-    error ErrorContractNotRegistered(address contractAddress);
-
-    IRegistry internal _registry;
-    NftId private _nftId;
-    address private _initialOwner; 
+    struct NftOwnableStorage {
+        NftId _nftId;
+        address _initialOwner; 
+    }
 
+    /// @dev enforces msg.sender is owner of nft (or initial owner of nft ownable)
     modifier onlyOwner() {
-        address owner = getOwner();
-
-        // owner == address(0) is eg uninitialized upgradable contract
-        if (owner != address(0) && msg.sender != owner) {
-            revert ErrorNftOwnableUnauthorized(msg.sender);
+        if (msg.sender != getOwner()) {
+            revert ErrorNftOwnableNotOwner(msg.sender);
         }
         _;
     }
 
-    constructor() {
-        _initialOwner = msg.sender;
-    }
 
-    // function only needed during bootstrapping on a new chain
-    function linkToRegistry(
-        address registryAddress,
-        address contractAddress
+    /// @dev initialization for upgradable contracts
+    // used in _initializeRegisterable
+    function initializeNftOwnable(
+        address initialOwner,
+        address registryAddress
     )
-        internal
-        onlyOwner()
-        returns (NftId)
+        public
+        virtual
+        onlyInitializing()
     {
-        if (_nftId.gtz()) {
-            revert ErrorAlreadyInitialized(address(_registry), _nftId);
-        }
+        initializeRegistryLinked(registryAddress);
+        initializeERC165();
 
-        if (address(_registry) != address(0)) {
-            revert ErrorRegistryAlreadyInitialized(address(_registry));
+        if(initialOwner == address(0)) {
+            revert ErrorNftOwnableInitialOwnerZero();
         }
 
-        if (registryAddress == address(0)) {
-            revert ErrorRegistryAddressZero();
-        }
-
-        _registry = IRegistry(registryAddress);
+        _getNftOwnableStorage()._initialOwner = initialOwner;
+    }
 
-        if (!_registry.isRegistered(contractAddress)) {
-            revert ErrorContractNotRegistered(contractAddress);
-        }
 
-        _nftId = _registry.getNftId(contractAddress);
+    /// @dev links this contract to nft after registration
+    // needs to be done once per registered contract and 
+    // reduces registry calls to check ownership
+    // does not need any protection as function can only do the "right thing"
+    function linkToRegisteredNftId()
+        public
+        virtual
+        returns (NftId nftId)
+    {
+        return _linkToNftOwnable(address(this));
+    }
 
-        return _nftId;
+    function getNftId() public view virtual override returns (NftId) {
+        return _getNftOwnableStorage()._nftId;
     }
 
+    function getOwner() public view virtual override returns (address) {
+        NftOwnableStorage storage $ = _getNftOwnableStorage();
 
-    function getRegistry() external view returns (IRegistry) {
-        return _registry;
+        if ($._nftId.gtz()) {
+            return getRegistry().ownerOf($._nftId);
+        }
+
+        return $._initialOwner;
     }
 
+    /// @dev used in constructor of registry service manager
+    // links ownership of registry service manager ot nft owner of registry service
+    function _linkToNftOwnable(
+        address nftOwnableAddress
+    )
+        internal
+        returns (NftId)
+    {
+        NftOwnableStorage storage $ = _getNftOwnableStorage();
+
+        if ($._nftId.gtz()) {
+            revert ErrorNftOwnableAlreadyLinked($._nftId);
+        }
+
+        if (!getRegistry().isRegistered(nftOwnableAddress)) {
+            revert ErrorNftOwnableContractNotRegistered(nftOwnableAddress);
+        }
+
+        $._nftId = getRegistry().getNftId(nftOwnableAddress);
 
-    function getNftId() external view returns (NftId) {
-        return _nftId;
+        return $._nftId;
     }
 
 
-    function getOwner() public view returns (address) {
-        if (_nftId.gtz()) {
-            return _registry.ownerOf(_nftId);
+    function _getNftOwnableStorage() private pure returns (NftOwnableStorage storage $) {
+        assembly {
+            $.slot := NFT_OWNABLE_STORAGE_LOCATION_V1
         }
-
-        return _initialOwner;
     }
 }

package/contracts/shared/PolicyHolder.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+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 {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, // 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;
+
+    struct PolicyHolderStorage {
+        mapping(NftId policyId => mapping(PayoutId payoutId => address beneficiary)) _beneficiary;
+        address _beneficiaryDefault;
+    }
+
+    function initializePolicyHolder(
+        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 {}
+
+    /// @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 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];
+
+        // fallback to claim independent beneficiary
+        if(beneficiary == address(0) && payoutId.gtz()) {
+            beneficiary = _getPolicyHolderStorage()._beneficiary[policyNftId][PayoutIdLib.zero()];
+        }
+    }
+
+    //--- IERC165 functions ---------------// 
+    function onERC721Received(
+        address, // operator
+        address, // from
+        uint256, // tokenId
+        bytes calldata // data
+    )
+        external
+        virtual
+        returns (bytes4)
+    {
+        return IERC721Receiver.onERC721Received.selector;
+    }
+
+    /// @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);
+    }
+
+    /// @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 $) {
+        assembly {
+            $.slot := POLICY_HOLDER_STORAGE_LOCATION_V1
+        }
+    }
+}