@etherisc/gif-next 0.0.2-90f8ffc-398 → 0.0.2-9105e58-225

package/contracts/components/Component.sol

@@ -10,6 +10,7 @@ import {IProductService} from "../instance/service/IProductService.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IInstance} from "../instance/IInstance.sol";
 import {InstanceAccessManager} from "../instance/InstanceAccessManager.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {NftId} from "../types/NftId.sol";
 import {ObjectType, INSTANCE, PRODUCT} from "../types/ObjectType.sol";
@@ -17,9 +18,9 @@ import {VersionPart} from "../types/Version.sol";
 import {Registerable} from "../shared/Registerable.sol";
 import {RoleId, RoleIdLib} from "../types/RoleId.sol";
 import {IAccess} from "../instance/module/IAccess.sol";
+import {VersionPart} from "../types/Version.sol";
 
 // TODO discuss to inherit from oz accessmanaged
-// TODO make contract upgradeable
 // then add (Distribution|Pool|Product)Upradeable that also intherit from Versionable
 // same pattern as for Service which is also upgradeable
 abstract contract Component is
@@ -32,9 +33,11 @@ abstract contract Component is
 
     struct ComponentStorage {
         IInstance _instance; // instance for this component
+        InstanceReader _instanceReader; // instance reader for this component
         string _name; // unique (per instance) component name
         IERC20Metadata _token; // token for this component
         address _wallet; // wallet for this component (default = component contract itself)
+        bool _isNftInterceptor; // declares if component is involved in nft transfers
         IInstanceService _instanceService; // instance service for this component
 
         NftId _productNftId; // only relevant for components that are linked to a aproduct
@@ -42,6 +45,14 @@ abstract contract Component is
     }
 
 
+    modifier onlyChainNft() {
+        if(msg.sender != getRegistry().getChainNftAddress()) {
+            revert ErrorComponentNotChainNft(msg.sender);
+        }
+        _;
+    }
+
+
     modifier onlyProductService() {
         if(msg.sender != address(_getComponentStorage()._productService)) {
             revert ErrorComponentNotProductService(msg.sender);
@@ -49,26 +60,13 @@ abstract contract Component is
         _;
     }
 
-    constructor(
-        address registry,
-        NftId instanceNftId,
-        string memory name,
-        address token,
-        ObjectType componentType,
-        bool isInterceptor,
-        address initialOwner,
-        bytes memory data
-    ) {
-        _initializeComponent(registry, instanceNftId, name, token, componentType, isInterceptor, initialOwner, data);
-    }
-
     function _getComponentStorage() private pure returns (ComponentStorage storage $) {
         assembly {
             $.slot := CONTRACT_LOCATION_V1
         }
     }
 
-    function _initializeComponent(
+    function initializeComponent(
         address registry,
         NftId instanceNftId,
         string memory name,
@@ -78,15 +76,16 @@ abstract contract Component is
         address initialOwner,
         bytes memory data
     )
-        internal
-        initializer 
+        public
         virtual
+        onlyInitializing()
     {
         ComponentStorage storage $ = _getComponentStorage();
-        _initializeRegisterable(registry, instanceNftId, componentType, isInterceptor, initialOwner, data);
+        initializeRegisterable(registry, instanceNftId, componentType, isInterceptor, initialOwner, data);
 
         // set unique name of component
         $._name = name;
+        $._isNftInterceptor = isInterceptor;
 
         // set and check linked instance
         IRegistry.ObjectInfo memory instanceInfo = getRegistry().getObjectInfo(instanceNftId);
@@ -101,15 +100,25 @@ abstract contract Component is
         // set linked services
         VersionPart gifVersion = $._instance.getMajorVersion();
         $._instanceService = IInstanceService(getRegistry().getServiceAddress(INSTANCE(), gifVersion));
+        $._instanceReader = $._instance.getInstanceReader();
         $._productService = IProductService(getRegistry().getServiceAddress(PRODUCT(), gifVersion));
 
         // set wallet and token
         $._wallet = address(this);
         $._token = IERC20Metadata(token);
 
-        _registerInterface(type(IComponent).interfaceId);
+        registerInterface(type(IComponent).interfaceId);
     }
 
+    /// @dev callback function for nft transfers. may only be called by chain nft contract.
+    /// default implementation is empty. overriding functions MUST add onlyChainNft modifier
+    function nftTransferFrom(address from, address to, uint256 tokenId)
+        external
+        virtual override
+        onlyChainNft()
+    { }
+
+    // TODO discuss replacement with modifier restricted from accessmanaged
     function lock() external onlyOwner override {
         _getComponentStorage()._instanceService.setTargetLocked(getName(), true);
     }
@@ -137,7 +146,11 @@ abstract contract Component is
     /// if the current wallet has tokens, these will be transferred. 
     /// if the new wallet address is externally owned, an approval from the 
     /// owner of the external wallet for the component to move all tokens must exist. 
-    function setWallet(address newWallet) external override onlyOwner {
+    function setWallet(address newWallet)
+        external
+        override
+        onlyOwner
+    {
         ComponentStorage storage $ = _getComponentStorage();
 
         address currentWallet = $._wallet;
@@ -193,10 +206,23 @@ abstract contract Component is
         return _getComponentStorage()._token;
     }
 
+    function isNftInterceptor() public view override returns(bool isInterceptor) {
+        return _getComponentStorage()._isNftInterceptor;
+    }
+
     function getInstance() public view override returns (IInstance instance) {
         return _getComponentStorage()._instance;
     }
 
+    function getInstanceReader() public view returns (InstanceReader reader) {
+        return _getComponentStorage()._instanceReader;
+    }
+
+    function getServiceAddress(ObjectType domain) public view returns (address service) {
+        VersionPart majorVersion = getInstance().getMajorVersion();
+        return getRegistry().getServiceAddress(domain, majorVersion);
+    }
+
     function getName() public view override returns(string memory name) {
         return _getComponentStorage()._name;
     }

package/contracts/components/Distribution.sol

@@ -4,8 +4,8 @@ pragma solidity ^0.8.19;
 import {DISTRIBUTION} from "../types/ObjectType.sol";
 import {IDistributionService} from "../instance/service/IDistributionService.sol";
 import {IProductService} from "../instance/service/IProductService.sol";
-import {NftId, zeroNftId, NftIdLib} from "../types/NftId.sol";
-import {ReferralId} from "../types/Referral.sol";
+import {NftId, zeroNftId, NftIdLib, toNftId} from "../types/NftId.sol";
+import {ReferralId, ReferralStatus, ReferralLib} from "../types/Referral.sol";
 import {Fee, FeeLib} from "../types/Fee.sol";
 import {Component} from "./Component.sol";
 import {IDistributionComponent} from "./IDistributionComponent.sol";
@@ -15,46 +15,48 @@ import {ISetup} from "../instance/module/ISetup.sol";
 import {Registerable} from "../shared/Registerable.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
+import {UFixed} from "../types/UFixed.sol";
+import {DistributorType} from "../types/DistributorType.sol";
+import {Timestamp} from "../types/Timestamp.sol";
+import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
+
 
 abstract contract Distribution is
     Component,
     IDistributionComponent
 {
-    using NftIdLib for NftId;
-
-    bool internal _isVerifying;
-    Fee internal _initialDistributionFee;
+    // keccak256(abi.encode(uint256(keccak256("etherisc.storage.Distribution")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant DISTRIBUTION_STORAGE_LOCATION_V1 = 0xaab7c5ea03d290056d6c060e0833d3ebcbe647f7694616a2ec52738a64b2f900;
 
-    TokenHandler internal _tokenHandler;
-
-    IDistributionService private _distributionService;
+    struct DistributionStorage {
+        Fee _distributionFee;
+        TokenHandler _tokenHandler;
+        IDistributionService _distributionService;
+        mapping(address distributor => NftId distributorNftId) _distributorNftId;
+    }
 
-    constructor(
+    function initializeDistribution(
         address registry,
         NftId instanceNftId,
-        // TODO refactor into tokenNftId
         string memory name,
         address token,
-        bool verifying,
         Fee memory distributionFee,
         address initialOwner,
         bytes memory data
-    ) Component (
-        registry, 
-        instanceNftId, 
-        name, token, 
-        DISTRIBUTION(), 
-        true, 
-        initialOwner, 
-        data
-    ) {
-        _isVerifying = verifying;
-        _initialDistributionFee = distributionFee;
+    )
+        public
+        virtual
+        onlyInitializing()
+    {
+        initializeComponent(registry, instanceNftId, name, token, DISTRIBUTION(), true, initialOwner, data);
 
-        _tokenHandler = new TokenHandler(token);
-        _distributionService = getInstance().getDistributionService();
+        DistributionStorage storage $ = _getDistributionStorage();
+        // TODO add validation
+        $._distributionFee = distributionFee;
+        $._tokenHandler = new TokenHandler(token);
+        $._distributionService = getInstance().getDistributionService();
 
-        _registerInterface(type(IDistributionComponent).interfaceId);
+        registerInterface(type(IDistributionComponent).interfaceId);
     }
 
     function setFees(
@@ -65,7 +67,100 @@ abstract contract Distribution is
         onlyOwner
         restricted()
     {
-        _distributionService.setFees(distributionFee);
+        _getDistributionStorage()._distributionService.setFees(distributionFee);
+    }
+
+    function getDistributionFee() external view returns (Fee memory distributionFee) {
+        DistributionStorage storage $ = _getDistributionStorage();
+        return $._distributionFee;
+    }
+
+    function createDistributorType(
+        string memory name,
+        UFixed minDiscountPercentage,
+        UFixed maxDiscountPercentage,
+        UFixed commissionPercentage,
+        uint32 maxReferralCount,
+        uint32 maxReferralLifetime,
+        bool allowSelfReferrals,
+        bool allowRenewals,
+        bytes memory data
+    )
+        public
+        returns (DistributorType distributorType)
+    {
+        DistributionStorage storage $ = _getDistributionStorage();
+        distributorType = $._distributionService.createDistributorType(
+            name,
+            minDiscountPercentage,
+            maxDiscountPercentage,
+            commissionPercentage,
+            maxReferralCount,
+            maxReferralLifetime,
+            allowSelfReferrals,
+            allowRenewals,
+            data);
+    }
+
+    function createDistributor(
+        address distributor,
+        DistributorType distributorType,
+        bytes memory data
+    )
+        public
+        returns(NftId distributorNftId)
+    {
+        DistributionStorage storage $ = _getDistributionStorage();
+        require($._distributorNftId[distributor].eqz(), "ERROR:DST-030:ALREADY_DISTRIBUTOR");
+
+        distributorNftId = $._distributionService.createDistributor(
+            distributor,
+            distributorType,
+            data);
+
+        $._distributorNftId[distributor] = distributorNftId;
+    }
+
+    function updateDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    )
+        public
+        // TODO figure out what we need for authz
+        // and add it
+    {
+        DistributionStorage storage $ = _getDistributionStorage();
+        $._distributionService.updateDistributorType(
+            distributorNftId,
+            distributorType,
+            data);
+    }
+
+    /**
+     * @dev lets distributors create referral codes.
+     * referral codes need to be unique
+     */
+    function createReferral(
+        NftId distributorNftId,
+        string memory code,
+        UFixed discountPercentage,
+        uint32 maxReferrals,
+        Timestamp expiryAt,
+        bytes memory data
+    )
+        public
+        // TODO add authz (only active distributor)
+        returns (ReferralId referralId)
+    {
+        DistributionStorage storage $ = _getDistributionStorage();
+        referralId = $._distributionService.createReferral(
+            distributorNftId,
+            code,
+            discountPercentage,
+            maxReferrals,
+            expiryAt,
+            data);
     }
 
     function calculateFeeAmount(
@@ -80,9 +175,53 @@ abstract contract Distribution is
         ISetup.DistributionSetupInfo memory setupInfo = getSetupInfo();
         Fee memory fee = setupInfo.distributionFee;
         (feeAmount,) = FeeLib.calculateFee(fee, netPremiumAmount);
+        // TODO: use this? 
+        // return _distributionService.calculateFeeAmount(referralId, premiumAmount);        
+    }
+
+    function isDistributor(address candidate)
+        public
+        view
+        returns (bool)
+    {
+        DistributionStorage storage $ = _getDistributionStorage();
+        return $._distributorNftId[candidate].gtz();
+    }
+
+    function getDistributorNftId(address distributor)
+        public
+        view
+        returns (NftId distributorNftId)
+    {
+        DistributionStorage storage $ = _getDistributionStorage();
+        return $._distributorNftId[distributor];
+    }
+
+    function getDiscountPercentage(string memory referralCode)
+        external
+        view
+        returns (
+            UFixed discountPercentage, 
+            ReferralStatus status
+        )
+    {
+        ReferralId referralId = getReferralId(referralCode);
+        return getInstanceReader().getDiscountPercentage(referralId);
     }
 
 
+    function getReferralId(
+        string memory referralCode
+    )
+        public
+        view 
+        returns (ReferralId referralId)
+    {
+        return ReferralLib.toReferralId(
+            getNftId(), 
+            referralCode);      
+    }
+
     function calculateRenewalFeeAmount(
         ReferralId referralId,
         uint256 netPremiumAmount
@@ -98,14 +237,15 @@ abstract contract Distribution is
 
     function processSale(
         ReferralId referralId,
-        uint256 feeAmount
+        uint256 premiumAmount
     )
         external
         onlyOwner
         restricted()
         virtual override
     {
-        // default is no action
+        DistributionStorage storage $ = _getDistributionStorage();
+        $._distributionService.processSale(referralId, premiumAmount);        
     }
 
     function processRenewal(
@@ -136,18 +276,33 @@ abstract contract Distribution is
     }
 
     function _getInitialSetupInfo() internal view returns (ISetup.DistributionSetupInfo memory setupInfo) {
+        DistributionStorage storage $ = _getDistributionStorage();
         return ISetup.DistributionSetupInfo(
             zeroNftId(),
-            _tokenHandler,
-            _initialDistributionFee,
-            _isVerifying,
+            $._tokenHandler,
+            $._distributionFee,
             address(this)
         );
     }
+
+
+    function nftTransferFrom(address from, address to, uint256 tokenId) external virtual override (Component, ITransferInterceptor) {
+        // keep track of distributor nft owner
+        emit LogDistributorUpdated(to, msg.sender);
+        DistributionStorage storage $ = _getDistributionStorage();
+        $._distributorNftId[from] = zeroNftId();
+        $._distributorNftId[to] = toNftId(tokenId);
+    }
     
 
     /// @dev returns true iff the component needs to be called when selling/renewing policis
     function isVerifying() external view returns (bool verifying) {
-        return _isVerifying;
+        return true;
+    }
+
+    function _getDistributionStorage() private pure returns (DistributionStorage storage $) {
+        assembly {
+            $.slot := DISTRIBUTION_STORAGE_LOCATION_V1
+        }
     }
 }

package/contracts/components/IComponent.sol

@@ -3,21 +3,27 @@ pragma solidity ^0.8.20;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
-import {IRegisterable} from "../shared/IRegisterable.sol";
 import {IInstance} from "../instance/IInstance.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IProductService} from "../instance/service/IProductService.sol";
+import {IRegisterable} from "../shared/IRegisterable.sol";
+import {ITransferInterceptor} from "../registry/ITransferInterceptor.sol";
 import {NftId} from "../types/NftId.sol";
+import {ObjectType} from "../types/ObjectType.sol";
 
-interface IComponent is IRegisterable {
+interface IComponent is 
+    IRegisterable,
+    ITransferInterceptor
+{
 
+    error ErrorComponentNotChainNft(address caller);
+    error ErrorComponentNotProductService(address caller);
     error ErrorComponentNotInstance(NftId instanceNftId, address instance);
     error ErrorComponentProductNftAlreadySet();
     error ErrorComponentWalletAddressZero();
     error ErrorComponentWalletAddressIsSameAsCurrent(address newWallet);
     error ErrorComponentWalletAllowanceTooSmall(address oldWallet, address newWallet, uint256 allowance, uint256 balance);
     error ErrorComponentUnauthorized(address caller, uint64 requiredRoleIdNum);
-    error ErrorComponentNotProductService(address caller);
 
     event LogComponentWalletAddressChanged(address newWallet);
     event LogComponentWalletTokensTransferred(address from, address to, uint256 amount);
@@ -33,8 +39,14 @@ interface IComponent is IRegisterable {
     function setWallet(address walletAddress) external;
     function getWallet() external view returns (address walletAddress);
 
+    function isNftInterceptor() external view returns(bool isInterceptor);
+
     function getInstance() external view returns (IInstance instance);
 
+    /// @dev returns the service address for the specified domain
+    /// gets address via lookup from registry using the major version form the linked instance
+    function getServiceAddress(ObjectType domain) external view returns (address service);
+
     function setProductNftId(NftId productNftId) external;
     function getProductNftId() external view returns (NftId productNftId);
 

package/contracts/components/IDistributionComponent.sol

@@ -4,17 +4,60 @@ pragma solidity ^0.8.19;
 import {Fee} from "../types/Fee.sol";
 import {IComponent} from "./IComponent.sol";
 import {ISetup} from "../instance/module/ISetup.sol";
-import {ReferralId} from "../types/Referral.sol";
+import {ReferralId, ReferralStatus} from "../types/Referral.sol";
 import {NftId} from "../types/NftId.sol";
+import {DistributorType} from "../types/DistributorType.sol";
+import {UFixed} from "../types/UFixed.sol";
+import {Timestamp} from "../types/Timestamp.sol";
 
 interface IDistributionComponent is IComponent {
 
+    event LogDistributorUpdated(address to, address caller);
+
     function getSetupInfo() external view returns (ISetup.DistributionSetupInfo memory setupInfo);
 
     function setFees(
         Fee memory distributionFee
     ) external;
 
+    function createDistributorType(
+        string memory name,
+        UFixed minDiscountPercentage,
+        UFixed maxDiscountPercentage,
+        UFixed commissionPercentage,
+        uint32 maxReferralCount,
+        uint32 maxReferralLifetime,
+        bool allowSelfReferrals,
+        bool allowRenewals,
+        bytes memory data
+    ) external returns (DistributorType distributorType);
+
+    function createDistributor(
+        address distributor,
+        DistributorType distributorType,
+        bytes memory data
+    ) external returns(NftId distributorNftId);
+
+    function updateDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    ) external;
+
+    /**
+     * @dev lets distributors create referral codes.
+     * referral codes need to be unique
+     * distributor is identified via msg.sender.
+     */
+    function createReferral(
+        NftId distributorNftId,
+        string memory code,
+        UFixed discountPercentage,
+        uint32 maxReferrals,
+        Timestamp expiryAt,
+        bytes memory data
+    ) external returns (ReferralId referralId);
+
     function calculateFeeAmount(
         ReferralId referralId,
         uint256 netPremiumAmount
@@ -39,6 +82,16 @@ interface IDistributionComponent is IComponent {
         uint256 feeAmount
     ) external;
 
+    function getDiscountPercentage(
+        string memory referralCode
+    ) external view returns (UFixed discountPercentage, ReferralStatus status);
+
+    function getDistributionFee() external view returns (Fee memory distibutionFee);
+
+    function getReferralId(
+        string memory referralCode
+    ) external returns (ReferralId referralId);
+
     /// @dev returns true iff the referral id is valid
     function referralIsValid(ReferralId referralId) external view returns (bool isValid);
 

package/contracts/components/IPoolComponent.sol

@@ -7,10 +7,14 @@ import {ISetup} from "../instance/module/ISetup.sol";
 import {NftId} from "../types/NftId.sol";
 import {UFixed} from "../types/UFixed.sol";
 
+/// @dev pool components hold and manage the collateral to cover active policies
+/// pools come in different flavors
 interface IPoolComponent is IComponent {
 
     event LogUnderwrittenByPool(NftId policyNftId, uint256 collateralizationAmount, address pool);
 
+    error ErrorPoolNotPoolService(address service);
+
     function getSetupInfo() external view returns (ISetup.PoolSetupInfo memory setupInfo);
 
     function setFees(
@@ -19,28 +23,59 @@ interface IPoolComponent is IComponent {
         Fee memory performanceFee
     ) external;
 
+    /// @dev sets an additional bundle fee, this fee is added on top of the poolFee and deducted from the premium amounts.
+    /// via these fees individual bundler owner may earn income per policy in the context of peer to peer pools
     function setBundleFee(
-        NftId policyNftId, 
+        NftId bundleNftId, 
         Fee memory fee
     ) external;
 
-    /** 
-     * @dev this is a callback function that is called by the product service when underwriting a policy.
-     * the pool has the option to check the details and object to underwriting by reverting.
-     * the function is only called for "active" pools that ask to be involved/notified
-     * by product related state changes.
-     */
-    function underwrite(
-        NftId policyNftId, 
+    /// @dev this is a callback function that is called by the product service when underwriting a policy.
+    /// the pool has the option to check the details and object to underwriting by reverting.
+    /// the function is only called for "active" pools that ask to be involved/notified
+    /// by product related state changes.
+    function verifyApplication(
+        NftId applicationNftId, 
         bytes memory policyData,
         bytes memory bundleFilter,
         uint256 collateralizationAmount
     ) external;
 
-    /**
-     * @dev returns true iff the policy application data in policyData matches
-     * with the bundle filter criteria encoded in bundleFilter. 
-     */
+    function lockBundle(NftId bundleNftId) external;
+
+    function unlockBundle(NftId bundleNftId) external;
+
+    /// @dev defines the multiplier to calculate the required collateral to cover a given sum insured amount
+    /// default implementation returns 100%
+    function getCollateralizationLevel() external view returns (UFixed collateralizationLevel);
+
+    /// @dev defines the amount of collateral held in the pool.
+    /// if the value is < 100% the pool is required to hold a policy that covers the locally missing collateral
+    /// default implementation returns 100%
+    function getRetentionLevel() external view returns (UFixed retentionLevel);
+
+    /// @dev declares if pool intercept transfers of bundle nft ids
+    /// - yes: pool may block transfer of bundle ownership or simply updates some bookkeeping related to bundle ownership. callback function is nftTransferFrom
+    /// - no: pool is not involved in transfer of bundle ownership
+    /// default implementation returns false (no)
+    function isInterceptingBundleTransfers() external view returns (bool);
+
+    /// @dev declares if pool relies on external management of collateral (yes/no): 
+    /// - yes: underwriting of new policies does not require an actual token balance, instead it is assumed that the pool owner will manage funds externally and inject enough tokens to allow process confirmed payouts
+    /// - no: the pool smart contract ensures that the necessary capacity of the pool prior to underwriting.
+    /// default implementation returns false (no)
+    function isExternallyManaged() external view returns (bool);
+
+    /// @dev declares if pool component is actively involved in underwriting (yes/no): 
+    /// - yes: verifying pools components actively confirm underwriting applications, ie the pool component logic explicitly needs to confirm the locking of collateral to cover the sum insured of the policy
+    /// - no: underwriting a policy does not require any interaction with the pool component if the covering bundle can provide the necessary captial
+    /// default implementation returnsfalse (no)
+    function isVerifyingApplications() external view returns (bool);
+
+    /// @dev returns true iff the policy application data in policyData matches
+    /// with the bundle filter criteria encoded in bundleFilter
+    /// this is a callback function that is only called if a pool declares itself as a verifying pool
+    /// default implementation returns true
     function policyMatchesBundle(
         bytes memory policyData,
         bytes memory bundleFilter
@@ -49,8 +84,4 @@ interface IPoolComponent is IComponent {
         view
         returns (bool isMatching);
 
-    function isConfirmingApplication() external view returns (bool isConfirmingApplication);
-
-    function getCollateralizationLevel() external view returns (UFixed collateralizationLevel);
-
 }