@etherisc/gif-next 0.0.2-efef0ea-320 → 0.0.2-f02157b-803

package/contracts/instance/InstanceServiceManager.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Instance} from "./Instance.sol";
+import {IVersionable} from "../shared/IVersionable.sol";
+import {ProxyManager} from "../shared/ProxyManager.sol";
+import {InstanceService} from "./InstanceService.sol";
+import {Registry} from "../registry/Registry.sol";
+import {RegistryService} from "../registry/RegistryService.sol";
+import {VersionLib} from "../types/Version.sol";
+
+contract InstanceServiceManager is ProxyManager {
+
+    InstanceService private _instanceService;
+
+    /// @dev initializes proxy manager with instance service implementation and deploys instance
+    constructor(
+        address registryAddress
+    )
+        ProxyManager()
+    {
+        InstanceService instSrv = new InstanceService();
+        // bytes memory initCode = type(InstanceService).creationCode;
+        bytes memory data = abi.encode(registryAddress, address(this));
+        IVersionable versionable = deploy(
+            address(instSrv), 
+            data);
+
+        _instanceService = InstanceService(address(versionable));
+
+        Registry registry = Registry(registryAddress);
+        address registryServiceAddress = registry.getServiceAddress("RegistryService", VersionLib.toVersion(3, 0, 0).toMajorPart());
+        RegistryService registryService = RegistryService(registryServiceAddress);
+
+        registryService.registerService(_instanceService);
+        // RegistryService registryService = _instanceService.getRegistryService();
+
+        // link ownership of instance service manager ot nft owner of instance service
+        _linkToNftOwnable(
+            address(registryAddress),
+            address(_instanceService));
+
+        // implies that after this constructor call only upgrade functionality is available
+        _isDeployed = true;
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getInstanceService()
+        external
+        view
+        returns (InstanceService instanceService)
+    {
+        return _instanceService;
+    }
+
+}

package/contracts/instance/base/ComponentServiceBase.sol

@@ -2,21 +2,23 @@
 pragma solidity ^0.8.19;
 
 import {IRegistry} from "../../registry/IRegistry.sol";
+import {IRegistryService} from "../../registry/IRegistryService.sol";
 import {IInstance} from "../../instance/IInstance.sol";
 import {ObjectType, INSTANCE, PRODUCT, POOL} from "../../types/ObjectType.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 
 import {ServiceBase} from "./ServiceBase.sol";
+import {Version, VersionPart, VersionLib} from "../../types/Version.sol";
 
 abstract contract ComponentServiceBase is ServiceBase {
 
     constructor(
         address registry,
-        NftId registryNftId
+        NftId registryNftId,
+        address initialOwner
     )
-        ServiceBase(registry, registryNftId)
-    // solhint-disable-next-line no-empty-blocks
     {
+        _initializeServiceBase(registry, registryNftId, initialOwner);
     }
 
 
@@ -30,13 +32,18 @@ abstract contract ComponentServiceBase is ServiceBase {
             IInstance instance
         )
     {
-        NftId componentNftId = _registry.getNftId(msg.sender);
+        NftId componentNftId = getRegistry().getNftId(msg.sender);
         require(componentNftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
 
-        info = _registry.getObjectInfo(componentNftId);
+        info = getRegistry().getObjectInfo(componentNftId);
         require(info.objectType == objectType, "OBJECT_TYPE_INVALID");
 
-        address instanceAddress = _registry.getObjectInfo(info.parentNftId).objectAddress;
+        address instanceAddress = getRegistry().getObjectInfo(info.parentNftId).objectAddress;
         instance = IInstance(instanceAddress);
     }
+
+    function getRegistryService() public view virtual returns (IRegistryService) {
+        address service = getRegistry().getServiceAddress("RegistryService", getMajorVersion());
+        return IRegistryService(service);
+    }
 }

package/contracts/instance/base/IInstanceBase.sol

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Key32} from "../../types/Key32.sol";
 import {StateId} from "../../types/StateId.sol";
 
 import {IKeyValueStore} from "./IKeyValueStore.sol";
+
 import {IComponentOwnerService} from "../service/IComponentOwnerService.sol";
 import {IDistributionService} from "../service/IDistributionService.sol";
 import {IProductService} from "../service/IProductService.sol";
@@ -15,7 +16,7 @@ interface IInstanceBase {
     function updateState(Key32 key, StateId state) external;
     function getState(Key32 key) external view returns (StateId state);
 
-    function getComponentOwnerService() external view returns(IComponentOwnerService service);
+    function getComponentOwnerService() external view returns(IComponentOwnerService);
     function getDistributionService() external view returns(IDistributionService);
     function getProductService() external view returns(IProductService service);
     function getPoolService() external view returns(IPoolService service);

package/contracts/instance/base/IKeyValueStore.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blocknumber.sol";
 import {Key32, KeyId} from "../../types/Key32.sol";
@@ -9,13 +9,9 @@ import {StateId} from "../../types/StateId.sol";
 
 import {ILifecycle} from "./ILifecycle.sol";
 
+// TODO remove - internal only?
 interface IKeyValueStore is ILifecycle {
 
-    struct Key {
-        ObjectType objectType;
-        KeyId id;
-    }
-
     struct Value {
         Metadata metadata;
         bytes data;
@@ -24,20 +20,24 @@ interface IKeyValueStore is ILifecycle {
     struct Metadata {
         ObjectType objectType;
         StateId state;
+        // TODO updatedBy needs concept that says what value should go here
+        // eg account outside gif objects that initiated the tx
+        // implies the caller needs to be propagated through all calls up to key values store itself
+        // to always have the instance address there doesn't seem to make sense
         address updatedBy;
         Blocknumber updatedIn;
         Blocknumber createdIn;
     }
 
-    event LogInfoCreated(Key key, StateId state, address createdBy, address txOrigin);
-    event LogInfoUpdated(Key key, StateId state, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
-    event LogStateUpdated(Key key, StateId stateOld, StateId stateNew, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogInfoCreated(ObjectType objectType, KeyId keyId, StateId state, address createdBy, address txOrigin);
+    event LogInfoUpdated(ObjectType objectType, KeyId keyId, StateId state, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
+    event LogStateUpdated(ObjectType objectType, KeyId keyId, StateId stateOld, StateId stateNew, address updatedBy, address txOrigin, Blocknumber lastUpdatedIn);
 
     // generic state changing functions
-    function create(Key32 key, ObjectType objectType, bytes memory data) external;
-    function update(Key32 key, StateId state, bytes memory data) external;
-    function updateData(Key32 key, bytes memory data) external;
-    function updateState(Key32 key, StateId state) external;
+    // function create(Key32 key, bytes memory data) external;
+    // function update(Key32 key, bytes memory data, StateId state) external;
+    // function updateData(Key32 key, bytes memory data) external;
+    // function updateState(Key32 key, StateId state) external;
 
     function exists(Key32 key) external view returns (bool);
     function get(Key32 key) external view returns (Value memory value);
@@ -46,5 +46,4 @@ interface IKeyValueStore is ILifecycle {
     function getState(Key32 key) external view returns (StateId state);
 
     function toKey32(ObjectType objectType, KeyId id) external pure returns(Key32);
-    function toKey(Key32 key32) external pure returns(Key memory key);
 }

package/contracts/instance/base/ILifecycle.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {ObjectType} from "../../types/ObjectType.sol";
-import {StateId, toStateId, zeroStateId} from "../../types/StateId.sol";
 import {NftId} from "../../types/NftId.sol";
+import {ObjectType} from "../../types/ObjectType.sol";
+import {StateId} from "../../types/StateId.sol";
 
 interface ILifecycle {
 

package/contracts/instance/base/KeyValueStore.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {Blocknumber, blockBlocknumber, zeroBlocknumber} from "../../types/Blocknumber.sol";
 import {Key32, KeyId, Key32Lib} from "../../types/Key32.sol";
 import {NftId} from "../../types/NftId.sol";
 import {ObjectType} from "../../types/ObjectType.sol";
 import {StateId, ACTIVE} from "../../types/StateId.sol";
-import {Timestamp, blockTimestamp, zeroTimestamp} from "../../types/Timestamp.sol";
+import {Timestamp, TimestampLib} from "../../types/Timestamp.sol";
 
 import {Lifecycle} from "./Lifecycle.sol";
 import {IKeyValueStore} from "./IKeyValueStore.sol";
@@ -14,27 +14,23 @@ import {IKeyValueStore} from "./IKeyValueStore.sol";
 contract KeyValueStore is Lifecycle, IKeyValueStore {
 
     mapping(Key32 key32 => Value value) private _value;
-    address private _owner;
 
-    modifier onlyOwner() {
-        require(
-            msg.sender == _owner,
-            "ERROR:KVS-001:NOT_OWNER");
-        _;
-    }
-
-    constructor() {
-        _owner = msg.sender;
+    function create(
+        Key32 key32, 
+        bytes memory data
+    )
+        internal
+    {
+        _create(key32, data);
     }
 
-    function create(
+    function _create(
         Key32 key32, 
-        ObjectType objectType, 
         bytes memory data
     )
-        public
-        onlyOwner
+        internal
     {
+        ObjectType objectType = key32.toObjectType();
         require(objectType.gtz(), "ERROR:KVS-010:TYPE_UNDEFINED");
 
         Metadata storage metadata = _value[key32].metadata;
@@ -55,12 +51,25 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         _value[key32].data = data;
 
         // solhint-disable-next-line avoid-tx-origin
-        emit LogInfoCreated(toKey(key32), initialState, createdBy, tx.origin);
+        emit LogInfoCreated(key32.toObjectType(), key32.toKeyId(), initialState, createdBy, tx.origin);
     }
 
-    function update(Key32 key32, StateId state, bytes memory data) 
-        public
-        onlyOwner
+    function update(
+        Key32 key32, 
+        bytes memory data,
+        StateId state
+    ) 
+        internal
+    {
+        _update(key32, data, state);
+    }
+
+    function _update(
+        Key32 key32, 
+        bytes memory data,
+        StateId state
+    ) 
+        internal
     {
         require(state.gtz(), "ERROR:KVS-020:STATE_UNDEFINED");
         Metadata storage metadata = _value[key32].metadata;
@@ -78,16 +87,20 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         metadata.updatedIn = blockBlocknumber();
 
         // create log entries
-        Key memory key = toKey(key32);
-        // solhint-disable-next-line avoid-tx-origin
-        emit LogStateUpdated(key, state, stateOld, updatedBy, tx.origin, lastUpdatedIn);
-        // solhint-disable-next-line avoid-tx-origin
-        emit LogInfoUpdated(key, state, updatedBy, tx.origin, lastUpdatedIn);
+        // solhint-disable avoid-tx-origin
+        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), state, stateOld, updatedBy, tx.origin, lastUpdatedIn);
+        emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, updatedBy, tx.origin, lastUpdatedIn);
+        // solhing-enable
     }
 
     function updateData(Key32 key32, bytes memory data) 
-        public
-        onlyOwner
+        internal
+    {
+        _updateData(key32, data);
+    }
+
+    function _updateData(Key32 key32, bytes memory data) 
+        internal
     {
         Metadata storage metadata = _value[key32].metadata;
         StateId state = metadata.state;
@@ -103,14 +116,18 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         metadata.updatedIn = blockBlocknumber();
 
         // create log entry
-        Key memory key = toKey(key32);
         // solhint-disable-next-line avoid-tx-origin
-        emit LogInfoUpdated(key, state, updatedBy, tx.origin, lastUpdatedIn);
+        emit LogInfoUpdated(key32.toObjectType(), key32.toKeyId(), state, updatedBy, tx.origin, lastUpdatedIn);
     }
 
     function updateState(Key32 key32, StateId state)
-        public
-        onlyOwner
+        internal
+    {
+        _updateState(key32, state);
+    }
+
+    function _updateState(Key32 key32, StateId state)
+        internal
     {
         require(state.gtz(), "ERROR:KVS-040:STATE_UNDEFINED");
         Metadata storage metadata = _value[key32].metadata;
@@ -125,9 +142,8 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
         metadata.updatedIn = blockBlocknumber();
 
         // create log entry
-        Key memory key = toKey(key32);
         // solhint-disable-next-line avoid-tx-origin
-        emit LogStateUpdated(key, state, stateOld, updatedBy, tx.origin, lastUpdatedIn);
+        emit LogStateUpdated(key32.toObjectType(), key32.toKeyId(), state, stateOld, updatedBy, tx.origin, lastUpdatedIn);
     }
 
     function exists(Key32 key32) public view returns (bool) {
@@ -153,9 +169,4 @@ contract KeyValueStore is Lifecycle, IKeyValueStore {
     function toKey32(ObjectType objectType, KeyId id) external pure override returns(Key32) {
         return Key32Lib.toKey32(objectType, id);
     }
-
-    function toKey(Key32 key32) public pure override returns (Key memory key) {
-        (ObjectType objectType, KeyId id) = key32.toKey();
-        return Key(objectType, id);
-    }
 }

package/contracts/instance/base/Lifecycle.sol

@@ -1,5 +1,5 @@
 // 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";

package/contracts/instance/base/ServiceBase.sol

@@ -3,9 +3,10 @@ pragma solidity ^0.8.19;
 
 import {NftId, zeroNftId} from "../../types/NftId.sol";
 import {ObjectType, SERVICE} from "../../types/ObjectType.sol";
-import {Version, VersionPart} from "../../types/Version.sol";
+import {Version, VersionPart, VersionLib} from "../../types/Version.sol";
 
 import {Registerable} from "../../shared/Registerable.sol";
+import {IRegistry} from "../../registry/IRegistry.sol";
 import {IVersionable} from "../../shared/IVersionable.sol";
 import {Versionable} from "../../shared/Versionable.sol";
 
@@ -16,22 +17,28 @@ abstract contract ServiceBase is
     Versionable,
     IService
 {
+    function getName() public pure virtual override returns(string memory name);
 
-    constructor(
-        address registry,
-        NftId registryNftId
-    )
-        Registerable(registry, registryNftId)
-        Versionable()
-    {
-        _registerInterface(type(IService).interfaceId);
+    function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
+        return getVersion().toMajorPart(); 
     }
 
-    function getMajorVersion() external view override returns(VersionPart majorVersion) {
-        return this.getVersion().toMajorPart();
+    // from Versionable
+    function getVersion()
+        public 
+        pure 
+        virtual override (IVersionable, Versionable)
+        returns(Version)
+    {
+        return VersionLib.toVersion(3,0,0);
     }
 
-    function getType() external pure override returns (ObjectType) {
-        return SERVICE();
+    function _initializeServiceBase(address registry, NftId registryNftId, address initialOwner)
+        internal 
+        //onlyInitializing //TODO uncomment when "fully" upgradeable
+    {// service must provide its name and version upon registration
+        bytes memory data = abi.encode(getName(), getMajorVersion());
+        _initializeRegisterable(registry, registryNftId, SERVICE(), false, initialOwner, data);
+        _registerInterface(type(IService).interfaceId);
     }
 }

package/contracts/instance/module/IAccess.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {ShortString, ShortStrings} from "@openzeppelin/contracts/utils/ShortStrings.sol";
+
+import {RoleId} from "../../types/RoleId.sol";
+
+interface IAccess {
+    struct RoleInfo {
+        ShortString name;
+        bool isCustom;
+    }
+
+    struct TargetInfo {
+        ShortString name;
+        bool isCustom;
+    }
+
+    error ErrorTargetAddressZero();
+    error ErrorTargetAlreadyExists(address target, ShortString name);
+    error ErrorTargetDoesNotExist(address target);
+    error ErrorTargetNameEmpty(address target);
+    error ErrorTargetNameExists(address target, address existingTarget, ShortString name);
+
+    error ErrorRoleIdInvalid(RoleId roleId);
+    error ErrorRoleIdTooBig(RoleId roleId);
+    error ErrorRoleIdTooSmall(RoleId roleId);
+    error ErrorRoleIdAlreadyExists(RoleId roleId, ShortString name);
+    error ErrorRoleIdNotActive(RoleId roleId);
+    error ErrorRoleNameEmpty(RoleId roleId);
+    error ErrorRoleNameNotUnique(RoleId roleId, ShortString name);
+    error ErrorRoleInvalidUpdate(RoleId roleId, bool isCustom);
+    error ErrorGrantNonexstentRole(RoleId roleId);
+    error ErrorRevokeNonexstentRole(RoleId roleId);
+    error ErrorRenounceNonexstentRole(RoleId roleId);
+
+}

package/contracts/instance/module/IBundle.sol

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

package/contracts/instance/module/IDistribution.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {DistributorType} from "../../types/DistributorType.sol";
+import {NftId} from "../../types/NftId.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
+import {UFixed} from "../../types/UFixed.sol";
+
+interface IDistribution {
+
+    struct DistributorTypeInfo {
+        string name;
+        UFixed minDiscountPercentage;
+        UFixed maxDiscountPercentage;
+        UFixed commissionPercentage;
+        uint32 maxReferralCount;
+        uint32 maxReferralLifetime;
+        bool allowSelfReferrals;
+        bool allowRenewals;
+        bytes data;
+    }
+
+    struct DistributorInfo {
+        DistributorType distributorType;
+        bool active;
+        bytes data;
+    }
+
+    struct ReferralInfo {   
+        NftId distributorNftId;
+        string referralCode;
+        UFixed discountPercentage;
+        uint32 maxReferrals;
+        uint32 usedReferrals;
+        Timestamp expiryAt;
+        bytes data;
+    }
+
+}

package/contracts/instance/module/IPolicy.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {NftId} from "../../types/NftId.sol";
+import {NumberId} from "../../types/NumberId.sol";
+import {ReferralId} from "../../types/Referral.sol";
+import {RiskId} from "../../types/RiskId.sol";
+import {Timestamp} from "../../types/Timestamp.sol";
+
+interface IPolicy {
+    struct PolicyInfo {
+        NftId productNftId;
+        NftId bundleNftId;
+        ReferralId referralId;
+        RiskId riskId;
+        uint256 sumInsuredAmount;
+        uint256 premiumAmount;
+        uint256 premiumPaidAmount;
+        uint256 lifetime;
+        bytes applicationData;
+        bytes policyData;
+        uint16 claimsCount;
+        uint16 openClaimsCount;
+        uint256 payoutAmount;
+        Timestamp activatedAt; // time of underwriting
+        Timestamp expiredAt; // no new claims (activatedAt + lifetime)
+        Timestamp closedAt; // no locked capital (or declinedAt)
+    }
+
+    // claimId neeeds to be encoded policyNftId:claimId combination
+    struct ClaimInfo {
+        uint256 claimAmount;
+        uint256 paidAmount;
+        bytes data;
+        Timestamp closedAt; // payoment of confirmed claim amount (or declinedAt)
+    }
+
+    // claimId neeeds to be encoded policyNftId:claimId combination
+    struct PayoutInfo {
+        NumberId claimId;
+        uint256 amount;
+        bytes data;
+        Timestamp paidAt; // payoment of confirmed claim amount (or declinedAt)
+    }
+}

package/contracts/instance/module/IRisk.sol

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

package/contracts/instance/module/ISetup.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Fee} from "../../types/Fee.sol";
+import {NftId} from "../../types/NftId.sol";
+import {UFixed} from "../../types/UFixed.sol";
+import {TokenHandler} from "../../shared/TokenHandler.sol";
+
+interface ISetup {
+    struct ProductSetupInfo {
+        IERC20Metadata token;
+        TokenHandler tokenHandler;
+        NftId distributionNftId;
+        NftId poolNftId;
+        Fee distributionFee; // default distribution fee (no referral id)
+        Fee productFee; // product fee on net premium
+        Fee processingFee; // product fee on payout amounts
+        Fee poolFee; // pool fee on net premium
+        Fee stakingFee; // pool fee on staked capital from investor
+        Fee performanceFee; // pool fee on profits from capital investors
+    }
+
+    struct DistributionSetupInfo {
+        NftId productNftId;
+        TokenHandler tokenHandler;
+        Fee distributionFee; // default distribution fee (no referral id)
+        bool isIntercepting; // intercepts nft transfers (for distributors)
+        address wallet;
+    }
+
+    struct PoolSetupInfo {
+        NftId productNftId;
+        TokenHandler tokenHandler;
+        UFixed collateralizationLevel;
+        Fee poolFee; // pool fee on net premium
+        Fee stakingFee; // pool fee on staked capital from investor
+        Fee performanceFee; // pool fee on profits from capital investors
+        bool isIntercepting; // intercepts nft transfers (for bundles)
+        address wallet;
+    }
+}

package/contracts/instance/module/ITreasury.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Fee} from "../../types/Fee.sol";
+import {NftId} from "../../types/NftId.sol";
+import {TokenHandler} from "../../shared/TokenHandler.sol";
+
+interface ITreasury {
+    struct TreasuryInfo {
+        IERC20Metadata token;
+        TokenHandler tokenHandler;
+        NftId distributionNftId;
+        NftId poolNftId;
+        Fee distributionFee; // default distribution fee (no referral id)
+        Fee productFee; // product fee on net premium
+        Fee processingFee; // product fee on payout amounts
+        Fee poolFee; // pool fee on net premium
+        Fee stakingFee; // pool fee on staked capital from investor
+        Fee performanceFee; // pool fee on profits from capital investors
+    }
+}