@etherisc/gif-next 3.0.0-a511887-523 → 3.0.0-ab05e7d-681

package/contracts/examples/flight/FlightProductAuthorization.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccess} from "../../../contracts/authorization/IAccess.sol";
+
+import {AccessAdminLib} from "../../authorization/AccessAdminLib.sol";
+import {BasicProductAuthorization} from "../../product/BasicProductAuthorization.sol";
+import {FlightProduct} from "./FlightProduct.sol";
+import {ORACLE} from "../../../contracts/type/ObjectType.sol";
+import {RoleId, ADMIN_ROLE, PUBLIC_ROLE} from "../../../contracts/type/RoleId.sol";
+
+
+contract FlightProductAuthorization
+    is BasicProductAuthorization
+{
+
+    uint64 public constant STATISTICS_PROVIDER_ROLE_IDX = 1; // 1st custom role for flight product
+    string public constant STATISTICS_PROVIDER_ROLE_NAME = "StatisticsProviderRole";
+    RoleId public STATISTICS_PROVIDER_ROLE;
+
+
+    constructor(string memory productName)
+        BasicProductAuthorization(productName)
+    { }
+
+
+    function _setupRoles()
+        internal
+        override
+    {
+        STATISTICS_PROVIDER_ROLE = AccessAdminLib.getCustomRoleId(STATISTICS_PROVIDER_ROLE_IDX);
+
+        _addRole(
+            STATISTICS_PROVIDER_ROLE,
+            AccessAdminLib.roleInfo(
+                ADMIN_ROLE(),
+                TargetType.Custom,
+                1, // max member count special case: instance nft owner is sole role owner
+                STATISTICS_PROVIDER_ROLE_NAME));
+    }
+
+
+    function _setupTargetAuthorizations()
+        internal
+        virtual override
+    {
+        super._setupTargetAuthorizations();
+        IAccess.FunctionInfo[] storage functions;
+
+        // authorize oracle service
+        functions = _authorizeForTarget(getMainTargetName(), getServiceRole(ORACLE()));
+        _authorize(functions, FlightProduct.flightStatusCallback.selector, "flightStatusCallback");
+
+        // authorize statistics provider role 
+        functions = _authorizeForTarget(getMainTargetName(), STATISTICS_PROVIDER_ROLE);
+        _authorize(functions, FlightProduct.createPolicyWithPermit.selector, "createPolicyWithPermit");
+
+        // authorize public role (additional authz via onlyOwner)
+        functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
+        _authorize(functions, FlightProduct.resendRequest.selector, "resendRequest");
+        _authorize(functions, FlightProduct.processPayoutsAndClosePolicies.selector, "processPayoutsAndClosePolicies");
+        _authorize(functions, FlightProduct.setConstants.selector, "setConstants");
+        _authorize(functions, FlightProduct.setTestMode.selector, "setTestMode");
+        _authorize(functions, FlightProduct.setDefaultBundle.selector, "setDefaultBundle");
+        _authorize(functions, FlightProduct.approveTokenHandler.selector, "approveTokenHandler");
+        _authorize(functions, FlightProduct.setLocked.selector, "setLocked");
+        _authorize(functions, FlightProduct.setWallet.selector, "setWallet");
+    }
+}
+

package/contracts/examples/flight/FlightProductManager.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAuthorization} from "../../authorization/IAuthorization.sol";
+import {IVersionable} from "../../upgradeability/IVersionable.sol";
+
+import {NftId} from "../../type/NftId.sol";
+import {ProxyManager} from "../../upgradeability/ProxyManager.sol";
+import {FlightProduct} from "./FlightProduct.sol";
+
+
+contract FlightProductManager is ProxyManager {
+
+    FlightProduct private _flightProduct;
+    bytes32 private _salt = "0x1234";
+
+    /// @dev initializes proxy manager with flight product implementation 
+    constructor(
+        address registry,
+        NftId instanceNftId,
+        string memory componentName,
+        IAuthorization authorization
+    ) 
+    {
+        // FlightProduct prd = new FlightProduct{salt: _salt}();
+        // bytes memory data = abi.encode(
+        //     registry, 
+        //     instanceNftId, 
+        //     componentName, 
+        //     authorization);
+
+        // IVersionable versionable = initialize(
+        //     registry,
+        //     address(prd), 
+        //     data,
+        //     _salt);
+
+        // _flightProduct = FlightProduct(address(versionable));
+    }
+
+    //--- view functions ----------------------------------------------------//
+    function getFlightProduct()
+        external
+        view
+        returns (FlightProduct flightProduct)
+    {
+        return _flightProduct;
+    }
+}

package/contracts/examples/flight/FlightUSD.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
+
+/// @dev FireUSD is a stablecoin with 6 decimals and an initial supply of 1 Billion tokens. 
+contract FlightUSD is ERC20Permit {
+
+    string public constant NAME = "FlightUSD";
+    string public constant SYMBOL = "FLTD";
+    uint8 public constant DECIMALS = 6;
+    uint256 public constant INITIAL_SUPPLY = 10**12 * 10**DECIMALS; // 1'000'000'000'000
+    
+    constructor()
+        ERC20Permit(NAME)
+        ERC20(NAME, SYMBOL)
+    {
+        _mint(
+            _msgSender(),
+            INITIAL_SUPPLY
+        );   
+    }
+
+    function decimals() public pure override returns(uint8) {
+        return DECIMALS;
+    }
+}

package/contracts/examples/flight/originalV1.sol

@@ -0,0 +1,396 @@
+// SPDX-License-Identifier: Apache-2.0
+// pragma solidity ^0.8.20;
+pragma solidity ^0.8.20;
+
+// import "@etherisc/gif-interface/contracts/0.7/Product.sol";
+
+// contract FlightDelayChainlink is Product {
+contract FlightDelayChainlink {
+
+    bytes32 public constant NAME = "FlightDelayChainlink";
+    bytes32 public constant VERSION = "0.1.6";
+
+    event LogRequestFlightRatings(uint256 requestId, bytes32 carrierFlightNumber, uint256 departureTime, uint256 arrivalTime, bytes32 riskId);
+    event LogRequestFlightStatus(uint256 requestId, uint256 arrivalTime, bytes32 carrierFlightNumber, bytes32 departureYearMonthDay);
+    event LogPayoutTransferred(bytes32 bpKey, uint256 claimId, uint256 payoutId, uint256 amount);
+    event LogError(string error, uint256 index, uint256 stored, uint256 calculated);
+    event LogUnprocessableStatus(bytes32 bpKey, uint256 requestId);
+    event LogPolicyExpired(bytes32 bpKey);
+    event LogRequestPayment(bytes32 bpKey, uint256 requestId);
+    event LogUnexpectedStatus(bytes32 bpKey, uint256 requestId, bytes1 status, int256 delay, address customer);
+
+    event LogCallback(bytes32 _bytes, bytes _data);
+
+
+    bytes32 public constant POLICY_FLOW = "PolicyFlowDefault";
+
+    // Minimum observations for valid prediction
+    uint256 public constant MIN_OBSERVATIONS = 10;
+    // Minimum time before departure for applying
+    uint256 public constant MIN_TIME_BEFORE_DEPARTURE = 14 * 24 hours;
+    // Maximum time before departure for applying
+    uint256 public constant MAX_TIME_BEFORE_DEPARTURE = 90 * 24 hours;
+    // Maximum duration of flight
+    uint256 public constant MAX_FLIGHT_DURATION = 2 days;
+    // Check for delay after .. minutes after scheduled arrival
+    uint256 public constant CHECK_OFFSET = 1 hours;
+
+    // uint256 public constant MIN_PREMIUM = 15 * 10 ** 18; // production
+    // All amounts in cent = multiplier is 10 ** 16!
+    uint256 public constant MIN_PREMIUM = 1500 * 10 ** 16; // for testing purposes
+    uint256 public constant MAX_PREMIUM = 1500 * 10 ** 16; // in cent
+    uint256 public constant MAX_PAYOUT = 75000  * 10 ** 16; // in cent
+    uint256 public constant MARGIN_PERCENT = 30;
+    string public constant RATINGS_CALLBACK = "flightRatingsCallback";
+    string public constant STATUSES_CALLBACK = "flightStatusCallback";
+
+    // ['observations','late15','late30','late45','cancelled','diverted']
+    uint8[6] public weightPattern = [0, 0, 0, 30, 50, 50];
+    uint8 public constant maxWeight = 50;
+
+    // Maximum cumulated weighted premium per risk
+    uint256 public constant MAX_TOTAL_PAYOUT = 3 * MAX_PAYOUT; // Maximum risk per flight is 3x max payout.
+
+    struct Risk {
+        bytes32 carrierFlightNumber;
+        bytes32 departureYearMonthDay;
+        uint256 departureTime;
+        uint256 arrivalTime;
+        uint delayInMinutes;
+        uint8 delay;
+        uint256 estimatedMaxTotalPayout;
+        uint256 premiumMultiplier;
+        uint256 weight;
+    }
+
+    mapping(bytes32 => Risk) public risks;
+    mapping(bytes32 => address) public bpKeyToAddress;
+    mapping(address => bytes32[]) public addressToBpKeys;
+    mapping(address => uint256) public addressToPolicyCount;
+
+    uint256 public uniqueIndex;
+    bytes32 public ratingsOracleType;
+    uint256 public ratingsOracleId;
+    bytes32 public statusesOracleType;
+    uint256 public statusesOracleId;
+
+    address public owner;
+
+    uint256 public productId;
+
+    // empty modifier to support compiling without inheritance from V1 product
+    modifier onlyOwner() { _; }
+    modifier onlyOracle() { _; }
+
+    constructor(
+        address _productServiceAddress,
+        bytes32 _ratingsOracleType,
+        uint256 _ratingsOracleId,
+        bytes32 _statusesOracleType,
+        uint256 _statusesOracleId
+    )
+        // Product(_productServiceAddress, NAME, POLICY_FLOW)
+    {
+        setOracles(_ratingsOracleType, _ratingsOracleId, _statusesOracleType, _statusesOracleId);
+    }
+
+    function setOracles(
+        bytes32 _ratingsOracleType,
+        uint256 _ratingsOracleId,
+        bytes32 _statusesOracleType,
+        uint256 _statusesOracleId
+    )
+        public
+        onlyOwner
+    {
+        ratingsOracleType = _ratingsOracleType;
+        ratingsOracleId = _ratingsOracleId;
+        statusesOracleType = _statusesOracleType;
+        statusesOracleId = _statusesOracleId;
+    }
+
+    function uniqueId(address _addr)
+        internal
+        returns (bytes32 _uniqueId)
+    {
+        uniqueIndex += 1;
+        return keccak256(abi.encode(_addr, productId, uniqueIndex));
+    }
+
+    function getValue() internal returns(uint256) {
+        return msg.value;
+    }
+
+    function applyForPolicy(
+        // domain specific
+        bytes32 _carrierFlightNumber,
+        bytes32 _departureYearMonthDay,
+        uint256 _departureTime,
+        uint256 _arrivalTime,
+        uint256[5] memory _payouts
+    ) external payable {
+        // Validate input parameters
+
+        uint256 premium = getValue();
+        bytes32 bpKey = uniqueId(msg.sender);
+
+        require(premium >= MIN_PREMIUM, "ERROR:FDD-001:INVALID_PREMIUM");
+        require(premium <= MAX_PREMIUM, "ERROR:FDD-002:INVALID_PREMIUM");
+        require(_arrivalTime > _departureTime, "ERROR:FDD-003:ARRIVAL_BEFORE_DEPARTURE_TIME");
+        /* for demo uncommented ********************************************************/
+        require(
+            _arrivalTime <= _departureTime + MAX_FLIGHT_DURATION,
+            "ERROR:FDD-004:INVALID_ARRIVAL/DEPARTURE_TIME"
+        );
+        require(
+            _departureTime >= block.timestamp + MIN_TIME_BEFORE_DEPARTURE,
+            "ERROR:FDD-012:INVALID_ARRIVAL/DEPARTURE_TIME"
+        );
+        require(
+            _departureTime <= block.timestamp + MAX_TIME_BEFORE_DEPARTURE,
+            "ERROR:FDD-005:INVALID_ARRIVAL/DEPARTURE_TIME"
+        );
+
+        // Create risk if not exists
+        bytes32 riskId = keccak256(abi.encode(_carrierFlightNumber, _departureTime, _arrivalTime));
+        Risk storage risk = risks[riskId];
+
+        if (risk.carrierFlightNumber == "") {
+            risk.carrierFlightNumber = _carrierFlightNumber;
+            risk.departureYearMonthDay = _departureYearMonthDay;
+            risk.departureTime = _departureTime;
+            risk.arrivalTime = _arrivalTime;
+        }
+
+        require (
+            premium * risk.premiumMultiplier + risk.estimatedMaxTotalPayout < MAX_TOTAL_PAYOUT,
+            "ERROR:FDD-006:CLUSTER_RISK"
+        );
+
+        // if this is the first policy for this flight,
+        // we "block" this risk by setting risk.estimatedMaxTotalPayout to
+        // the maximum. Next flight for this risk can only be insured after this one has been underwritten.
+        if (risk.estimatedMaxTotalPayout == 0) {
+            risk.estimatedMaxTotalPayout = MAX_TOTAL_PAYOUT;
+        }
+
+        // Create new application
+        // _newApplication(bpKey, abi.encode(premium, _payouts, msg.sender, riskId));
+
+        // // Request flight ratings
+        uint256 requestId; // = _request(
+        //     bpKey,
+        //     abi.encode(_carrierFlightNumber),
+        //     RATINGS_CALLBACK,
+        //     ratingsOracleType,
+        //     ratingsOracleId
+        // );
+
+        emit LogRequestFlightRatings(
+            requestId,
+            _carrierFlightNumber,
+            _departureTime,
+            _arrivalTime,
+            riskId
+        );
+
+        /**
+         * Record bpKey to address relation for easier lookup.
+         */
+        bpKeyToAddress[bpKey] = msg.sender;
+        addressToBpKeys[msg.sender].push(bpKey);
+        addressToPolicyCount[msg.sender] += 1;
+
+    }
+
+    function checkApplication(
+        bytes32 _carrierFlightNumber,
+        uint256 _departureTime,
+        uint256 _arrivalTime,
+        uint256 _premium
+    )
+    external view
+    returns (uint256 errors)
+    {
+        // Validate input parameters
+        if (_premium < MIN_PREMIUM) errors = errors | (uint256(1) << 0);
+        if (_premium > MAX_PREMIUM) errors = errors | (uint256(1) << 1);
+        if (_arrivalTime < _departureTime) errors = errors | (uint256(1) << 2);
+        if (_arrivalTime > _departureTime + MAX_FLIGHT_DURATION) errors = errors | (uint256(1) << 3);
+        if (_departureTime < block.timestamp + MIN_TIME_BEFORE_DEPARTURE) errors = errors | (uint256(1) << 4);
+        if (_departureTime > block.timestamp + MAX_TIME_BEFORE_DEPARTURE) errors = errors | (uint256(1) << 5);
+        bytes32 riskId = keccak256(abi.encode(_carrierFlightNumber, _departureTime, _arrivalTime));
+        Risk storage risk = risks[riskId];
+        if (_premium * risk.premiumMultiplier + risk.estimatedMaxTotalPayout >= MAX_TOTAL_PAYOUT) errors = errors | (uint256(1) << 6);
+
+        return errors;
+    }
+
+    function declineAndPayback(bytes32 _bpKey, address payable _customer, uint256 _premium)
+        internal
+    {
+        // _decline(_bpKey);
+        // _customer.transfer(_premium);
+    }
+
+    function flightRatingsCallback(
+        uint256 _requestId,
+        bytes32 _bpKey,
+        bytes calldata _response
+    ) external onlyOracle {
+
+        // Statistics: ['observations','late15','late30','late45','cancelled','diverted']
+        uint256[6] memory _statistics = abi.decode(_response, (uint256[6]));
+        uint256 premium;
+        uint256[5] memory payouts;
+        address payable customer;
+        // (uint256 premium, uint256[5] memory payouts, address payable customer, bytes32 riskId) =
+        // abi.decode(_getApplicationData(_bpKey), (uint256,uint256[5],address,bytes32));
+        // if (_statistics[0] < MIN_OBSERVATIONS) {
+        //     declineAndPayback(_bpKey, customer, premium);
+        //     return;
+        // }
+
+        (uint256 weight, uint256[5] memory calculatedPayouts) = calculatePayouts(premium, _statistics);
+        Risk storage risk; // = risks[riskId];
+
+        for (uint256 i = 0; i < 5; i++) {
+            if (calculatedPayouts[i] > MAX_PAYOUT) {
+                emit LogError("ERROR:FDD-007:PAYOUT_GT_MAXPAYOUT", i, payouts[i], calculatedPayouts[i]);
+                declineAndPayback(_bpKey, customer, premium);
+                return;
+            }
+            if (calculatedPayouts[i] != payouts[i]) {
+                emit LogError("ERROR:FDD-008:INVALID_PAYOUT_OPTION", i, payouts[i], calculatedPayouts[i]);
+                declineAndPayback(_bpKey, customer, premium);
+                return;
+            }
+        }
+
+        // It's the first policy for this risk, we accept any premium
+        // REMARK: all policy holders for this flight will share the same max payout estimates
+        // trends during the onboarding of policies are not considered
+        // if (risk.premiumMultiplier == 0) {
+        //     risk.premiumMultiplier = maxWeight * 10000 / weight;
+        //     risk.estimatedMaxTotalPayout = 0;
+        // }
+        // uint256 estimatedMaxPayout = premium * risk.premiumMultiplier;
+        // if (estimatedMaxPayout > MAX_PAYOUT) { estimatedMaxPayout = MAX_PAYOUT; }
+        // risk.estimatedMaxTotalPayout = risk.estimatedMaxTotalPayout + estimatedMaxPayout;
+        // risk.weight = weight;
+
+        // _underwrite(_bpKey);
+
+        // uint256 requestId = _request(
+        //     _bpKey,
+        //     abi.encode(
+        //         risk.arrivalTime + CHECK_OFFSET,
+        //         risk.carrierFlightNumber,
+        //         risk.departureYearMonthDay
+        //     ),
+        //     STATUSES_CALLBACK,
+        //     statusesOracleType,
+        //     statusesOracleId
+        // );
+
+        // Now everything is prepared
+        // address(RiskPool).transfer(premium);
+
+        // emit LogRequestFlightStatus(
+        //     requestId,
+        //     risk.arrivalTime + CHECK_OFFSET,
+        //     risk.carrierFlightNumber,
+        //     risk.departureYearMonthDay
+        // );
+    }
+
+    function flightStatusCallback(uint256 _requestId, bytes32 _bpKey, bytes calldata _response)
+        external
+        onlyOracle
+    {
+        (bytes1 status, int256 delay) = abi.decode(_response, (bytes1, int256));
+        // (/* uint256 premium */, uint256[5] memory payouts, address payable customer, /* bytes32 riskId */) =
+        // abi.decode(_getApplicationData(_bpKey), (uint256,uint256[5],address,bytes32));
+
+        if (status != "L" && status != "A" && status != "C" && status != "D") {
+            emit LogUnprocessableStatus(_bpKey, _requestId);
+            return;
+        }
+
+        if (status == "A") {
+            // todo: active, reschedule oracle call + 45 min
+            // emit LogUnexpectedStatus(_bpKey, _requestId, status, delay, customer);
+            return;
+        }
+
+        // if (status == "C") {
+        //     resolvePayout(_bpKey, payouts[3], customer);
+        // } else if (status == "D") {
+        //     resolvePayout(_bpKey, payouts[4], customer);
+        // } else if (delay >= 15 && delay < 30) {
+        //     resolvePayout(_bpKey, payouts[0], customer);
+        // } else if (delay >= 30 && delay < 45) {
+        //     resolvePayout(_bpKey, payouts[1], customer);
+        // } else if (delay >= 45) {
+        //     resolvePayout(_bpKey, payouts[2], customer);
+        // } else {
+        //     resolvePayout(_bpKey, 0, customer);
+        // }
+    }
+
+    function resolvePayout(bytes32 _bpKey, uint256 _payoutAmount, address payable _customer) internal {
+        if (_payoutAmount == 0) {
+            // _expire(_bpKey);
+            emit LogPolicyExpired(_bpKey);
+        } else {
+            // uint256 claimId = _newClaim(_bpKey, abi.encode(_payoutAmount));
+            // uint256 payoutId = _confirmClaim(_bpKey, claimId, abi.encode(_payoutAmount));
+            // _payout(_bpKey, payoutId, true, abi.encode(_payoutAmount));
+            _customer.transfer(_payoutAmount);
+            // emit LogPayoutTransferred(_bpKey, claimId, payoutId, _payoutAmount);
+        }
+    }
+
+    function calculatePayouts(uint256 _premium, uint256[6] memory _statistics)
+        public
+        view
+        returns (uint256 _weight, uint256[5] memory _payoutOptions)
+    {
+        require(_premium >= MIN_PREMIUM, "ERROR:FDD-009:INVALID_PREMIUM");
+        require(_premium <= MAX_PREMIUM, "ERROR:FDD-010:INVALID_PREMIUM");
+        require(_statistics[0] >= MIN_OBSERVATIONS, "ERROR:FDD-011:LOW_OBSERVATIONS");
+
+        _weight = 0;
+        _payoutOptions = [uint256(0), 0, 0, 0, 0];
+
+        for (uint256 i = 1; i < 6; i++) {
+            _weight += weightPattern[i] * _statistics[i] * 10000 / _statistics[0];
+            // 1% = 100 / 100% = 10,000
+        }
+
+        // To avoid div0 in the payout section, we have to make a minimal assumption on weight
+        if (_weight == 0) {
+            _weight = 100000 / _statistics[0];
+        }
+
+        _weight = _weight * (100 + MARGIN_PERCENT) / 100;
+
+        for (uint256 i = 0; i < 5; i++) {
+            _payoutOptions[i] = _premium * weightPattern[i + 1] * 10000 / _weight;
+
+            if (_payoutOptions[i] > MAX_PAYOUT) {
+                _payoutOptions[i] = MAX_PAYOUT;
+            }
+        }
+    }
+
+    function faucet(uint256 _amount) // for testing only
+        public
+        onlyOwner
+    {
+        require(_amount <= address(this).balance);
+        address payable receiver;
+        receiver = payable(owner);
+        receiver.transfer(_amount);
+    }
+}

package/contracts/instance/BaseStore.sol

@@ -42,6 +42,8 @@ abstract contract BaseStore is
         metadata.objectType = objectType;
         metadata.state = initialState;
         metadata.updatedIn = blocknumber;
+
+        emit LogBaseStoreMetadataCreated(key32, objectType, initialState);
     }
 
     function _updateState(
@@ -73,6 +75,8 @@ abstract contract BaseStore is
 
         // update metadata
         metadata.updatedIn = BlocknumberLib.current();
+        
+        emit LogBaseStoreMetadataUpdated(key32, oldState, state);
     }
 
     function exists(Key32 key32) public view returns (bool) {

package/contracts/instance/IBaseStore.sol

@@ -17,6 +17,14 @@ interface IBaseStore is ILifecycle {
     error ErrorBaseStoreStateZero(Key32 key);
     error ErrorBaseStoreNotExisting(Key32 key);
 
+    event LogBaseStoreMetadataCreated(
+        Key32 indexed key,
+        ObjectType indexed objectType,
+        StateId indexed state);
+    event LogBaseStoreMetadataUpdated(
+        Key32 indexed key,
+        StateId indexed oldState,
+        StateId indexed newState);
 
     struct Metadata {
         // slot 0

package/contracts/instance/IInstance.sol

@@ -143,7 +143,7 @@ interface IInstance is
 
     // get products
     function products() external view returns (uint256 productCount);
-    function getProductNftId(uint256 idx) external view returns (NftId productNftId);
+    function getProduct(uint256 idx) external view returns (NftId productNftId);
 
     // get supporting contracts
     function getInstanceReader() external view returns (InstanceReader);

package/contracts/instance/IInstanceService.sol

@@ -58,6 +58,8 @@ interface IInstanceService is IService {
     
     event LogInstanceServiceInstanceLocked(NftId instanceNftId, bool locked);
     event LogInstanceServiceInstanceCreated(NftId instanceNftId, address instance);
+    event LogInstanceServiceMasterInstanceRegistered(NftId masterInstanceNftId, address masterInstance, address masterInstanceAdmin, address masterAccessManager, 
+                address masterInstanceReader, address masterInstanceBundleSet, address masterInstanceRiskSet, address masterInstanceStore, address masterProductStore);
     event LogInstanceServiceMasterInstanceReaderUpgraded(NftId instanceNfId, address newInstanceReader);
     event LogInstanceServiceInstanceReaderUpgraded(NftId instanceNfId, address newInstanceReader);
 

package/contracts/instance/Instance.sol

@@ -26,6 +26,8 @@ contract Instance is
     IInstance,
     Registerable
 {
+    bool private _initialized;
+
     IComponentService internal _componentService;
     IInstanceService internal _instanceService;
 
@@ -58,6 +60,7 @@ contract Instance is
     function initialize(
         InstanceContracts memory instanceContracts,
         IRegistry registry, 
+        VersionPart release,
         address initialOwner,
         bool tokenRegistryDisabled // only disable for testing
     ) 
@@ -97,12 +100,12 @@ contract Instance is
         _componentService = IComponentService(
             getRegistry().getServiceAddress(
                 COMPONENT(), 
-                getRelease()));
+                release));
 
         _instanceService = IInstanceService(
             getRegistry().getServiceAddress(
                 INSTANCE(), 
-                getRelease()));
+                release));
 
         _tokenRegistryDisabled = tokenRegistryDisabled;
 
@@ -314,7 +317,7 @@ contract Instance is
         return _products.length;
     }
 
-    function getProductNftId(uint256 idx) external view returns (NftId productNftId) {
+    function getProduct(uint256 idx) external view returns (NftId productNftId) {
         return _products[idx];
     }