Optimizing the fee estimation calculation interface.

contract/AElf.Contracts.MultiToken/TokenContractConstants.cs

@@ -22,4 +22,6 @@ public static class TokenContractConstants
     public const string SeedCollectionSymbol = "SEED-0";
     public const string SeedOwnedSymbolExternalInfoKey = "__seed_owned_symbol";
     public const string SeedExpireTimeExternalInfoKey = "__seed_exp_time";
+    public const string NftCreateChainIdExternalInfoKey = "__nft_create_chain_id";
+    public const int DefaultMaxBatchApproveCount = 100;
 }

contract/AElf.Contracts.MultiToken/TokenContractState.cs

@@ -65,4 +65,6 @@ public partial class TokenContractState : ContractState
     public SingletonState<Address> VoteContractAddress { get; set; }
 
     public SingletonState<bool> TokenIssuerAndOwnerModificationDisabled { get; set; }
+
+    public SingletonState<int> MaxBatchApproveCount { get; set; }
 }

contract/AElf.Contracts.MultiToken/TokenContract_Actions.cs

@@ -32,8 +32,6 @@ public override Empty InitializeFromParentChain(InitializeFromParentChainInput i
     /// <returns></returns>
     public override Empty Create(CreateInput input)
     {
-        // can not call create on side chain
-        Assert(State.SideChainCreator.Value == null, "Failed to create token if side chain creator already set.");
         var inputSymbolType = GetCreateInputSymbolType(input.Symbol);
         if (input.Owner == null)
         {
@@ -52,6 +50,9 @@ private Empty CreateToken(CreateInput input, SymbolType symbolType = SymbolType.
         AssertValidCreateInput(input, symbolType);
         if (symbolType == SymbolType.Token || symbolType == SymbolType.NftCollection)
         {
+            // can not call create on side chain
+            Assert(State.SideChainCreator.Value == null,
+                "Failed to create token if side chain creator already set.");
             if (!IsAddressInCreateWhiteList(Context.Sender) &&
                 input.Symbol != TokenContractConstants.SeedCollectionSymbol)
             {
@@ -253,14 +254,35 @@ public override Empty Approve(ApproveInput input)
     {
         AssertValidInputAddress(input.Spender);
         AssertValidToken(input.Symbol, input.Amount);
-        State.Allowances[Context.Sender][input.Spender][input.Symbol] = input.Amount;
+        Approve(input.Spender, input.Symbol, input.Amount);
+        return new Empty();
+    }
+
+    private void Approve(Address spender, string symbol, long amount)
+    {
+        State.Allowances[Context.Sender][spender][symbol] = amount;
         Context.Fire(new Approved
         {
             Owner = Context.Sender,
-            Spender = input.Spender,
-            Symbol = input.Symbol,
-            Amount = input.Amount
+            Spender = spender,
+            Symbol = symbol,
+            Amount = amount
         });
+    }
+
+    public override Empty BatchApprove(BatchApproveInput input)
+    {
+        Assert(input != null && input.Value != null && input.Value.Count > 0, "Invalid input .");
+        Assert(input.Value.Count <= GetMaxBatchApproveCount(), "Exceeds the max batch approve count.");
+        foreach (var approve in input.Value)
+        {
+            AssertValidInputAddress(approve.Spender);
+            AssertValidToken(approve.Symbol, approve.Amount);
+        }
+        var approveInputList = input.Value.GroupBy(approve => approve.Symbol + approve.Spender, approve => approve)
+            .Select(approve => approve.Last()).ToList();
+        foreach (var approve in approveInputList)
+            Approve(approve.Spender, approve.Symbol, approve.Amount);
         return new Empty();
     }
 
@@ -468,7 +490,6 @@ public override Empty CrossChainCreateToken(CrossChainCreateTokenInput input)
             Owner = validateTokenInfoExistsInput.Owner ?? validateTokenInfoExistsInput.Issuer
         };
         RegisterTokenInfo(tokenInfo);
-
         Context.Fire(new TokenCreated
         {
             Symbol = validateTokenInfoExistsInput.Symbol,
@@ -626,4 +647,27 @@ public override BoolValue GetTokenIssuerAndOwnerModificationEnabled(Empty input)
             Value = !State.TokenIssuerAndOwnerModificationDisabled.Value
         };
     }
+
+    public override Empty SetMaxBatchApproveCount(Int32Value input)
+    {
+        Assert(input.Value > 0, "Invalid input.");
+        AssertSenderAddressWith(GetDefaultParliamentController().OwnerAddress);
+        State.MaxBatchApproveCount.Value = input.Value;
+        return new Empty();
+    }
+
+    public override Int32Value GetMaxBatchApproveCount(Empty input)
+    {
+        return new Int32Value
+        {
+            Value = GetMaxBatchApproveCount()
+        };
+    }
+
+    private int GetMaxBatchApproveCount()
+    {
+        return State.MaxBatchApproveCount.Value == 0
+            ? TokenContractConstants.DefaultMaxBatchApproveCount
+            : State.MaxBatchApproveCount.Value;
+    }
 }

contract/AElf.Contracts.MultiToken/TokenContract_NFTHelper.cs

@@ -13,8 +13,4 @@ private SymbolType GetCreateInputSymbolType(string symbol)
         return words[1] == TokenContractConstants.CollectionSymbolSuffix ? SymbolType.NftCollection : SymbolType.Nft;
     }
 
-    private void AssertNFTCreateInput(CreateInput input)
-    {
-        Assert(input.Decimals == 0, "NFT's decimals must be 0");
-    }
 }

contract/AElf.Contracts.MultiToken/TokenContract_NFT_Actions.cs

@@ -9,23 +9,34 @@ public partial class TokenContract
 {
     private Empty CreateNFTCollection(CreateInput input)
     {
-        AssertNFTCreateInput(input);
         return CreateToken(input, SymbolType.NftCollection);
     }
 
     private Empty CreateNFTInfo(CreateInput input)
     {
-        AssertNFTCreateInput(input);
         var nftCollectionInfo = AssertNftCollectionExist(input.Symbol);
         input.IssueChainId = input.IssueChainId == 0 ? nftCollectionInfo.IssueChainId : input.IssueChainId;
-        Assert(input.IssueChainId == nftCollectionInfo.IssueChainId,
-            "NFT create ChainId must be collection's issue chainId");
-
+        Assert(
+            input.IssueChainId == nftCollectionInfo.IssueChainId,
+            "NFT issue ChainId must be collection's issue chainId");
+        if (nftCollectionInfo.ExternalInfo != null && nftCollectionInfo.ExternalInfo.Value.TryGetValue(
+                TokenContractConstants.NftCreateChainIdExternalInfoKey,
+                out var nftCreateChainId) && long.TryParse(nftCreateChainId, out var nftCreateChainIdLong))
+        {
+            Assert(nftCreateChainIdLong == Context.ChainId,
+                "NFT create ChainId must be collection's NFT create chainId");
+        }
+        else
+        {
+            Assert(State.SideChainCreator.Value == null,
+                "Failed to create token if side chain creator already set.");
+        }
+
         var owner = nftCollectionInfo.Owner ?? nftCollectionInfo.Issuer;
         Assert(Context.Sender == owner && owner == input.Owner, "NFT owner must be collection's owner");
-
         if (nftCollectionInfo.Symbol == TokenContractConstants.SeedCollectionSymbol)
         {
+            Assert(input.Decimals == 0 && input.TotalSupply == 1, "SEED must be unique.");
             Assert(input.ExternalInfo.Value.TryGetValue(TokenContractConstants.SeedOwnedSymbolExternalInfoKey,
                     out var ownedSymbol), "OwnedSymbol does not exist.");
             Assert(input.ExternalInfo.Value.TryGetValue(TokenContractConstants.SeedExpireTimeExternalInfoKey,

contract/AElf.Contracts.Profit/ProfitContract.cs

@@ -769,18 +769,19 @@ public override Empty ClaimProfits(ClaimProfitsInput input)
         Context.LogDebug(() =>
             $"Profitable details: {profitableDetails.Aggregate("\n", (profit1, profit2) => profit1.ToString() + "\n" + profit2)}");
 
+        var profitableDetailCount =
+            Math.Min(ProfitContractConstants.ProfitReceivingLimitForEachTime, profitableDetails.Count);
+        var maxProfitReceivingPeriodCount = GetMaximumPeriodCountForProfitableDetail(profitableDetailCount);
         // Only can get profit from last profit period to actual last period (profit.CurrentPeriod - 1),
         // because current period not released yet.
-        for (var i = 0;
-             i < Math.Min(ProfitContractConstants.ProfitReceivingLimitForEachTime, profitableDetails.Count);
-             i++)
+        for (var i = 0; i < profitableDetailCount; i++)
         {
             var profitDetail = profitableDetails[i];
             if (profitDetail.LastProfitPeriod == 0)
                 // This detail never performed profit before.
                 profitDetail.LastProfitPeriod = profitDetail.StartPeriod;
 
-            ProfitAllPeriods(scheme, profitDetail, beneficiary);
+            ProfitAllPeriods(scheme, profitDetail, beneficiary, maxProfitReceivingPeriodCount);
         }
 
         var profitDetailsToRemove = profitableDetails
@@ -807,7 +808,41 @@ public override Empty ClaimProfits(ClaimProfitsInput input)
         return new Empty();
     }
 
-    private Dictionary<string, long> ProfitAllPeriods(Scheme scheme, ProfitDetail profitDetail, Address beneficiary,
+    /// <summary>
+    /// This method calculates the maximum period count for a profitable detail
+    /// based on the number of profitable details and the maximum profit receiving period
+    /// For example:
+    /// If the number of profitable detail is 10 and the maximum profit receiving period is 100,
+    /// the maximum period count for a profitable detail will be 10.
+    /// If the number of profitable detail is 10 and the maximum profit receiving period is 5,
+    /// the maximum period count for a profitable detail will be 1.
+    /// </summary>
+    /// <param name="profitableDetailCount">The number of  profitable details</param>
+    /// <returns></returns>
+    private int GetMaximumPeriodCountForProfitableDetail(int profitableDetailCount)
+    {
+        // Get the maximum profit receiving period count
+        var maxPeriodCount = GetMaximumProfitReceivingPeriodCount();
+        // Check if the maximum period count is greater than the profitable detail count
+        // and if the profitable detail count is greater than 0
+        return maxPeriodCount > profitableDetailCount && profitableDetailCount > 0
+            // Divide the maximum period count by the profitable detail count
+            ? maxPeriodCount.Div(profitableDetailCount)
+            // If the conditions are not met, return 1 as the maximum period count
+            : 1;
+    }
+
+    public override Empty SetMaximumProfitReceivingPeriodCount(Int32Value input)
+    {
+        ValidateContractState(State.ParliamentContract, SmartContractConstants.ParliamentContractSystemName);
+        Assert(Context.Sender == State.ParliamentContract.GetDefaultOrganizationAddress.Call(new Empty()),
+            "No permission.");
+        Assert(input.Value > 0, "Invalid maximum profit receiving period count.");
+        State.MaximumProfitReceivingPeriodCount.Value = input.Value;
+        return new Empty();
+    }
+
+    private Dictionary<string, long> ProfitAllPeriods(Scheme scheme, ProfitDetail profitDetail, Address beneficiary, long maxProfitReceivingPeriodCount,
         bool isView = false, string targetSymbol = null)
     {
         var profitsMap = new Dictionary<string, long>();
@@ -818,13 +853,11 @@ private Dictionary<string, long> ProfitAllPeriods(Scheme scheme, ProfitDetail pr
         foreach (var symbol in symbols)
         {
             var totalAmount = 0L;
-            for (var period = profitDetail.LastProfitPeriod;
-                 period <= (profitDetail.EndPeriod == long.MaxValue
-                     ? Math.Min(scheme.CurrentPeriod - 1,
-                         profitDetail.LastProfitPeriod.Add(ProfitContractConstants
-                             .MaximumProfitReceivingPeriodCountOfOneTime))
-                     : Math.Min(scheme.CurrentPeriod - 1, profitDetail.EndPeriod));
-                 period++)
+            var targetPeriod = Math.Min(scheme.CurrentPeriod - 1, profitDetail.EndPeriod);
+            var maxProfitPeriod = profitDetail.EndPeriod == long.MaxValue
+                ? Math.Min(scheme.CurrentPeriod - 1, profitDetail.LastProfitPeriod.Add(maxProfitReceivingPeriodCount))
+                : Math.Min(targetPeriod, profitDetail.LastProfitPeriod.Add(maxProfitReceivingPeriodCount));
+            for (var period = profitDetail.LastProfitPeriod; period <= maxProfitPeriod; period++)
             {
                 var periodToPrint = period;
                 var detailToPrint = profitDetail;
@@ -885,6 +918,15 @@ private Dictionary<string, long> ProfitAllPeriods(Scheme scheme, ProfitDetail pr
 
         return profitsMap;
     }
+
+    private int GetMaximumProfitReceivingPeriodCount()
+    {
+        var maxPeriodCount = State.MaximumProfitReceivingPeriodCount.Value;
+        maxPeriodCount = maxPeriodCount == 0
+            ? ProfitContractConstants.DefaultMaximumProfitReceivingPeriodCountOfOneTime
+            : maxPeriodCount;
+        return maxPeriodCount;
+    }
 
     private void ValidateContractState(ContractReferenceState state, string contractSystemName)
     {

contract/AElf.Contracts.Profit/ProfitContractConstants.cs

@@ -6,5 +6,5 @@ public class ProfitContractConstants
     public const int DefaultProfitReceivingDuePeriodCount = 10;
     public const int MaximumProfitReceivingDuePeriodCount = 1024;
     public const int TokenAmountLimit = 5;
-    public const int MaximumProfitReceivingPeriodCountOfOneTime = 100;
+    public const int DefaultMaximumProfitReceivingPeriodCountOfOneTime = 100;
 }

contract/AElf.Contracts.Profit/ProfitContractState.cs

@@ -17,4 +17,6 @@ public partial class ProfitContractState : ContractState
     public MappedState<string, MethodFees> TransactionFees { get; set; }
 
     public SingletonState<AuthorityInfo> MethodFeeController { get; set; }
+
+    public SingletonState<int> MaximumProfitReceivingPeriodCount { get; set; }
 }