@etherisc/gif-next 3.0.0-f0c22a5-010 → 3.0.0-f608233-662

package/contracts/distribution/DistributionService.sol

@@ -98,21 +98,24 @@ contract DistributionService is
         }
 
         distributorType = DistributorTypeLib.toDistributorType(distributionNftId, name);
-        IDistribution.DistributorTypeInfo memory info = IDistribution.DistributorTypeInfo({
-            name: name,
-            distributionNftId: distributionNftId,
-            minDiscountPercentage: minDiscountPercentage,
-            maxDiscountPercentage: maxDiscountPercentage,
-            commissionPercentage: commissionPercentage,
-            maxReferralCount: maxReferralCount,
-            maxReferralLifetime: maxReferralLifetime,
-            allowSelfReferrals: allowSelfReferrals,
-            allowRenewals: allowRenewals,
-            data: data});
-
-        instance.getInstanceStore().createDistributorType(distributorType, info);
+        
+        {
+            IDistribution.DistributorTypeInfo memory info = IDistribution.DistributorTypeInfo({
+                name: name,
+                distributionNftId: distributionNftId,
+                minDiscountPercentage: minDiscountPercentage,
+                maxDiscountPercentage: maxDiscountPercentage,
+                commissionPercentage: commissionPercentage,
+                maxReferralCount: maxReferralCount,
+                maxReferralLifetime: maxReferralLifetime,
+                allowSelfReferrals: allowSelfReferrals,
+                allowRenewals: allowRenewals,
+                data: data});
+
+            instance.getInstanceStore().createDistributorType(distributorType, info);
+        }
 
-        emit LogDistributionServiceDistributorTypeCreated(distributionNftId, name, commissionPercentage);
+        emit LogDistributionServiceDistributorTypeCreated(distributionNftId, distributorType, name, commissionPercentage);
     }
 
 
@@ -148,7 +151,7 @@ contract DistributionService is
 
         instance.getInstanceStore().createDistributor(distributorNftId, info);
 
-        emit LogDistributionServiceDistributorCreated(distributionNftId, distributorNftId, distributorType, distributor);
+        emit LogDistributionServiceDistributorCreated(distributionNftId, distributorNftId, distributor, distributorType);
     }
 
     function changeDistributorType(
@@ -236,7 +239,7 @@ contract DistributionService is
 
             instance.getInstanceStore().createReferral(referralId, info);
 
-            emit LogDistributionServiceReferralCreated(distributionNftId, distributorNftId, referralId, code, discountPercentage, maxReferrals, expiryAt);
+            emit LogDistributionServiceReferralCreated(distributorNftId, referralId, code, discountPercentage, maxReferrals, expiryAt);
         }
     }
 
@@ -258,7 +261,7 @@ contract DistributionService is
             referralInfo.usedReferrals += 1;
             instance.getInstanceStore().updateReferral(referralId, referralInfo, KEEP_STATE());
 
-            emit LogDistributionServiceReferralProcessed(distributionNftId, referralInfo.distributorNftId, referralId, referralInfo.usedReferrals);
+            emit LogDistributionServiceReferralProcessed(referralInfo.distributorNftId, referralId, referralInfo.usedReferrals);
         }
     }
 
@@ -299,7 +302,7 @@ contract DistributionService is
         } else {
             // increase distribution balance by distribution owner fee
             _accountingService.increaseDistributionBalance(store, distributionNftId, AmountLib.zero(), distributionOwnerFee);
-            emit LogDistributionServiceSaleProcessed(distributionNftId, referralId, premium.premiumAmount, distributionOwnerFee);
+            emit LogDistributionServiceSaleProcessed(distributionNftId, premium.premiumAmount, distributionOwnerFee);
         }
 
         
@@ -343,7 +346,7 @@ contract DistributionService is
         // transfer amount to distributor
         {
             address distributor = getRegistry().ownerOf(distributorNftId);
-            emit LogDistributionServiceCommissionWithdrawn(distributorNftId, distributor, address(distributionInfo.tokenHandler.TOKEN()), withdrawnAmount);
+            emit LogDistributionServiceCommissionWithdrawn(distributorNftId, distributor, withdrawnAmount, address(distributionInfo.tokenHandler.TOKEN()));
             distributionInfo.tokenHandler.pushToken(distributor, withdrawnAmount);
         }
     }

package/contracts/distribution/IDistributionComponent.sol

@@ -11,8 +11,6 @@ import {UFixed} from "../type/UFixed.sol";
 
 interface IDistributionComponent is IInstanceLinkedComponent {
 
-    event LogDistributorUpdated(address to, address operator);
-
     function getDiscountPercentage(
         string memory referralCode
     ) external view returns (UFixed discountPercentage, ReferralStatus status);

package/contracts/distribution/IDistributionService.sol

@@ -39,14 +39,14 @@ interface IDistributionService is IService {
     error ErrorDistributionServiceInvalidFeeTransferred(Amount transferredDistributionFeeAmount, Amount expectedDistributionFeeAmount);
     error ErrorDistributionServiceReferralDistributionMismatch(ReferralId referralId, NftId referralDistributionNft, NftId distributionNftId);
 
-    event LogDistributionServiceCommissionWithdrawn(NftId distributorNftId, address recipient, address tokenAddress, Amount amount);
-    event LogDistributionServiceDistributorTypeCreated(NftId distributionNftId, string name, UFixed commissionPercentage);
-    event LogDistributionServiceDistributorCreated(NftId distributionNftId, NftId distributorNftId, DistributorType distributorType, address distributor);
-    event LogDistributionServiceDistributorTypeChanged(NftId distributorNftId, DistributorType oldDistributorType, DistributorType newDistributorType);
-    event LogDistributionServiceReferralCreated(NftId distributionNftId, NftId distributorNftId, ReferralId referralId, string code, UFixed discountPercentage, uint32 maxReferrals, Timestamp expiryAt);
-    event LogDistributionServiceReferralProcessed(NftId distributionNftId, NftId distributorNftId, ReferralId referralId, uint32 usedReferrals);
-    event LogDistributionServiceSaleProcessed(NftId distributionNftId, ReferralId referralId, Amount premium, Amount distributionOwnerFee);
-    event LogDistributionServiceSaleProcessedWithReferral(NftId distributionNftId, NftId distributorNftId, ReferralId referralId, uint32 numPoliciesSold, Amount premium, Amount distributionOwnerFee, Amount commissionAmount);
+    event LogDistributionServiceCommissionWithdrawn(NftId indexed distributorNftId, address indexed recipient, Amount amount, address indexed tokenAddress);
+    event LogDistributionServiceDistributorTypeCreated(NftId indexed distributionNftId, DistributorType indexed distributorType, string name, UFixed commissionPercentage);
+    event LogDistributionServiceDistributorCreated(NftId indexed distributionNftId, NftId indexed distributorNftId, address indexed distributor, DistributorType distributorType);
+    event LogDistributionServiceDistributorTypeChanged(NftId indexed distributorNftId, DistributorType indexed oldDistributorType, DistributorType indexed newDistributorType);
+    event LogDistributionServiceReferralCreated(NftId indexed distributorNftId, ReferralId indexed referralId, string code, UFixed discountPercentage, uint32 maxReferrals, Timestamp expiryAt);
+    event LogDistributionServiceReferralProcessed(NftId indexed distributorNftId, ReferralId indexed referralId, uint32 usedReferrals);
+    event LogDistributionServiceSaleProcessed(NftId indexed distributionNftId, Amount premium, Amount distributionOwnerFee);
+    event LogDistributionServiceSaleProcessedWithReferral(NftId indexed distributionNftId, NftId indexed distributorNftId, ReferralId indexed referralId, uint32 numPoliciesSold, Amount premium, Amount distributionOwnerFee, Amount commissionAmount);
 
     function createDistributorType(
         string memory name,

package/contracts/examples/crop/AccountingToken.sol

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

package/contracts/examples/crop/CropPool.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IAuthorization} from "../../authorization/IAuthorization.sol";
+import {IComponents} from "../../instance/module/IComponents.sol";
+
+import {Amount, AmountLib} from "../../type/Amount.sol";
+import {BasicPool} from "../../pool/BasicPool.sol";
+import {FeeLib} from "../../type/Fee.sol";
+import {NftId} from "../../type/NftId.sol";
+import {SecondsLib} from "../../type/Seconds.sol";
+import {UFixedLib} from "../../type/UFixed.sol";
+
+
+/// @dev CropPool implements the pool for the crop product.
+/// Only the pool owner is allowed to create and manage bundles.
+contract CropPool is
+    BasicPool
+{   
+    constructor(
+        address registry,
+        NftId productNftId,
+        string memory componentName,
+        IAuthorization authorization
+    ) 
+    {
+        address initialOwner = msg.sender;
+        _intialize(
+            registry,
+            productNftId,
+            componentName,
+            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 productNftId,
+        string memory componentName,
+        IComponents.PoolInfo memory poolInfo,
+        IAuthorization authorization,
+        address initialOwner
+    )
+        internal
+        initializer
+    {
+        _initializeBasicPool(
+            registry,
+            productNftId,
+            componentName,
+            poolInfo,
+            authorization,
+            initialOwner);
+    }
+
+    function createBundle(
+        Amount initialAmount
+    )
+        external
+        virtual 
+        restricted()
+        onlyOwner()
+        returns(NftId bundleNftId)
+    {
+        address owner = msg.sender;
+        bundleNftId = _createBundle(
+            owner,
+            FeeLib.zero(),
+            SecondsLib.fromDays(90),
+            "" // filter
+        );
+
+        _stake(bundleNftId, initialAmount);
+    }
+
+    function approveTokenHandler(IERC20Metadata token, Amount amount) external restricted() onlyOwner() { _approveTokenHandler(token, amount); }
+    function setWallet(address newWallet) external restricted() onlyOwner() { _setWallet(newWallet); }
+}

package/contracts/examples/crop/CropPoolAuthorization.sol

@@ -0,0 +1,37 @@
+
+
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccess} from "../../../contracts/authorization/IAccess.sol";
+
+import {BasicPoolAuthorization} from "../../pool/BasicPoolAuthorization.sol";
+import {CropPool} from "./CropPool.sol";
+import {PUBLIC_ROLE} from "../../../contracts/type/RoleId.sol";
+
+contract CropPoolAuthorization
+    is BasicPoolAuthorization
+{
+
+    constructor(string memory poolName)
+        BasicPoolAuthorization(poolName)
+    {}
+
+
+    function _setupTargetAuthorizations()
+        internal
+        virtual override
+    {
+        super._setupTargetAuthorizations();
+        IAccess.FunctionInfo[] storage functions;
+
+        // authorize public role (also protected by onlyOwner)
+        functions = _authorizeForTarget(getMainTargetName(), PUBLIC_ROLE());
+
+        // only owner
+        _authorize(functions, CropPool.createBundle.selector, "createBundle");
+        _authorize(functions, CropPool.approveTokenHandler.selector, "approveTokenHandler");
+        _authorize(functions, CropPool.setWallet.selector, "setWallet");
+    }
+}
+