@etherisc/gif-next 0.0.2-98bc1be-984 → 0.0.2-98e9f45-792

package/contracts/instance/InstanceStore.sol

@@ -7,7 +7,7 @@ import {Amount} from "../type/Amount.sol";
 import {Key32} from "../type/Key32.sol";
 import {NftId} from "../type/NftId.sol";
 import {ClaimId} from "../type/ClaimId.sol";
-import {ObjectType, BUNDLE, POLICY, POOL, PRODUCT, COMPONENT, DISTRIBUTOR, DISTRIBUTOR_TYPE} from "../type/ObjectType.sol";
+import {ObjectType, BUNDLE, POLICY, POOL, PREMIUM, PRODUCT, COMPONENT, DISTRIBUTOR} from "../type/ObjectType.sol";
 import {RequestId} from "../type/RequestId.sol";
 import {RiskId} from "../type/RiskId.sol";
 import {StateId} from "../type/StateId.sol";
@@ -27,21 +27,28 @@ import {IPolicy} from "./module/IPolicy.sol";
 import {IOracle} from "../oracle/IOracle.sol";
 import {IRisk} from "./module/IRisk.sol";
 
+import {ObjectLifecycle} from "./base/ObjectLifecycle.sol";
+
 
 contract InstanceStore is
     AccessManagedUpgradeable, 
     BalanceStore,
     KeyValueStore,
-    ObjectCounter
+    ObjectCounter,
+    ObjectLifecycle
 {
-    function initialize(address instance)
+
+    /// @dev This initializer needs to be called from the instance itself.
+    function initialize()
         public 
         initializer()
     {
+        address instance = msg.sender;
         address authority = IInstance(instance).authority();
-        __AccessManaged_init(authority);
 
-        initializeLifecycle();
+        __AccessManaged_init(authority);
+        // double initialization, safe
+        _initializeLifecycle();
     }
 
     //--- Component ---------------------------------------------------------//
@@ -109,6 +116,7 @@ contract InstanceStore is
 
     //--- Distributor -------------------------------------------------------//
     function createDistributor(NftId distributorNftId, IDistribution.DistributorInfo memory info) external restricted() {
+        _registerBalanceTarget(distributorNftId);
         _create(_toNftKey32(distributorNftId, DISTRIBUTOR()), abi.encode(info));
     }
 
@@ -187,6 +195,20 @@ contract InstanceStore is
         _updateState(_toNftKey32(policyNftId, POLICY()), newState);
     }
 
+    
+    //--- Premium (Policy) ----------------------------------------------//
+    function createPremium(NftId policyNftId, IPolicy.PremiumInfo memory premium) external restricted() {
+        _create(_toNftKey32(policyNftId, PREMIUM()), abi.encode(premium));
+    }
+
+    function updatePremium(NftId policyNftId, IPolicy.PremiumInfo memory premium, StateId newState) external restricted() {
+        _update(_toNftKey32(policyNftId, PREMIUM()), abi.encode(premium), newState);
+    }
+
+    function updatePremiumState(NftId policyNftId, StateId newState) external restricted() {
+        _updateState(_toNftKey32(policyNftId, PREMIUM()), newState);
+    }
+
     //--- Claim -------------------------------------------------------------//
     function createClaim(NftId policyNftId, ClaimId claimId, IPolicy.ClaimInfo memory claim) external restricted() {
         _create(_toClaimKey32(policyNftId, claimId), abi.encode(claim));

package/contracts/instance/base/ObjectLifecycle.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
+
+import {COMPONENT, BUNDLE, POLICY, REQUEST, RISK, CLAIM, PAYOUT, POOL, PREMIUM, PRODUCT, DISTRIBUTION, DISTRIBUTOR, DISTRIBUTOR_TYPE, REFERRAL} from "../../type/ObjectType.sol";
+import {ACTIVE, PAUSED, ARCHIVED, CLOSED, APPLIED, COLLATERALIZED, REVOKED, SUBMITTED, CONFIRMED, DECLINED, EXPECTED, PAID, FULFILLED, FAILED, CANCELLED} from "../../type/StateId.sol";
+import {Lifecycle} from "../../shared/Lifecycle.sol";
+
+contract ObjectLifecycle is
+    Lifecycle,
+    Initializable
+{
+    function _initializeLifecycle() internal onlyInitializing
+    {
+        _setupLifecycle();
+    }
+
+    function _setupLifecycle()
+        internal
+        override
+    {
+        _setupBundleLifecycle();
+        _setupComponentLifecycle();
+        _setupPolicyLifecycle();
+        _setupPremiumLifecycle();
+        _setupClaimLifecycle();
+        _setupPayoutLifecycle();
+        _setupRiskLifecycle();
+        _setupRequestLifecycle();
+
+        // setup dummy lifecycles to manage with key value store 
+        _setUpPoolLifecycle();
+        _setUpProductLifecycle();
+        _setUpDistributionLifecycle();
+    }
+
+    function _setupComponentLifecycle() private {
+        setInitialState(COMPONENT(), ACTIVE());
+        setStateTransition(COMPONENT(), ACTIVE(), PAUSED());
+        setStateTransition(COMPONENT(), PAUSED(), ACTIVE());
+        setStateTransition(COMPONENT(), PAUSED(), ARCHIVED());
+    }
+
+    function _setupBundleLifecycle() private {
+        setInitialState(BUNDLE(), ACTIVE());
+        setStateTransition(BUNDLE(), ACTIVE(), PAUSED());
+        setStateTransition(BUNDLE(), ACTIVE(), CLOSED());
+        setStateTransition(BUNDLE(), PAUSED(), ACTIVE());
+        setStateTransition(BUNDLE(), PAUSED(), CLOSED());
+    }
+
+    function _setupPolicyLifecycle() private {
+        setInitialState(POLICY(), APPLIED());
+        setStateTransition(POLICY(), APPLIED(), REVOKED());
+        setStateTransition(POLICY(), APPLIED(), DECLINED());
+        setStateTransition(POLICY(), APPLIED(), COLLATERALIZED());
+        setStateTransition(POLICY(), COLLATERALIZED(), CLOSED());
+    }
+
+    function _setupPremiumLifecycle() private {
+        setInitialState(PREMIUM(), ACTIVE());
+    }
+
+    function _setupClaimLifecycle() private {
+        setInitialState(CLAIM(), SUBMITTED());
+        setStateTransition(CLAIM(), SUBMITTED(), CONFIRMED());
+        setStateTransition(CLAIM(), SUBMITTED(), DECLINED());
+        setStateTransition(CLAIM(), CONFIRMED(), CLOSED());
+    }
+
+    function _setupPayoutLifecycle() private {
+        setInitialState(PAYOUT(), EXPECTED());
+        // TODO: add state cancelled
+        setStateTransition(PAYOUT(), EXPECTED(), PAID());
+    }
+
+    function _setupRiskLifecycle() private {
+        setInitialState(RISK(), ACTIVE());
+        setStateTransition(RISK(), ACTIVE(), PAUSED());
+        setStateTransition(RISK(), PAUSED(), ACTIVE());
+        setStateTransition(RISK(), PAUSED(), ARCHIVED());
+    }
+
+    function _setupRequestLifecycle() private {
+        setInitialState(REQUEST(), ACTIVE());
+        setStateTransition(REQUEST(), ACTIVE(), FULFILLED());
+        setStateTransition(REQUEST(), ACTIVE(), FAILED());
+        setStateTransition(REQUEST(), FAILED(), FULFILLED());
+        setStateTransition(REQUEST(), ACTIVE(), CANCELLED());
+    }
+
+    // dummy lifecycle only
+    function _setUpPoolLifecycle() private {
+        setInitialState(POOL(), ACTIVE());
+    }
+
+    // dummy lifecycle only
+    function _setUpProductLifecycle() private {
+        setInitialState(PRODUCT(), ACTIVE());
+    }
+
+    // dummy lifecycles only
+    function _setUpDistributionLifecycle() private {
+        setInitialState(DISTRIBUTION(), ACTIVE());
+        setInitialState(DISTRIBUTOR(), ACTIVE());
+        setInitialState(DISTRIBUTOR_TYPE(), ACTIVE());
+        setInitialState(REFERRAL(), ACTIVE());
+    }
+}

package/contracts/instance/base/{ObjectManager.sol → ObjectSet.sol}

@@ -10,28 +10,27 @@ import {IRegistry} from "../../registry/IRegistry.sol";
 import {LibNftIdSet} from "../../type/NftIdSet.sol";
 import {NftId} from "../../type/NftId.sol";
 
-contract ObjectManager is
+contract ObjectSet is
     Cloneable
 {
 
-    event LogObjectManagerInitialized(address instance);
+    event LogObjectSetInitialized(address instance);
 
-    error ErrorObjectManagerNftIdInvalid(NftId instanceNftId);
+    error ErrorObjectSetNftIdInvalid(NftId instanceNftId);
 
     mapping(NftId compnentNftId => LibNftIdSet.Set objects) internal _activeObjects;
     mapping(NftId compnentNftId => LibNftIdSet.Set objects) internal _allObjects;
-    IInstance internal _instance; // store instance address -> more flexible, instance may not be registered during ObjectManager initialization
+    IInstance internal _instance; // store instance address -> more flexible, instance may not be registered during ObjectSet initialization
 
-    /// @dev call to initialize MUST be made in the same transaction as cloning of the contract
-    function initialize(address instanceAddress) 
-        initializer
-        external 
+    /// @dev This initializer needs to be called from the instance itself.
+    function initialize() 
+        external
+        initializer()
     {
-        IInstance instance = IInstance(instanceAddress);
-        __Cloneable_init(instance.authority(), address(instance.getRegistry()));
-        _instance = instance;
+        _instance = IInstance(msg.sender);
+        __Cloneable_init(_instance.authority(), address(_instance.getRegistry()));
         
-        emit LogObjectManagerInitialized(instanceAddress);
+        emit LogObjectSetInitialized(address(_instance));
     }
 
     function getInstance() external view returns (IInstance) {

package/contracts/instance/module/IBundle.sol

@@ -13,7 +13,7 @@ interface IBundle {
         NftId poolNftId;
         Fee fee; // bundle fee on net premium amounts
         bytes filter; // required conditions for applications to be considered for collateralization by this bundle
-        Seconds lifetime; // lifetime of bundle after creation
+        Timestamp activatedAt; 
         Timestamp expiredAt; // no new policies starting with this timestamp
         Timestamp closedAt; // no open policies, locked amount = 0
     }

package/contracts/instance/module/IComponents.sol

@@ -21,7 +21,6 @@ interface IComponents {
         bytes data; // will hold component type specific additional info (eg encoded pool info)
     }
 
-
     struct ProductInfo {
         NftId distributionNftId;
         NftId poolNftId;
@@ -36,17 +35,12 @@ interface IComponents {
 
 
     struct PoolInfo {
-        NftId productNftId; // the nft of the product this pool is linked to
         RoleId bundleOwnerRole; // the required role for bundle owners
-        // TODO maxCapitalAmount -> maxBalanceAmount
-        Amount maxCapitalAmount; // max capital amount allowed for pool
+        Amount maxBalanceAmount; // max balance amount allowed for pool
         bool isInterceptingBundleTransfers; // intercepts nft transfers for bundles
         bool isExternallyManaged; // funding bundles is restricted to book keeping, actual funds may be provided as needed to support payouts
         bool isVerifyingApplications; // underwriting requires the pool component checks/confirms the applications 
         UFixed collateralizationLevel; // factor to calculate collateral for sum insurance (default 100%)
         UFixed retentionLevel; // amount of collateral held in pool (default 100%)
-        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
     }
 }

package/contracts/instance/module/IDistribution.sol

@@ -25,7 +25,6 @@ interface IDistribution {
         DistributorType distributorType;
         bool active;
         bytes data;
-        Amount commissionAmount;
         uint32 numPoliciesSold;
     }
 

package/contracts/instance/module/IPolicy.sol

@@ -11,7 +11,7 @@ import {Timestamp} from "../../type/Timestamp.sol";
 
 interface IPolicy {
 
-    struct Premium {
+    struct PremiumInfo {
         // premium splitting per target wallet
         Amount productFeeAmount;
         Amount distributionFeeAndCommissionAmount;
@@ -19,26 +19,26 @@ interface IPolicy {
 
         // detailed positions
         // this is the net premium calculated by the product 
-        uint256 netPremiumAmount;
+        Amount netPremiumAmount;
         // fullPremium = netPremium + all fixed amounts + all variable amounts (excl commission and minDistribtuionOwnerFee variable part)
-        uint256 fullPremiumAmount;
-        // premium = fullPremium - discount
-        uint256 premiumAmount;
-        uint256 productFeeFixAmount;
-        uint256 poolFeeFixAmount;
-        uint256 bundleFeeFixAmount;
-        uint256 distributionFeeFixAmount;
-        uint256 productFeeVarAmount;
-        uint256 poolFeeVarAmount;
-        uint256 bundleFeeVarAmount;
-        uint256 distributionFeeVarAmount;
-        uint256 distributionOwnerFeeFixAmount;
+        Amount fullPremiumAmount;
+        // effective premium = fullPremium - discount 
+        Amount premiumAmount;
+        Amount productFeeFixAmount;
+        Amount poolFeeFixAmount;
+        Amount bundleFeeFixAmount;
+        Amount distributionFeeFixAmount;
+        Amount productFeeVarAmount;
+        Amount poolFeeVarAmount;
+        Amount bundleFeeVarAmount;
+        Amount distributionFeeVarAmount;
+        Amount distributionOwnerFeeFixAmount;
         // this is the remaining amount when the commission and discount are subtracted from the distribution fee variable part (must be at least the minDistributionOwnerFee)
-        uint256 distributionOwnerFeeVarAmount;
+        Amount distributionOwnerFeeVarAmount;
         // this value is based on distributor type referenced in the referral 
-        uint256 commissionAmount;
+        Amount commissionAmount;
         // this is based on referral used
-        uint256 discountAmount;
+        Amount discountAmount;
     }
 
     /// @dev policy data for the full policy lifecycle

package/contracts/mock/Dip.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 contract Dip is ERC20 {
 

package/contracts/oracle/BasicOracle.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAuthorization} from "../../contracts/authorization/IAuthorization.sol";
+import {NftId} from "../../contracts/type/NftId.sol";
+import {Oracle} from "../../contracts/oracle/Oracle.sol";
+import {RequestId} from "../../contracts/type/RequestId.sol";
+
+contract BasicOracle is
+    Oracle
+{
+
+    /// Function to provide reponse data releated to request id.
+    function respond(
+        RequestId requestId,
+        bytes memory responseData
+    )
+        external
+        virtual
+        restricted()
+    {
+        _respond(requestId, responseData);
+    }
+
+    function _initializeBasicOracle(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name,
+        address token
+    )
+        internal
+        virtual
+        onlyInitializing()
+    {
+
+        _initializeOracle(
+            registry,
+            instanceNftId,
+            authorization,
+            initialOwner,
+            name,
+            token,
+            "",
+            "");
+    }
+}

package/contracts/oracle/BasicOracleAuthorization.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Authorization} from "../authorization/Authorization.sol";
+import {BasicOracle} from "./BasicOracle.sol"; 
+import {ORACLE} from "../type/ObjectType.sol";
+import {IAccess} from "../authorization/IAccess.sol";
+import {IOracle} from "./IOracle.sol"; 
+import {PUBLIC_ROLE} from "../../contracts/type/RoleId.sol";
+import {RoleId} from "../type/RoleId.sol";
+
+
+contract BasicOracleAuthorization
+     is Authorization
+{
+
+     constructor(string memory componentName)
+          Authorization(componentName)
+     {}
+
+     function _setupTargets()
+          internal
+          virtual override
+     {
+          // basic component target
+          _addComponentTargetWithRole(ORACLE()); 
+     }
+
+
+     function _setupTargetAuthorizations()
+          internal
+          virtual override
+     {
+          IAccess.FunctionInfo[] storage functions;
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getTargetName(), getServiceRole(ORACLE()));
+          _authorize(functions, IOracle.request.selector, "request");
+          _authorize(functions, IOracle.cancel.selector, "cancel");
+
+          // authorize public role (open access to any account, only allows to lock target)
+          functions = _authorizeForTarget(getTargetName(), PUBLIC_ROLE());
+          _authorize(functions, BasicOracle.respond.selector, "respond");
+     }
+}
+

package/contracts/oracle/IOracle.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.20;
 
 import {NftId} from "../type/NftId.sol";
+import {RequestId} from "../type/RequestId.sol";
 import {Timestamp} from "../type/Timestamp.sol";
 
 
@@ -17,4 +18,19 @@ interface IOracle {
         Timestamp expiredAt; // expiry timestamp
         bool isCancelled;
     }
+
+
+    /// @dev Callback function for oracle service to notify this oracle component to retreive some oracle data.
+    function request(
+        RequestId requestId,
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    ) external;
+
+
+    /// @dev Callback function for oracle service to notify this oracle component that the specified oracle request has ben cancelled by the requestor.
+    function cancel(
+        RequestId requestId
+    ) external;
 }

package/contracts/oracle/IOracleComponent.sol

@@ -11,7 +11,8 @@ import {UFixed} from "../type/UFixed.sol";
 import {Timestamp} from "../type/Timestamp.sol";
 
 interface IOracleComponent is IInstanceLinkedComponent {
-
+    error ErrorOracleNotImplemented(string methodName);
+    
     /// @dev callback method for requesting some data from the oracle
     function request(
         RequestId requestId,

package/contracts/oracle/Oracle.sol

@@ -1,18 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {Amount} from "../type/Amount.sol";
 import {COMPONENT, ORACLE} from "../type/ObjectType.sol";
-import {IOracleService} from "./IOracleService.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
-import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
+import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
 import {IOracleComponent} from "./IOracleComponent.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {InstanceReader} from "../instance/InstanceReader.sol";
+import {IOracleService} from "./IOracleService.sol";
+import {NftId} from "../type/NftId.sol";
+import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
 import {RequestId} from "../type/RequestId.sol";
-import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
-import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
-import {UFixed} from "../type/UFixed.sol";
+import {Timestamp} from "../type/Timestamp.sol";
 
 
 abstract contract Oracle is
@@ -28,38 +27,41 @@ abstract contract Oracle is
     }
 
 
-    function initializeOracle(
-        address registry,
-        NftId instanceNftId,
-        address initialOwner,
-        string memory name,
-        address token,
-        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
-        bytes memory componentData // component specifidc data 
-    )
-        public
+    function register()
+        external
         virtual
-        onlyInitializing()
+        onlyOwner()
     {
-        initializeInstanceLinkedComponent(registry, instanceNftId, name, token, ORACLE(), true, initialOwner, registryData, componentData);
+        _getOracleStorage()._componentService.registerOracle();
+    }
 
-        OracleStorage storage $ = _getOracleStorage();
-        $._oracleService = IOracleService(_getServiceAddress(ORACLE())); 
-        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
 
-        registerInterface(type(IOracleComponent).interfaceId);
+    function request(
+        RequestId requestId,
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
+    )
+        external
+        virtual
+        restricted()
+    {
+        _request(requestId, requesterId, requestData, expiryAt);
     }
 
 
-    function register()
+    function cancel(
+        RequestId requestId
+    )
         external
         virtual
-        onlyOwner()
+        restricted()
     {
-        _getOracleStorage()._componentService.registerOracle();
+        _cancel(requestId);
     }
 
 
+    /// @dev Not relevant for oracle components, always returns false.
     function isVerifying()
         external 
         virtual 
@@ -69,36 +71,55 @@ abstract contract Oracle is
         return false;
     }
 
-
-    function request(
-        RequestId requestId,
-        NftId requesterId,
-        bytes calldata requestData,
-        Timestamp expiryAt
-    )
+    function withdrawFees(Amount amount)
         external
         virtual
-        // restricted() // TODO enable: only oracle service
+        override(IInstanceLinkedComponent, InstanceLinkedComponent)
+        onlyOwner()
+        restricted()
+        returns (Amount withdrawnAmount)
     {
-        _request(requestId, requesterId, requestData, expiryAt);
+        revert ErrorOracleNotImplemented("withdrawFees");
     }
 
 
-    function cancel(
-        RequestId requestId
+    function _initializeOracle(
+        address registry,
+        NftId instanceNftId,
+        IAuthorization authorization,
+        address initialOwner,
+        string memory name,
+        address token,
+        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
+        bytes memory componentData // component specifidc data 
     )
-        external
+        internal
         virtual
-        // restricted() // TODO enable: only oracle service
+        onlyInitializing()
     {
-        _cancel(requestId);
+        _initializeInstanceLinkedComponent(
+            registry, 
+            instanceNftId, 
+            name, 
+            token, 
+            ORACLE(), 
+            authorization,
+            true, 
+            initialOwner, 
+            registryData, 
+            componentData);
+
+        OracleStorage storage $ = _getOracleStorage();
+        $._oracleService = IOracleService(_getServiceAddress(ORACLE())); 
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT())); 
+
+        registerInterface(type(IOracleComponent).interfaceId);
     }
 
 
-    /// @dev internal function for handling requests.
-    /// empty implementation.
-    /// overwrite this function to implement use case specific handling
-    /// for oracle calls.
+    /// @dev Internal function for handling requests.
+    /// Empty implementation.
+    /// Overwrite this function to implement use case specific handling for oracle calls.
     function _request(
         RequestId requestId,
         NftId requesterId,
@@ -111,9 +132,9 @@ abstract contract Oracle is
     }
 
 
-    /// @dev internal function for cancelling requests.
-    /// empty implementation.
-    /// overwrite this function to implement use case specific cancelling
+    /// @dev Internal function for cancelling requests.
+    /// Empty implementation.
+    /// Overwrite this function to implement use case specific cancelling.
     function _cancel(
         RequestId requestId
     )
@@ -123,9 +144,9 @@ abstract contract Oracle is
     }
 
 
-    /// @dev internal function for handling oracle responses.
-    /// use this function in use case specific external/public functions
-    /// to handle use case specific response handling.
+    /// @dev Internal function for handling oracle responses.
+    /// Default implementation sends response back to oracle service.
+    /// Use this function in use case specific external/public functions to handle use case specific response handling.
     function _respond(
         RequestId requestId,
         bytes memory responseData

package/contracts/oracle/OracleServiceManager.sol

@@ -1,12 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IVersionable} from "../shared/IVersionable.sol";
-import {ProxyManager} from "../shared/ProxyManager.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {OracleService} from "./OracleService.sol";
-import {Registry} from "../registry/Registry.sol";
-import {RegistryService} from "../registry/RegistryService.sol";
-import {REGISTRY} from "../type/ObjectType.sol";
 
 contract OracleServiceManager is ProxyManager {