@etherisc/gif-next 0.0.2-89c8f37-711 → 0.0.2-8a72793-100

package/contracts/distribution/DistributionService.sol

@@ -1,36 +1,36 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-
-import {IRegistry} from "../registry/IRegistry.sol";
-import {IInstance} from "../instance/IInstance.sol";
+import {IAccountingService} from "../accounting/IAccountingService.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
+import {IDistribution} from "../instance/module/IDistribution.sol";
+import {IDistributionService} from "./IDistributionService.sol";
+import {IInstance} from "../instance/IInstance.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryService} from "../registry/IRegistryService.sol";
-import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IPolicy} from "../instance/module/IPolicy.sol";
 
 import {Amount, AmountLib} from "../type/Amount.sol";
-import {NftId, NftIdLib} from "../type/NftId.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
-import {KEEP_STATE} from "../type/StateId.sol";
-import {ObjectType, COMPONENT, DISTRIBUTION, INSTANCE, DISTRIBUTION, DISTRIBUTOR, REGISTRY} from "../type/ObjectType.sol";
 import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
-import {IDistributionService} from "./IDistributionService.sol";
-import {UFixed, UFixedLib} from "../type/UFixed.sol";
 import {DistributorType, DistributorTypeLib} from "../type/DistributorType.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {KEEP_STATE} from "../type/StateId.sol";
+import {ObjectType, ACCOUNTING, COMPONENT, DISTRIBUTION, INSTANCE, DISTRIBUTION, DISTRIBUTOR, REGISTRY} from "../type/ObjectType.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {InstanceStore} from "../instance/InstanceStore.sol";
 import {ReferralId, ReferralLib} from "../type/Referral.sol";
+import {Seconds} from "../type/Seconds.sol";
 import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
-import {IDistribution} from "../instance/module/IDistribution.sol";
-import {InstanceStore} from "../instance/InstanceStore.sol";
+import {UFixed} from "../type/UFixed.sol";
 
 
 contract DistributionService is
     ComponentVerifyingService,
     IDistributionService
 {
+    IAccountingService private _accountingService;
     IComponentService private _componentService;
     IInstanceService private _instanceService;
     IRegistryService private _registryService;
@@ -40,21 +40,22 @@ contract DistributionService is
         bytes memory data
     )
         internal
-        initializer
         virtual override
+        initializer()
     {
-        address initialOwner;
-        address registryAddress;
-        (registryAddress, initialOwner) = abi.decode(data, (address, address));
-        // TODO while DistributionService is not deployed in DistributionServiceManager constructor
-        //      owner is DistributionServiceManager deployer
-        initializeService(registryAddress, address(0), owner);
+        (
+            address authority,
+            address registry
+        ) = abi.decode(data, (address, address));
+
+        __Service_init(authority, registry, owner);
 
+        _accountingService = IAccountingService(_getServiceAddress(ACCOUNTING()));
         _componentService = IComponentService(_getServiceAddress(COMPONENT()));
         _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
 
-        registerInterface(type(IDistributionService).interfaceId);
+        _registerInterface(type(IDistributionService).interfaceId);
     }
 
 
@@ -64,7 +65,7 @@ contract DistributionService is
         UFixed maxDiscountPercentage,
         UFixed commissionPercentage,
         uint32 maxReferralCount,
-        uint32 maxReferralLifetime,
+        Seconds maxReferralLifetime,
         bool allowSelfReferrals,
         bool allowRenewals,
         bytes memory data
@@ -73,14 +74,14 @@ contract DistributionService is
         returns (DistributorType distributorType)
     {
         (NftId distributionNftId,, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
-        InstanceReader instanceReader = instance.getInstanceReader();
+        // InstanceReader instanceReader = instance.getInstanceReader();
 
         {
-            NftId productNftId = _getProductNftId(instanceReader, distributionNftId);
-            IComponents.ProductInfo memory productInfo = instance.getInstanceReader().getProductInfo(productNftId);
+            NftId productNftId = _getProductNftId(distributionNftId);
+            IComponents.FeeInfo memory feeInfo = instance.getInstanceReader().getFeeInfo(productNftId);
 
-            UFixed variableDistributionFees = productInfo.distributionFee.fractionalFee;
-            UFixed variableFeesPartsTotal = productInfo.minDistributionOwnerFee.fractionalFee + commissionPercentage;
+            UFixed variableDistributionFees = feeInfo.distributionFee.fractionalFee;
+            UFixed variableFeesPartsTotal = feeInfo.minDistributionOwnerFee.fractionalFee + commissionPercentage;
 
             if (variableFeesPartsTotal > variableDistributionFees) {
                 revert ErrorDistributionServiceVariableFeesTooHight(variableDistributionFees.toInt1000(), variableFeesPartsTotal.toInt1000());
@@ -139,21 +140,20 @@ contract DistributionService is
         instance.getInstanceStore().createDistributor(distributorNftId, info);
     }
 
-    // function updateDistributorType(
-    //     NftId distributorNftId,
-    //     DistributorType distributorType,
-    //     bytes memory data
-    // )
-    //     external
-    //     virtual
-    // {
-    //     (, IInstance instance) = _getAndVerifyCallingDistribution();
-    //     InstanceReader instanceReader = instance.getInstanceReader();
-    //     IDistribution.DistributorInfo memory distributorInfo = instanceReader.getDistributorInfo(distributorNftId);
-    //     distributorInfo.distributorType = distributorType;
-    //     distributorInfo.data = data;
-    //     instance.updateDistributor(distributorNftId, distributorInfo, KEEP_STATE());
-    // }
+    function changeDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    )
+        external
+        virtual
+    {
+        (,, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
+        IDistribution.DistributorInfo memory distributorInfo = instance.getInstanceReader().getDistributorInfo(distributorNftId);
+        distributorInfo.distributorType = distributorType;
+        distributorInfo.data = data;
+        instance.getInstanceStore().updateDistributor(distributorNftId, distributorInfo, KEEP_STATE());
+    }
 
 
     function createReferral(
@@ -166,79 +166,105 @@ contract DistributionService is
     )
         external
         virtual
+        onlyNftOfType(distributorNftId, DISTRIBUTOR())
         returns (ReferralId referralId)
     {
         (NftId distributionNftId,, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
 
         if (bytes(code).length == 0) {
-            revert ErrorIDistributionServiceInvalidReferral(code);
+            revert ErrorDistributionServiceInvalidReferral(code);
         }
-        if (expiryAt.eqz()) {
-            revert ErrorIDistributionServiceExpirationInvalid(expiryAt);
+        if (expiryAt.eqz() || expiryAt.lte(TimestampLib.blockTimestamp())) {
+            revert ErrorDistributionServiceExpirationInvalid(expiryAt);
         }
 
-        InstanceReader instanceReader = instance.getInstanceReader();
-        DistributorType distributorType = instanceReader.getDistributorInfo(distributorNftId).distributorType;
-        IDistribution.DistributorTypeInfo memory distributorTypeData = instanceReader.getDistributorTypeInfo(distributorType);
+        {
+            InstanceReader instanceReader = instance.getInstanceReader();
+            DistributorType distributorType = instanceReader.getDistributorInfo(distributorNftId).distributorType;
+            IDistribution.DistributorTypeInfo memory distributorTypeData = instanceReader.getDistributorTypeInfo(distributorType);
 
-        if (distributorTypeData.maxReferralCount < maxReferrals) {
-            revert ErrorIDistributionServiceMaxReferralsExceeded(distributorTypeData.maxReferralCount);
-        }
-        if (distributorTypeData.minDiscountPercentage > discountPercentage) {
-            revert ErrorIDistributionServiceDiscountTooLow(distributorTypeData.minDiscountPercentage.toInt(), discountPercentage.toInt());
-        }
-        if (distributorTypeData.maxDiscountPercentage < discountPercentage) {
-            revert ErrorIDistributionServiceDiscountTooHigh(distributorTypeData.maxDiscountPercentage.toInt(), discountPercentage.toInt());
-        }
-        if (expiryAt.toInt() - TimestampLib.blockTimestamp().toInt() > distributorTypeData.maxReferralLifetime) {
-            revert ErrorIDistributionServiceExpiryTooLong(distributorTypeData.maxReferralLifetime, expiryAt.toInt());
+            if (distributorTypeData.maxReferralCount < maxReferrals) {
+                revert ErrorDistributionServiceMaxReferralsExceeded(distributorTypeData.maxReferralCount);
+            }
+            if (distributorTypeData.minDiscountPercentage > discountPercentage) {
+                revert ErrorDistributionServiceDiscountTooLow(distributorTypeData.minDiscountPercentage.toInt(), discountPercentage.toInt());
+            }
+            if (distributorTypeData.maxDiscountPercentage < discountPercentage) {
+                revert ErrorDistributionServiceDiscountTooHigh(distributorTypeData.maxDiscountPercentage.toInt(), discountPercentage.toInt());
+            }
+            if (expiryAt.toInt() - TimestampLib.blockTimestamp().toInt() > distributorTypeData.maxReferralLifetime.toInt()) {
+                revert ErrorDistributionServiceExpiryTooLong(distributorTypeData.maxReferralLifetime, expiryAt);
+            }
         }
 
-        referralId = ReferralLib.toReferralId(distributionNftId, code);
-        IDistribution.ReferralInfo memory info = IDistribution.ReferralInfo(
-            distributorNftId,
-            code,
-            discountPercentage,
-            maxReferrals,
-            0, // used referrals
-            expiryAt,
-            data
-        );
-
-        instance.getInstanceStore().createReferral(referralId, info);
-        return referralId;
+        {
+            referralId = ReferralLib.toReferralId(distributionNftId, code);
+            IDistribution.ReferralInfo memory info = IDistribution.ReferralInfo(
+                distributorNftId,
+                code,
+                discountPercentage,
+                maxReferrals,
+                0, // used referrals
+                expiryAt,
+                data
+            );
+
+            instance.getInstanceStore().createReferral(referralId, info);
+        }
     }
 
+    /// @inheritdoc IDistributionService
+    function processReferral(
+        NftId distributionNftId, 
+        ReferralId referralId
+    ) 
+        external
+        virtual
+        restricted()
+        onlyNftOfType(distributionNftId, DISTRIBUTION())
+    {
+        if (referralIsValid(distributionNftId, referralId)) {
+            IRegistry registry = getRegistry();
+            IRegistry.ObjectInfo memory distributionInfo = registry.getObjectInfo(distributionNftId);
+            IInstance instance = _getInstanceForComponent(registry, distributionInfo.parentNftId);
+
+            // update book keeping for referral info
+            IDistribution.ReferralInfo memory referralInfo = instance.getInstanceReader().getReferralInfo(referralId);
+            referralInfo.usedReferrals += 1;
+            instance.getInstanceStore().updateReferral(referralId, referralInfo, KEEP_STATE());
+        }
+    }
 
     function processSale(
         NftId distributionNftId, // assume always of distribution type
         ReferralId referralId,
-        IPolicy.Premium memory premium
+        IPolicy.PremiumInfo memory premium
     )
         external
         virtual
-        restricted
+        restricted()
+        onlyNftOfType(distributionNftId, DISTRIBUTION())
     {
-        IInstance instance = _getInstanceForDistribution(distributionNftId);
+        IRegistry registry = getRegistry();
+        IRegistry.ObjectInfo memory distributionInfo = registry.getObjectInfo(distributionNftId);
+        IInstance instance = _getInstanceForComponent(registry, distributionInfo.parentNftId);
         InstanceReader reader = instance.getInstanceReader();
         InstanceStore store = instance.getInstanceStore();
 
         // get distribution owner fee amount
-        Amount distributionOwnerFee = AmountLib.toAmount(premium.distributionOwnerFeeFixAmount + premium.distributionOwnerFeeVarAmount);
+        Amount distributionOwnerFee = premium.distributionOwnerFeeFixAmount + premium.distributionOwnerFeeVarAmount;
 
         // update referral/distributor info if applicable
         if (referralIsValid(distributionNftId, referralId)) {
 
             // increase distribution balance by commission amount and distribution owner fee
-            Amount commissionAmount = AmountLib.toAmount(premium.commissionAmount);
-            _componentService.increaseDistributionBalance(store, distributionNftId, commissionAmount, distributionOwnerFee);
+            Amount commissionAmount = premium.commissionAmount;
+            _accountingService.increaseDistributionBalance(store, distributionNftId, commissionAmount, distributionOwnerFee);
 
             // update book keeping for referral info
             IDistribution.ReferralInfo memory referralInfo = reader.getReferralInfo(referralId);
-            referralInfo.usedReferrals += 1;
-            store.updateReferral(referralId, referralInfo, KEEP_STATE());
 
-            _componentService.increaseDistributorBalance(store, referralInfo.distributorNftId, AmountLib.zero(), commissionAmount);
+            _accountingService.increaseDistributorBalance(store, referralInfo.distributorNftId, AmountLib.zero(), commissionAmount);
 
             // update book keeping for distributor info
             IDistribution.DistributorInfo memory distributorInfo = reader.getDistributorInfo(referralInfo.distributorNftId);
@@ -246,7 +272,7 @@ contract DistributionService is
             store.updateDistributor(referralInfo.distributorNftId, distributorInfo, KEEP_STATE());
         } else {
             // increase distribution balance by distribution owner fee
-            _componentService.increaseDistributionBalance(store, distributionNftId, AmountLib.zero(), distributionOwnerFee);
+            _accountingService.increaseDistributionBalance(store, distributionNftId, AmountLib.zero(), distributionOwnerFee);
         }
     }
 
@@ -255,13 +281,14 @@ contract DistributionService is
         public 
         virtual
         // TODO: restricted() (once #462 is done)
+        onlyNftOfType(distributorNftId, DISTRIBUTOR())
         returns (Amount withdrawnAmount) 
     {
         (NftId distributionNftId,, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
         InstanceReader reader = instance.getInstanceReader();
         
         IComponents.ComponentInfo memory distributionInfo = reader.getComponentInfo(distributionNftId);
-        address distributionWallet = distributionInfo.wallet;
+        address distributionWallet = distributionInfo.tokenHandler.getWallet();
         
         Amount commissionAmount = reader.getFeeAmount(distributorNftId);
         
@@ -275,42 +302,36 @@ contract DistributionService is
             }
         }
 
-        if (withdrawnAmount.eqz()) {
-            revert ErrorDistributionServiceCommissionWithdrawAmountIsZero();
-        }
-
-        // check allowance
-        IERC20Metadata token = IERC20Metadata(distributionInfo.token);
-        uint256 tokenAllowance = token.allowance(distributionWallet, address(distributionInfo.tokenHandler));
-        if (tokenAllowance < withdrawnAmount.toInt()) {
-            revert ErrorDistributionServiceWalletAllowanceTooSmall(distributionWallet, address(distributionInfo.tokenHandler), tokenAllowance, withdrawnAmount.toInt());
-        }
-
         // decrease fee counters by withdrawnAmount and update distributor info
         {
             InstanceStore store = instance.getInstanceStore();
             // decrease fee counter for distribution balance
-            _componentService.decreaseDistributionBalance(store, distributionNftId, withdrawnAmount, AmountLib.zero());
+            _accountingService.decreaseDistributionBalance(store, distributionNftId, withdrawnAmount, AmountLib.zero());
             // decrease fee counter for distributor fee
-            _componentService.decreaseDistributorBalance(store, distributorNftId, AmountLib.zero(), withdrawnAmount);
+            _accountingService.decreaseDistributorBalance(store, distributorNftId, AmountLib.zero(), withdrawnAmount);
         }
 
         // transfer amount to distributor
         {
             address distributor = getRegistry().ownerOf(distributorNftId);
-            // TODO: centralize token handling (issue #471)
-            distributionInfo.tokenHandler.transfer(distributionWallet, distributor, withdrawnAmount);
-
-            emit LogDistributionServiceCommissionWithdrawn(distributorNftId, distributor, address(token), withdrawnAmount);
+            emit LogDistributionServiceCommissionWithdrawn(distributorNftId, distributor, address(distributionInfo.token), withdrawnAmount);
+            distributionInfo.tokenHandler.pushToken(distributor, withdrawnAmount);
         }
     }
 
-    function referralIsValid(NftId distributionNftId, ReferralId referralId) public view returns (bool isValid) {
+    function referralIsValid(NftId distributionNftId, ReferralId referralId) 
+        public 
+        view 
+        onlyNftOfType(distributionNftId, DISTRIBUTION())
+        returns (bool isValid) 
+    {
         if (distributionNftId.eqz() || referralId.eqz()) {
             return false;
         }
 
-        IInstance instance = _getInstanceForDistribution(distributionNftId);
+        IRegistry registry = getRegistry();
+        IRegistry.ObjectInfo memory distributionInfo = registry.getObjectInfo(distributionNftId);
+        IInstance instance = _getInstanceForComponent(registry, distributionInfo.parentNftId);
         IDistribution.ReferralInfo memory info = instance.getInstanceReader().getReferralInfo(referralId);
 
         if (info.distributorNftId.eqz()) {
@@ -326,8 +347,8 @@ contract DistributionService is
         view
         returns(IInstance instance)
     {
-        NftId instanceNftId = getRegistry().getObjectInfo(distributionNftId).parentNftId;
-        address instanceAddress = getRegistry().getObjectInfo(instanceNftId).objectAddress;
+        NftId instanceNftId = getRegistry().getParentNftId(distributionNftId);
+        address instanceAddress = getRegistry().getObjectAddress(instanceNftId);
         return IInstance(instanceAddress);
     }
 

package/contracts/distribution/DistributionServiceManager.sol

@@ -12,15 +12,15 @@ contract DistributionServiceManager is ProxyManager {
     /// @dev initializes proxy manager with distribution service implementation and deploys instance
     constructor(
         address authority, 
-        address registryAddress,
+        address registry,
         bytes32 salt
     ) 
-        ProxyManager(registryAddress)
     {
-        DistributionService distSrv = new DistributionService{salt: salt}();
-        bytes memory data = abi.encode(registryAddress, address(this), authority);
-        IVersionable versionable = deployDetermenistic(
-            address(distSrv), 
+        DistributionService svc = new DistributionService{salt: salt}();
+        bytes memory data = abi.encode(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
+            address(svc), 
             data,
             salt);
 

package/contracts/distribution/IDistributionComponent.sol

@@ -12,7 +12,7 @@ interface IDistributionComponent is IInstanceLinkedComponent {
     error ErrorDistributionNotDistributor(address distributor);
     error ErrorDistributionAlreadyDistributor(address distributor, NftId distributorNftId);
 
-    event LogDistributorUpdated(address to, address caller);
+    event LogDistributorUpdated(address to, address operator);
 
     /// @dev Returns true iff the provided address is registered as a distributor with this distribution component.
     function isDistributor(address candidate) external view returns (bool);

package/contracts/distribution/IDistributionService.sol

@@ -3,38 +3,36 @@ pragma solidity ^0.8.20;
 
 import {Amount} from "../type/Amount.sol";
 import {NftId} from "../type/NftId.sol";
-import {Fee} from "../type/Fee.sol";
 import {IPolicy} from "../instance/module/IPolicy.sol";
 import {IService} from "../shared/IService.sol";
 import {UFixed} from "../type/UFixed.sol";
 import {DistributorType} from "../type/DistributorType.sol";
 import {ReferralId} from "../type/Referral.sol";
+import {Seconds} from "../type/Seconds.sol";
 import {Timestamp} from "../type/Timestamp.sol";
 
 
 interface IDistributionService is IService {
 
     error ErrorDistributionServiceCallerNotRegistered(address caller);
-    error ErrorIDistributionServiceParentNftIdNotInstance(NftId nftId, NftId parentNftId);
-    error ErrorIDistributionServiceCallerNotDistributor(address caller);
-    error ErrorIDistributionServiceInvalidReferralId(ReferralId referralId);
-    error ErrorIDistributionServiceMaxReferralsExceeded(uint256 maxReferrals);
-    error ErrorIDistributionServiceDiscountTooLow(uint256 minDiscountPercentage, uint256 discountPercentage);
-    error ErrorIDistributionServiceDiscountTooHigh(uint256 maxDiscountPercentage, uint256 discountPercentage);
-    error ErrorIDistributionServiceExpiryTooLong(uint256 maxReferralLifetime, uint256 expiryAt);
-    error ErrorIDistributionServiceInvalidReferral(string code);
-    error ErrorIDistributionServiceExpirationInvalid(Timestamp expiryAt);
-    error ErrorIDistributionServiceCommissionTooHigh(uint256 commissionPercentage, uint256 maxCommissionPercentage);
-    error ErrorIDistributionServiceMinFeeTooHigh(uint256 minFee, uint256 limit);
+    error ErrorDistributionServiceParentNftIdNotInstance(NftId nftId, NftId parentNftId);
+    error ErrorDistributionServiceCallerNotDistributor(address caller);
+    error ErrorDistributionServiceInvalidReferralId(ReferralId referralId);
+    error ErrorDistributionServiceMaxReferralsExceeded(uint256 maxReferrals);
+    error ErrorDistributionServiceDiscountTooLow(uint256 minDiscountPercentage, uint256 discountPercentage);
+    error ErrorDistributionServiceDiscountTooHigh(uint256 maxDiscountPercentage, uint256 discountPercentage);
+    error ErrorDistributionServiceExpiryTooLong(Seconds maxReferralLifetime, Timestamp expiryAt);
+    error ErrorDistributionServiceInvalidReferral(string code);
+    error ErrorDistributionServiceExpirationInvalid(Timestamp expiryAt);
+    error ErrorDistributionServiceCommissionTooHigh(uint256 commissionPercentage, uint256 maxCommissionPercentage);
+    error ErrorDistributionServiceMinFeeTooHigh(uint256 minFee, uint256 limit);
 
     error ErrorDistributionServiceCommissionWithdrawAmountExceedsLimit(Amount amount, Amount limit);
-    error ErrorDistributionServiceCommissionWithdrawAmountIsZero();
-    error ErrorDistributionServiceWalletAllowanceTooSmall(address wallet, address tokenHandler, uint256 allowance, uint256 amount);
-
+    
     error ErrorDistributionServiceVariableFeesTooHight(uint256 maxDiscountPercentage, uint256 limit);
     error ErrorDistributionServiceMaxDiscountTooHigh(uint256 maxDiscountPercentage, uint256 limit);
 
-    error ErrorIDistributionServiceReferralInvalid(NftId distributionNftId, ReferralId referralId);
+    error ErrorDistributionServiceReferralInvalid(NftId distributionNftId, ReferralId referralId);
     error ErrorDistributionServiceInvalidFeeTransferred(Amount transferredDistributionFeeAmount, Amount expectedDistributionFeeAmount);
 
     event LogDistributionServiceCommissionWithdrawn(NftId distributorNftId, address recipient, address tokenAddress, Amount amount);
@@ -45,7 +43,7 @@ interface IDistributionService is IService {
         UFixed maxDiscountPercentage,
         UFixed commissionPercentage,
         uint32 maxReferralCount,
-        uint32 maxReferralLifetime,
+        Seconds maxReferralLifetime,
         bool allowSelfReferrals,
         bool allowRenewals,
         bytes memory data
@@ -59,12 +57,11 @@ interface IDistributionService is IService {
         bytes memory data
     ) external returns (NftId distributorNftId);
 
-    // TODO re-enable and reorganize (service contract too large)
-    // function updateDistributorType(
-    //     NftId distributorNftId,
-    //     DistributorType distributorType,
-    //     bytes memory data
-    // ) external;
+    function changeDistributorType(
+        NftId distributorNftId,
+        DistributorType distributorType,
+        bytes memory data
+    ) external;
 
     function createReferral(
         NftId distributorNftId,
@@ -77,11 +74,18 @@ interface IDistributionService is IService {
         external
         returns (ReferralId referralId);
 
+    /// @dev callback from product service when a referral is used. 
+    /// Calling this will increment the referral usage counter. 
+    function processReferral(
+        NftId distributionNftId, 
+        ReferralId referralId
+    ) external;
+
     /// @dev callback from product service when selling a policy for a specific referralId
     function processSale(
         NftId distributionNftId,
         ReferralId referralId,
-        IPolicy.Premium memory premium
+        IPolicy.PremiumInfo memory premium
     ) external;
 
     function referralIsValid(

package/contracts/examples/fire/DamageLevel.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+type DamageLevel is uint8;
+
+// type bindings
+using {
+    DamageLevelLib.eq,
+    DamageLevelLib.eqz,
+    DamageLevelLib.toInt
+} for DamageLevel global;
+
+// solhint-disable-next-line func-name-mixedcase
+function DAMAGE_SMALL() pure returns (DamageLevel) {
+    return DamageLevel.wrap(1);
+}
+
+// solhint-disable-next-line func-name-mixedcase
+function DAMAGE_MEDIUM() pure returns (DamageLevel) {
+    return DamageLevel.wrap(2);
+}
+
+// solhint-disable-next-line func-name-mixedcase
+function DAMAGE_LARGE() pure returns (DamageLevel) {
+    return DamageLevel.wrap(3);
+}
+
+library DamageLevelLib {
+
+    error ErrorDamageLeveLibInvalidDamageLevel(uint8 damageLevel);
+
+    function zero() internal pure returns (DamageLevel) {
+        return DamageLevel.wrap(0);
+    }
+
+    function toDamageLevel(uint8 damage) internal pure returns (DamageLevel) {
+        if (damage == 1) {
+            return DAMAGE_SMALL();
+        } else if (damage == 2) {
+            return DAMAGE_MEDIUM();
+        } else if (damage == 3) {
+            return DAMAGE_LARGE();
+        } else {
+            revert ErrorDamageLeveLibInvalidDamageLevel(damage);
+        }
+    }
+
+    function toInt(DamageLevel damageLevel) internal pure returns (uint8) {
+        return uint8(DamageLevel.unwrap(damageLevel));
+    }
+
+    function eq(DamageLevel a, DamageLevel b) internal pure returns (bool) {
+        return DamageLevel.unwrap(a) == DamageLevel.unwrap(b);
+    }
+
+    function eqz(DamageLevel a) internal pure returns (bool) {
+        return DamageLevel.unwrap(a) == 0;
+    }
+}

package/contracts/examples/fire/FirePool.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {Amount, AmountLib} from "../../type/Amount.sol";
+import {BasicPool} from "../../pool/BasicPool.sol";
+import {Fee} from "../../type/Fee.sol";
+import {IAuthorization} from "../../authorization/IAuthorization.sol";
+import {IComponents} from "../../instance/module/IComponents.sol";
+import {NftId} from "../../type/NftId.sol";
+import {Seconds} from "../../type/Timestamp.sol";
+import {UFixed, UFixedLib} from "../../type/UFixed.sol";
+
+contract FirePool is
+    BasicPool
+{   
+    constructor(
+        address registry,
+        NftId fireProductNftId,
+        string memory componentName,
+        address token,
+        IAuthorization authorization
+    ) 
+    {
+        address initialOwner = msg.sender;
+        _intialize(
+            registry,
+            fireProductNftId,
+            componentName,
+            token,
+            IComponents.PoolInfo({
+                maxBalanceAmount: AmountLib.max(),
+                isInterceptingBundleTransfers: false,
+                isProcessingConfirmedClaims: false,
+                isExternallyManaged: false,
+                isVerifyingApplications: false,
+                collateralizationLevel: UFixedLib.one(),
+                retentionLevel: UFixedLib.one()
+            }),
+            authorization,
+            initialOwner);
+    }
+
+    function _intialize(
+        address registry,
+        NftId fireProductNftId,
+        string memory componentName,
+        address token,
+        IComponents.PoolInfo memory poolInfo,
+        IAuthorization authorization,
+        address initialOwner
+    )
+        internal
+        initializer
+    {
+        _initializeBasicPool(
+            registry,
+            fireProductNftId,
+            componentName,
+            token,
+            poolInfo,
+            authorization,
+            initialOwner);
+    }
+
+    function createBundle(
+        Fee memory fee,
+        Amount initialAmount,
+        Seconds lifetime
+    )
+        external
+        virtual 
+        restricted()
+        returns(NftId bundleNftId, Amount netStakedAmount)
+    {
+        address owner = msg.sender;
+        bundleNftId = _createBundle(
+            owner,
+            fee,
+            lifetime,
+            "" // filter
+        );
+        netStakedAmount = _stake(bundleNftId, initialAmount);
+    }
+
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external restricted() onlyOwner() { _approveTokenHandler(token, amount); }
+    function setLocked(bool locked) external onlyOwner() { _setLocked(locked); }
+    function setWallet(address newWallet) external restricted() onlyOwner() { _setWallet(newWallet); }
+}