@etherisc/gif-next 3.0.0-ed516f2-751 → 3.0.0-ee35efe-784

package/contracts/oracle/IOracleComponent.sol

@@ -13,6 +13,10 @@ import {Timestamp} from "../type/Timestamp.sol";
 interface IOracleComponent is IInstanceLinkedComponent {
     error ErrorOracleNotImplemented(string methodName);
     
+    event LogOracleRequestReceived(RequestId indexed requestId, NftId indexed requesterId);
+    event LogOracleRequestCancelled(RequestId indexed requestId);
+
+
     /// @dev callback method for requesting some data from the oracle
     function request(
         RequestId requestId,
@@ -30,4 +34,10 @@ interface IOracleComponent is IInstanceLinkedComponent {
 
     /// @dev returns true iff the component needs to be called when selling/renewing policis
     function isVerifying() external view returns (bool verifying);
+
+    function activeRequests() external view returns(uint256 numberOfRequests);
+    
+    function getActiveRequest(uint256 idx) external view returns(RequestId requestId);
+
+    function isActiveRequest(RequestId requestId) external view returns(bool isActive);
 }

package/contracts/oracle/IOracleService.sol

@@ -63,4 +63,19 @@ interface IOracleService is IService {
     /// Permissioned: only the requester may cancel a request
     function cancel(RequestId requestId) external;
 
+    // FIXME: this should be done by request
+    function addRequest(RequestId requestId) external;
+
+    // FIXME: this could be done by respond, resend, cancel
+    function removeRequest(RequestId requestId) external;
+
+    // FIXME: move to instance reader
+    function activeRequests() external view returns(uint256 numberOfRequests);
+
+    // FIXME: move to instance reader
+    function activeRequestAt(uint256 idx) external view returns(RequestId requestId);
+
+    // FIXME: move to instance reader
+    function isActiveRequest(RequestId requestId) external view returns(bool isActive);
+
 }

package/contracts/oracle/Oracle.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
-import {COMPONENT, PRODUCT, ORACLE} from "../type/ObjectType.sol";
+import {COMPONENT, ORACLE} from "../type/ObjectType.sol";
 import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
 import {IInstanceLinkedComponent} from "../shared/IInstanceLinkedComponent.sol";
@@ -11,6 +11,7 @@ import {IOracleService} from "./IOracleService.sol";
 import {NftId} from "../type/NftId.sol";
 import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
 import {RequestId} from "../type/RequestId.sol";
+import {FULFILLED} from "../type/StateId.sol";
 import {Timestamp} from "../type/Timestamp.sol";
 
 
@@ -74,6 +75,33 @@ abstract contract Oracle is
         revert ErrorOracleNotImplemented("withdrawFees");
     }
 
+    function activeRequests()
+        external
+        view
+        returns(uint256 numberOfRequests)
+    {
+        OracleStorage storage $ = _getOracleStorage();
+        return $._oracleService.activeRequests();
+    }
+
+
+    function getActiveRequest(uint256 idx)
+        external
+        view
+        returns(RequestId requestId)
+    {
+        OracleStorage storage $ = _getOracleStorage();
+        return $._oracleService.activeRequestAt(idx);
+    }
+
+    function isActiveRequest(RequestId requestId)
+        external
+        view
+        returns(bool isActive)
+    {
+        OracleStorage storage $ = _getOracleStorage();
+        return $._oracleService.isActiveRequest(requestId);
+    }
 
     function __Oracle_init(
         address registry,
@@ -102,48 +130,67 @@ abstract contract Oracle is
         _registerInterface(type(IOracleComponent).interfaceId);
     }
 
-
-    /// @dev Internal function for handling requests.
-    /// Empty implementation.
-    /// Overwrite this function to implement use case specific handling for oracle calls.
-    function _request(
+    /// @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,
-        NftId requesterId,
-        bytes calldata requestData,
-        Timestamp expiryAt
+        bytes memory responseData
     )
         internal
         virtual
     {
+        _getOracleStorage()._oracleService.respond(requestId, responseData);
     }
 
-
-    /// @dev Internal function for cancelling requests.
-    /// Empty implementation.
-    /// Overwrite this function to implement use case specific cancelling.
-    function _cancel(
+    // check callback result
+    function _updateRequestState(
         RequestId requestId
     )
         internal
-        virtual
     {
+        bool requestFulfilled = _getInstanceReader().getRequestState(
+            requestId) == FULFILLED();
+        OracleStorage storage $ = _getOracleStorage();
+
+        // remove from active requests when successful
+        if (requestFulfilled && $._oracleService.isActiveRequest(requestId)) {
+            $._oracleService.removeRequest(requestId);
+        } 
     }
 
 
-    /// @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(
+    /// @dev use case specific handling of oracle requests
+    /// for now only log is emitted to verify that request has been received by oracle component 
+    function _request(
         RequestId requestId,
-        bytes memory responseData
+        NftId requesterId,
+        bytes calldata requestData,
+        Timestamp expiryAt
     )
         internal
-        virtual
+        virtual 
     {
-        _getOracleStorage()._oracleService.respond(
-            requestId, responseData);
+        OracleStorage storage $ = _getOracleStorage();
+        $._oracleService.addRequest(requestId);
+        emit LogOracleRequestReceived(requestId, requesterId);
     }
 
+
+    /// @dev use case specific handling of oracle requests
+    /// for now only log is emitted to verify that cancelling has been received by oracle component 
+    function _cancel(
+        RequestId requestId
+    )
+        internal
+        virtual 
+    {
+        OracleStorage storage $ = _getOracleStorage();
+        $._oracleService.removeRequest(requestId);
+        emit LogOracleRequestCancelled(requestId);
+    }
+
+
     function _getOracleStorage() private pure returns (OracleStorage storage $) {
         assembly {
             $.slot := ORACLE_STORAGE_LOCATION_V1

package/contracts/oracle/OracleService.sol

@@ -2,16 +2,14 @@
 pragma solidity ^0.8.20;
 
 import {ContractLib} from "../shared/ContractLib.sol";
-import {IComponent} from "../shared/IComponent.sol";
 import {IInstance} from "../instance/IInstance.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IOracle} from "./IOracle.sol";
 import {IOracleComponent} from "./IOracleComponent.sol";
 import {IOracleService} from "./IOracleService.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {NftId} from "../type/NftId.sol";
-import {ObjectType, COMPONENT, ORACLE, PRODUCT} from "../type/ObjectType.sol";
+import {ObjectType, ORACLE, PRODUCT} from "../type/ObjectType.sol";
 import {RequestId} from "../type/RequestId.sol";
 import {Service} from "../shared/Service.sol";
 import {StateId, ACTIVE, KEEP_STATE, FULFILLED, FAILED, CANCELLED} from "../type/StateId.sol";
@@ -217,6 +215,84 @@ contract OracleService is
         emit LogOracleServiceRequestCancelled(requestId, requesterNftId);
     }
 
+    function activeRequests() 
+        external 
+        view 
+        virtual 
+        returns(uint256 numberOfRequests) 
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyAnyComponent(
+            getRegistry(), msg.sender, true);
+        IInstance instance = IInstance(instanceAddress);
+
+
+        return instance.getRequestSet().activeRequests(info.nftId);
+    }
+
+    function activeRequestAt(uint256 idx) 
+        external 
+        view 
+        virtual 
+        returns(RequestId requestId) 
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyAnyComponent(
+            getRegistry(), msg.sender, true);
+        IInstance instance = IInstance(instanceAddress);
+
+        return instance.getRequestSet().activeRequestAt(info.nftId, idx);
+    }
+
+    function isActiveRequest(RequestId requestId) 
+        external 
+        view 
+        virtual 
+        returns(bool isActive) 
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyAnyComponent(
+            getRegistry(), msg.sender, true);
+        IInstance instance = IInstance(instanceAddress);
+
+        return instance.getRequestSet().contains(info.nftId, requestId);
+    }
+
+    function addRequest(RequestId requestId) 
+        external 
+        virtual 
+        restricted()
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyAnyComponent(
+            getRegistry(), msg.sender, true);
+        IInstance instance = IInstance(instanceAddress);
+
+        instance.getRequestSet().add(info.nftId, requestId);
+    }
+
+    function removeRequest(RequestId requestId) 
+        external 
+        virtual 
+        restricted()
+    {
+        (
+            IRegistry.ObjectInfo memory info, 
+            address instanceAddress
+        ) = ContractLib.getAndVerifyAnyComponent(
+            getRegistry(), msg.sender, true);
+        IInstance instance = IInstance(instanceAddress);
+
+        instance.getRequestSet().remove(info.nftId, requestId);
+    }
 
     function _checkRequestParams(
         IRegistry registry,

package/contracts/pool/BundleService.sol

@@ -130,7 +130,7 @@ contract BundleService is
         BundleSet bundleManager = instance.getBundleSet();
         bundleManager.add(bundleNftId);
 
-        emit LogBundleServiceBundleCreated(bundleNftId, poolNftId, lifetime);
+        emit LogBundleServiceBundleCreated(bundleNftId, poolNftId, lifetime, bundleFee.fixedFee, bundleFee.fractionalFee);
     }
 
 

package/contracts/pool/IBundleService.sol

@@ -30,7 +30,7 @@ interface IBundleService is IService {
 
     error ErrorBundleServiceExtensionLifetimeIsZero();
 
-    event LogBundleServiceBundleCreated(NftId bundleNftId, NftId poolNftId, Seconds lifetime);
+    event LogBundleServiceBundleCreated(NftId bundleNftId, NftId poolNftId, Seconds lifetime, Amount fixedFee, UFixed fractionalFee);
     event LogBundleServiceBundleClosed(NftId bundleNftId);
     event LogBundleServiceBundleLocked(NftId bundleNftId);
     event LogBundleServiceBundleUnlocked(NftId bundleNftId);

package/contracts/pool/IPoolService.sol

@@ -19,7 +19,7 @@ interface IPoolService is IService {
     event LogPoolServiceWalletDefunded(NftId poolNftId, address poolOwner, Amount amount);
 
     event LogPoolServiceBundleCreated(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
-    event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
+    event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount balanceAmount, Amount feeAmount);
 
     event LogPoolServiceBundleStaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
     event LogPoolServiceBundleUnstaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);

package/contracts/pool/PoolService.sol

@@ -98,7 +98,7 @@ contract PoolService is
             unstakedAmount +  feeAmount, 
             AmountLib.zero());
         
-        emit LogPoolServiceBundleClosed(instance.getNftId(), poolNftId, bundleNftId);
+        emit LogPoolServiceBundleClosed(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount, feeAmount);
 
         if ((unstakedAmount + feeAmount).gtz()){
             IComponents.ComponentInfo memory poolComponentInfo = instance.getInstanceReader().getComponentInfo(poolNftId);

package/contracts/product/IPolicyService.sol

@@ -13,7 +13,7 @@ interface IPolicyService is IService {
 
     event LogPolicyServicePolicyCreated(NftId policyNftId, Amount premiumAmount, Timestamp activatedAt);
     event LogPolicyServicePolicyDeclined(NftId policyNftId);
-    event LogPolicyServicePolicyPremiumCollected(NftId policyNftId, Amount premiumAmount);
+    event LogPolicyServicePolicyPremiumCollected(NftId policyNftId, NftId productNftId, Amount premiumAmount, Timestamp activateAt);
     event LogPolicyServicePolicyActivated(NftId policyNftId, Timestamp activatedAt);
     event LogPolicyServicePolicyActivatedUpdated(NftId policyNftId, Timestamp activatedAt);
     event LogPolicyServicePolicyExpirationUpdated(NftId policyNftId, Timestamp expiredAt);

package/contracts/product/PolicyService.sol

@@ -247,7 +247,7 @@ contract PolicyService is
         instance.getProductStore().updatePremiumState(policyNftId, PAID());
 
         // log premium collection before interactions with token
-        emit LogPolicyServicePolicyPremiumCollected(policyNftId, premium.premiumAmount);
+        emit LogPolicyServicePolicyPremiumCollected(policyNftId, policyInfo.productNftId, premium.premiumAmount, activateAt);
 
         // interactions
         _transferPremiumAmounts(instanceReader, policyNftId, policyInfo.productNftId, premium);

package/contracts/product/PolicyServiceLib.sol

@@ -95,13 +95,14 @@ library PolicyServiceLib {
     {
         if (policyState != COLLATERALIZED()) { 
             revert IPolicyService.ErrorPolicyServicePolicyNotActive(policyNftId, policyState);
-        } 
-        if (TimestampLib.current() < policyInfo.activatedAt) { 
+        }
+
+        if (policyInfo.activatedAt.eqz() || TimestampLib.current() < policyInfo.activatedAt) { 
             revert IPolicyService.ErrorPolicyServicePolicyNotActive(policyNftId, policyState);
         } 
 
         // check expiredAt represents a valid expiry time
-        if (newExpiredAt >= policyInfo.expiredAt) {
+        if (newExpiredAt > policyInfo.expiredAt) {
             revert IPolicyService.ErrorPolicyServicePolicyExpirationTooLate(policyNftId, policyInfo.expiredAt, newExpiredAt);
         }
 
@@ -110,6 +111,7 @@ library PolicyServiceLib {
         }
     }
 
+
     function policyIsCloseable(InstanceReader instanceReader, NftId policyNftId)
         external 
         view

package/contracts/registry/ChainNft.sol

@@ -11,7 +11,7 @@ contract ChainNft is ERC721Enumerable {
     event LogTokenInterceptorAddress(uint256 tokenId, address interceptor);
 
     // constants
-    string public constant NAME = "Dezentralized Insurance Protocol NFT";
+    string public constant NAME = "Decentralized Insurance Protocol NFT";
     string public constant SYMBOL = "DIPNFT";
 
     uint256 public constant PROTOCOL_NFT_ID = 1101;

package/contracts/registry/IRegistry.sol

@@ -20,7 +20,7 @@ interface IRegistry is
 {
 
     event LogRegistryObjectRegistered(NftId nftId, NftId parentNftId, ObjectType objectType, bool isInterceptor, address objectAddress, address initialOwner);
-    event LogRegistryServiceRegistered(VersionPart majorVersion, ObjectType domain);
+    event LogRegistryServiceRegistered(NftId nftId, VersionPart majorVersion, ObjectType domain);
     event LogRegistryChainRegistryRegistered(NftId nftId, uint256 chainId, address chainRegistryAddress);
 
     // initialize

package/contracts/registry/Registry.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.20;
 
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 
@@ -16,7 +15,6 @@ import {IRelease} from "./IRelease.sol";
 import {IRegisterable} from "../shared/IRegisterable.sol";
 import {IStaking} from "../staking/IStaking.sol";
 import {ReleaseRegistry} from "./ReleaseRegistry.sol";
-import {TokenRegistry} from "./TokenRegistry.sol";
 import {RegistryAdmin} from "./RegistryAdmin.sol";
 
 /// @dev IMPORTANT
@@ -231,7 +229,7 @@ contract Registry is
 
         _service[version][domain] = service;
 
-        emit LogRegistryServiceRegistered(version, domain);
+        emit LogRegistryServiceRegistered(info.nftId,version, domain);
 
         nftId = _register(info);
     }
@@ -566,6 +564,8 @@ contract Registry is
                 initialOwner: NFT_LOCK_ADDRESS,
                 data: ""}),
             true);
+
+        emit LogRegistryObjectRegistered(protocolNftId, NftIdLib.zero(), PROTOCOL(), false, address(0), NFT_LOCK_ADDRESS);
     }
 
     /// @dev register this registry
@@ -671,6 +671,8 @@ contract Registry is
 
         // calls nft receiver
         CHAIN_NFT.mint(info.initialOwner, info.nftId.toInt());
+
+        emit LogRegistryObjectRegistered(info.nftId, info.parentNftId, info.objectType, info.isInterceptor, info.objectAddress, info.initialOwner);
     }
 
     function _setAddressForNftId(NftId nftId, address objectAddress)

package/contracts/registry/RegistryAdmin.sol

@@ -85,7 +85,13 @@ contract RegistryAdmin is
                 registry, 
                 release); 
 
-        _checkAuthorization(authorization, REGISTRY(), release, false, true);
+        AccessAdminLib.checkAuthorization(
+            address(_authorization),
+            authorization, 
+            REGISTRY(), 
+            release, 
+            false, // expectServiceAuthorization
+            false); // checkAlreadyInitialized);
 
         _registry = registry;
         _authorization = IAuthorization(authorization);

package/contracts/registry/RegistryAuthorization.sol

@@ -144,8 +144,6 @@ contract RegistryAuthorization
           _setupStakingThAuthorization();
      }
 
-     event LogAccessAdminDebug(string message, string custom, uint256 value);
-
      function _setupRegistryAuthorization() internal {
           IAccess.FunctionInfo[] storage functions;
 

package/contracts/registry/ReleaseAdmin.sol

@@ -72,7 +72,14 @@ contract ReleaseAdmin is
                 release);
 
         IServiceAuthorization serviceAuthorization = IServiceAuthorization(authorization);
-        _checkAuthorization(address(serviceAuthorization), RELEASE(), release, true, true);
+        AccessAdminLib.checkAuthorization(
+            address(_authorization),
+            address(serviceAuthorization), 
+            RELEASE(), 
+            release, 
+            true, // expectServiceAuthorization
+            true); // checkAlreadyInitialized);
+
         _serviceAuthorization = serviceAuthorization;
 
         // link nft ownability to registry

package/contracts/registry/ServiceAuthorizationV3.sol

@@ -308,6 +308,8 @@ contract ServiceAuthorizationV3
           _authorize(functions, IOracleService.respond.selector, "respond");
           _authorize(functions, IOracleService.resend.selector, "resend");
           _authorize(functions, IOracleService.cancel.selector, "cancel");
+          _authorize(functions, IOracleService.addRequest.selector, "addRequest");
+          _authorize(functions, IOracleService.removeRequest.selector, "removeRequest");
      }
 
      function _setupApplicationServiceAuthorization()

package/contracts/shared/ComponentService.sol

@@ -312,9 +312,27 @@ contract ComponentService is
             productNftId, 
             initialProductInfo);
 
+        emit LogComponentServiceProductCreated(productNftId, productAddress, initialProductInfo.hasDistribution, initialProductInfo.expectedNumberOfOracles);
+
+        IComponents.FeeInfo memory initialFeeInfo = product.getInitialFeeInfo();
+        
         productStore.createFee(
             productNftId, 
-            product.getInitialFeeInfo());
+            initialFeeInfo);
+
+        emit LogComponentServiceProductInitialProductFeesSet(
+            productNftId, 
+            initialFeeInfo.productFee.fixedFee, initialFeeInfo.productFee.fractionalFee,
+            initialFeeInfo.processingFee.fixedFee, initialFeeInfo.processingFee.fractionalFee);
+        emit LogComponentServiceProductInitialDistributionFeesSet(
+            productNftId, 
+            initialFeeInfo.distributionFee.fixedFee, initialFeeInfo.distributionFee.fractionalFee,
+            initialFeeInfo.minDistributionOwnerFee.fixedFee, initialFeeInfo.minDistributionOwnerFee.fractionalFee);
+        emit LogComponentServiceProductInitialPoolFeesSet(
+            productNftId, 
+            initialFeeInfo.poolFee.fixedFee, initialFeeInfo.poolFee.fractionalFee,
+            initialFeeInfo.stakingFee.fixedFee, initialFeeInfo.stakingFee.fractionalFee,
+            initialFeeInfo.performanceFee.fixedFee, initialFeeInfo.performanceFee.fractionalFee);
     }
 
     //-------- distribution -------------------------------------------------//
@@ -341,6 +359,8 @@ contract ComponentService is
         // set distribution in product info
         productInfo.distributionNftId = distributionNftId;
         productStore.updateProduct(productNftId, productInfo, KEEP_STATE());
+
+        emit LogComponentServiceDistributionCreated(distributionNftId, productNftId);
     }
 
 
@@ -400,6 +420,8 @@ contract ComponentService is
         productInfo.oracleNftId[productInfo.numberOfOracles] = oracleNftId;
         productInfo.numberOfOracles++;
         productStore.updateProduct(productNftId, productInfo, KEEP_STATE());
+
+        emit LogComponentServiceOracleCreated(oracleNftId, productNftId);
     }
 
     //-------- pool ---------------------------------------------------------//
@@ -423,13 +445,20 @@ contract ComponentService is
 
         // create info
         IPoolComponent pool = IPoolComponent(componentAddress);
+        IComponents.PoolInfo memory initialPoolInfo = pool.getInitialPoolInfo();
         instanceStore.createPool(
             poolNftId, 
-            pool.getInitialPoolInfo());
+            initialPoolInfo);
 
         // update pool in product info
         productInfo.poolNftId = poolNftId;
         productStore.updateProduct(productNftId, productInfo, KEEP_STATE());
+
+        emit LogComponentServicePoolCreated(
+            poolNftId, productNftId, componentAddress, 
+            initialPoolInfo.maxBalanceAmount, initialPoolInfo.collateralizationLevel, 
+            initialPoolInfo.retentionLevel, initialPoolInfo.isExternallyManaged, 
+            initialPoolInfo.isVerifyingApplications);
     }
 
 
@@ -543,6 +572,11 @@ contract ComponentService is
             address(component), // initially, component is its own wallet
             token, 
             instanceAdmin.authority());
+
+        emit LogComponentServiceTokenHandlerDeployed(
+            componentNftId, 
+            address(componentInfo.tokenHandler), 
+            token);
         
         // register component with instance
         instanceStore.createComponent(

package/contracts/shared/IComponent.sol

@@ -25,10 +25,6 @@ interface IComponent is
     error ErrorComponentWalletAddressIsSameAsCurrent();
     error ErrorComponentWalletNotComponent();
 
-    event LogComponentWalletAddressChanged(address oldWallet, address newWallet);
-    event LogComponentWalletTokensTransferred(address from, address to, uint256 amount);
-    event LogComponentTokenHandlerApproved(address tokenHandler, address token, Amount limit, bool isMaxAmount);
-
     /// @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);

package/contracts/shared/IComponentService.sol

@@ -46,9 +46,8 @@ interface IComponentService is
     error ErrorComponentServiceWalletAllowanceTooSmall(address wallet, address spender, uint256 allowance, uint256 amount);
 
     event LogComponentServiceComponentLocked(address component, bool locked);
+    event LogComponentServiceTokenHandlerDeployed(NftId componentNftId, address tokenHandler, address token);
     event LogComponentServiceRegistered(NftId instanceNftId, NftId componentNftId, ObjectType componentType, address component, address token, address initialOwner); 
-    event LogComponentServiceWalletAddressChanged(NftId componentNftId, address currentWallet, address newWallet);
-    event LogComponentServiceWalletTokensTransferred(NftId componentNftId, address currentWallet, address newWallet, uint256 currentBalance);
     event LogComponentServiceComponentFeesWithdrawn(NftId componentNftId, address recipient, address token, Amount withdrawnAmount);
     event LogComponentServiceProductFeesUpdated(NftId productNftId);
     event LogComponentServiceDistributionFeesUpdated(NftId distributionNftId);
@@ -61,6 +60,29 @@ interface IComponentService is
         UFixed newFractionalFee, 
         Amount newFixedFee
     );
+    event LogComponentServiceProductCreated(
+        NftId indexed productNftId, address indexed productAddress, bool indexed hasDistribution, uint8 expectedNumberOfOracles);
+    event LogComponentServiceProductInitialProductFeesSet(
+        NftId indexed productNftId, 
+        Amount indexed productFeeFixed, UFixed indexed productFeeFractional,
+        Amount processingFeeFixed, UFixed processingFeeFractional);
+    event LogComponentServiceProductInitialDistributionFeesSet(
+        NftId indexed productNftId, 
+        Amount indexed distributionFeeFixed, UFixed indexed distributionFeeFractional,
+        Amount minDistributionOwnerFeeFixed, UFixed minDistributionOwnerFeeFractional);
+    event LogComponentServiceProductInitialPoolFeesSet(
+        NftId indexed productNftId, 
+        Amount indexed poolFeeFixed, UFixed indexed poolFeeFractional,
+        Amount stakingFeeFixed, UFixed stakingFeeFractional,
+        Amount performanceFeeFixed, UFixed performanceFeeFractional);
+    event LogComponentServicePoolCreated(
+        NftId indexed poolNftId, NftId indexed productNftId, address indexed componentAddress, 
+        Amount maxBalanceAmount, UFixed collateralizationLevel, UFixed retentionLevel, 
+        bool isExternallyManaged, bool isVerifyingApplications);
+    event LogComponentServiceDistributionCreated(
+        NftId indexed distributionNftId, NftId indexed productNftId);
+    event LogComponentServiceOracleCreated(
+        NftId indexed oracleNftId, NftId indexed productNftId);
     
     //-------- component ----------------------------------------------------//
 

package/contracts/shared/InstanceLinkedComponent.sol

@@ -92,7 +92,7 @@ abstract contract InstanceLinkedComponent is
     }
 
 
-    function _resendRequest(RequestId requestId)
+    function _resendResponse(RequestId requestId)
         internal
         virtual
     {

package/contracts/staking/IStaking.sol

@@ -25,6 +25,8 @@ interface IStaking is
     IVersionable
 {
 
+    event LogStakingTokenHandlerDeployed(NftId componentNftId, address tokenHandler, address token);
+    
     // owner functions
     event LogStakingStakingRateSet(ChainId chainId, address token, UFixed newStakingRate, UFixed oldStakingRate, Blocknumber lastUpdateIn);
     event LogStakingStakingServiceSet(address stakingService, VersionPart release, address oldStakingService);