Merge branch 'dev' into feature/whitelist-to-sdk

Author: chopin-fan

contract/AElf.Contracts.Consensus.AEDPoS/AEDPoSContract_ProcessConsensusInformation.cs

@@ -127,10 +127,12 @@ private void ProcessNextRound(NextRoundInput input)
             {
                 var minersCount = GetMinersCount(nextRound);
                 if (minersCount != 0 && State.ElectionContract.Value != null)
+                {
                     State.ElectionContract.UpdateMinersCount.Send(new UpdateMinersCountInput
                     {
                         MinersCount = minersCount
                     });
+                }
             }
         }
 

contract/AElf.Contracts.MultiToken/TokenContract_Helper.cs

@@ -215,10 +215,16 @@ private Address ExtractTokenContractAddress(ByteString bytes)
     private void AssertCrossChainTransaction(Transaction originalTransaction, Address validAddress,
         params string[] validMethodNames)
     {
-        var validateResult = validMethodNames.Contains(originalTransaction.MethodName)
+        var validateResult = validMethodNames.Contains(MaybeRecoverInlineTransactionFunctionName(originalTransaction.MethodName))
                              && originalTransaction.To == validAddress;
         Assert(validateResult, "Invalid transaction.");
     }
+    
+    private static string MaybeRecoverInlineTransactionFunctionName(string methodName)
+    {
+        var parts = methodName.Split('.');
+        return parts.Length > 1 ? parts[^2] : methodName;
+    }
 
     private void RegisterTokenInfo(TokenInfo tokenInfo)
     {

protobuf/inline_transaction.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+option csharp_namespace = "AElf.Types";
+
+
+import "aelf/core.proto";
+import "aelf/options.proto";
+
+service InlineTransaction {
+}
+
+message InlineTransactionCreated {
+  option (aelf.is_event) = true;
+  aelf.Transaction transaction = 1 [(aelf.is_indexed) = true];
+}

protobuf/test_virtual_address_contract.proto

@@ -14,6 +14,7 @@ service VirtualAddressContract {
   option (aelf.base) = "acs1.proto";
 
   rpc VirtualAddressVote(VirtualAddressVoteInput) returns (google.protobuf.Empty);
+  rpc VirtualAddressVoteWithInline(VirtualAddressVoteWithCountInput) returns (google.protobuf.Empty);
   rpc VirtualAddressWithdraw(aelf.Hash) returns (google.protobuf.Empty);
   rpc VirtualAddressChangeVotingOption(VirtualAddressChangeVotingOptionInput) returns (google.protobuf.Empty);
   rpc VirtualAddressClaimProfit(VirtualAddressClaimProfitInput) returns (google.protobuf.Empty);
@@ -32,6 +33,11 @@ message VirtualAddressVoteInput {
   aelf.Hash token = 4;
 }
 
+message VirtualAddressVoteWithCountInput {
+  VirtualAddressVoteInput vote_input = 1; // Existing input type
+  int32 count = 2; // Additional count input
+}
+
 message VirtualAddressChangeVotingOptionInput {
   bool is_reset = 1;
   aelf.Hash vote_id = 2;

protobuf/virtual_transaction.proto

@@ -17,4 +17,4 @@ message VirtualTransactionCreated {
   string method_name = 4 [(aelf.is_indexed) = true];
   bytes params = 5;
   aelf.Address signatory = 6 [(aelf.is_indexed) = true];
-}
+}

src/AElf.ContractTestKit.AEDPoSExtension/UnitTestPlainTransactionExecutingService.cs

@@ -2,6 +2,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using AElf.Kernel;
+using AElf.Kernel.Blockchain.Application;
 using AElf.Kernel.FeatureDisable.Core;
 using AElf.Kernel.SmartContract;
 using AElf.Kernel.SmartContract.Application;
@@ -13,8 +14,8 @@ public class UnitTestPlainTransactionExecutingService : PlainTransactionExecutin
 {
     public UnitTestPlainTransactionExecutingService(ISmartContractExecutiveService smartContractExecutiveService,
         IEnumerable<IPostExecutionPlugin> postPlugins, IEnumerable<IPreExecutionPlugin> prePlugins,
-        ITransactionContextFactory transactionContextFactory, IFeatureDisableService featureDisableService) : base(
-        smartContractExecutiveService, postPlugins, prePlugins, transactionContextFactory, featureDisableService)
+        ITransactionContextFactory transactionContextFactory, IFeatureDisableService featureDisableService,IBlockchainService blockchainService) : base(
+        smartContractExecutiveService, postPlugins, prePlugins, transactionContextFactory, featureDisableService,blockchainService)
     {
     }
 

src/AElf.Kernel.Core/Extensions/TransactionExtensions.cs

@@ -16,6 +16,10 @@ public static int Size(this Transaction transaction)
 
     public static bool VerifySignature(this Transaction transaction)
     {
+        if (transaction.IsInlineWithTransactionId())
+        {
+            return true;
+        }
         if (!transaction.VerifyFields())
             return false;
 
@@ -27,7 +31,16 @@ public static bool VerifySignature(this Transaction transaction)
 
     public static bool VerifyExpiration(this Transaction transaction, long chainBranchBlockHeight)
     {
+        if (transaction.IsInlineWithTransactionId())
+        {
+            return true;
+        }
         return transaction.RefBlockNumber <= chainBranchBlockHeight &&
                transaction.GetExpiryBlockNumber() > chainBranchBlockHeight;
     }
+
+    public static bool IsInlineWithTransactionId(this Transaction transaction)
+    {
+        return transaction.MethodName.Contains(".");
+    }
 }

src/AElf.Kernel.SmartContract/AElf.Kernel.SmartContract.csproj

@@ -22,5 +22,8 @@
         <ContractMessage Include="..\..\protobuf\virtual_transaction.proto">
             <Link>Protobuf\Proto\virtual_transaction.proto</Link>
         </ContractMessage>
+        <ContractMessage Include="..\..\protobuf\inline_transaction.proto">
+            <Link>Protobuf\Proto\inline_transaction.proto</Link>
+        </ContractMessage>
     </ItemGroup>
 </Project>

src/AElf.Kernel.SmartContract/Application/PlainTransactionExecutingService.cs

@@ -3,6 +3,8 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using AElf.CSharp.Core.Extension;
+using AElf.Kernel.Blockchain.Application;
 using AElf.Kernel.FeatureDisable.Core;
 using AElf.Kernel.SmartContract.Domain;
 using AElf.Kernel.SmartContract.Infrastructure;
@@ -23,14 +25,17 @@ public class PlainTransactionExecutingService : IPlainTransactionExecutingServic
     private readonly ISmartContractExecutiveService _smartContractExecutiveService;
     private readonly ITransactionContextFactory _transactionContextFactory;
     private readonly IFeatureDisableService _featureDisableService;
+    private readonly IBlockchainService _blockchainService;
 
     public PlainTransactionExecutingService(ISmartContractExecutiveService smartContractExecutiveService,
         IEnumerable<IPostExecutionPlugin> postPlugins, IEnumerable<IPreExecutionPlugin> prePlugins,
-        ITransactionContextFactory transactionContextFactory, IFeatureDisableService featureDisableService)
+        ITransactionContextFactory transactionContextFactory, IFeatureDisableService featureDisableService,
+        IBlockchainService blockchainService)
     {
         _smartContractExecutiveService = smartContractExecutiveService;
         _transactionContextFactory = transactionContextFactory;
         _featureDisableService = featureDisableService;
+        _blockchainService = blockchainService;
         _prePlugins = GetUniquePlugins(prePlugins);
         _postPlugins = GetUniquePlugins(postPlugins);
         Logger = NullLogger<PlainTransactionExecutingService>.Instance;
@@ -61,6 +66,7 @@ public async Task<List<ExecutionReturnSet>> ExecuteAsync(TransactionExecutingDto
                 var singleTxExecutingDto = new SingleTransactionExecutingDto
                 {
                     Depth = 0,
+                    InlineWithTransactionIdCounter = new InlineWithTransactionIdCounter(),
                     ChainContext = groupChainContext,
                     Transaction = transaction,
                     CurrentBlockTime = transactionExecutingDto.BlockHeader.Time,
@@ -71,7 +77,7 @@ public async Task<List<ExecutionReturnSet>> ExecuteAsync(TransactionExecutingDto
                     var transactionExecutionTask = Task.Run(() => ExecuteOneAsync(singleTxExecutingDto,
                         cancellationToken), cancellationToken);
 
-                    trace = await transactionExecutionTask.WithCancellation(cancellationToken);
+                    trace = await transactionExecutionTask;
                 }
                 catch (OperationCanceledException)
                 {
@@ -90,7 +96,7 @@ public async Task<List<ExecutionReturnSet>> ExecuteAsync(TransactionExecutingDto
                 var result = GetTransactionResult(trace, transactionExecutingDto.BlockHeader.Height);
 
                 var returnSet = GetReturnSet(trace, result);
-                returnSets.Add(returnSet);
+                returnSets.AddRange(returnSet);
             }
 
             return returnSets;
@@ -175,14 +181,22 @@ protected virtual async Task<TransactionTrace> ExecuteOneAsync(
 
             #endregion
 
+            var methodName = txContext.Transaction.MethodName;
+            var originMethodName = MaybeRecoverInlineTransactionFunctionName(methodName);
+            txContext.Transaction.MethodName = originMethodName;
+
             await executive.ApplyAsync(txContext);
 
             if (txContext.Trace.IsSuccessful())
+            {
+                // Maybe layered method name.
+                txContext.Transaction.MethodName = methodName;
                 await ExecuteInlineTransactions(singleTxExecutingDto.Depth, singleTxExecutingDto.CurrentBlockTime,
                     txContext, internalStateCache,
                     internalChainContext,
                     singleTxExecutingDto.OriginTransactionId,
                     cancellationToken);
+            }
 
             #region PostTransaction
 
@@ -221,11 +235,40 @@ private async Task ExecuteInlineTransactions(int depth, Timestamp currentBlockTi
     {
         var trace = txContext.Trace;
         internalStateCache.Update(txContext.Trace.GetStateSets());
+
+        var methodNameCount = new Dictionary<string, int>();
         foreach (var inlineTx in txContext.Trace.InlineTransactions)
         {
+            var needTxId = NeedTransactionId(inlineTx.MethodName);
+            if (needTxId)
+            {
+                txContext.InlineWithTransactionIdCounter.Increment();
+                if (!methodNameCount.TryAdd(inlineTx.MethodName, 0))
+                {
+                    methodNameCount[inlineTx.MethodName]++;
+                    inlineTx.MethodName =
+                        GenerateLayeredMethodNameForInlineTransaction(
+                            txContext.Transaction,
+                            inlineTx.MethodName,
+                            methodNameCount[inlineTx.MethodName]
+                        );
+                }
+                else
+                {
+                    inlineTx.MethodName = GenerateLayeredMethodNameForInlineTransaction(
+                        txContext.Transaction,
+                        inlineTx.MethodName,
+                        0
+                    );
+                }
+
+                await _blockchainService.AddTransactionsAsync([inlineTx]);
+            }
+
             var singleTxExecutingDto = new SingleTransactionExecutingDto
             {
                 Depth = depth + 1,
+                InlineWithTransactionIdCounter = txContext.InlineWithTransactionIdCounter,
                 ChainContext = internalChainContext,
                 Transaction = inlineTx,
                 CurrentBlockTime = currentBlockTime,
@@ -246,6 +289,25 @@ private async Task ExecuteInlineTransactions(int depth, Timestamp currentBlockTi
         }
     }
 
+    private static string GenerateLayeredMethodNameForInlineTransaction(Transaction parentTx, string inlineFunctionName,
+        int index)
+    {
+        var parentTxMethodName = parentTx.MethodName;
+        inlineFunctionName = inlineFunctionName.StartsWith('.') ? inlineFunctionName[1..] : inlineFunctionName;
+        return $"{parentTx.GetHash().ToHex()}.{parentTxMethodName}.{inlineFunctionName}.{index}";
+    }
+
+    private static string MaybeRecoverInlineTransactionFunctionName(string methodName)
+    {
+        var parts = methodName.Split('.');
+        return parts.Length > 1 ? parts[^2] : methodName;
+    }
+
+    private static bool NeedTransactionId(string methodName)
+    {
+        return methodName.Contains('.');
+    }
+
     private async Task<bool> ExecutePluginOnPreTransactionStageAsync(IExecutive executive,
         ITransactionContext txContext,
         Timestamp currentBlockTime,
@@ -393,7 +455,7 @@ private TransactionResult GetTransactionResult(TransactionTrace trace, long bloc
         return txResult;
     }
 
-    private ExecutionReturnSet GetReturnSet(TransactionTrace trace, TransactionResult result)
+    private IEnumerable<ExecutionReturnSet> GetReturnSet(TransactionTrace trace, TransactionResult result)
     {
         var returnSet = new ExecutionReturnSet
         {
@@ -402,12 +464,41 @@ private ExecutionReturnSet GetReturnSet(TransactionTrace trace, TransactionResul
             Bloom = result.Bloom,
             TransactionResult = result
         };
+        var returnSets = new List<ExecutionReturnSet> { returnSet };
 
         if (trace.IsSuccessful())
         {
             var transactionExecutingStateSets = trace.GetStateSets();
             returnSet = GetReturnSet(returnSet, transactionExecutingStateSets);
             returnSet.ReturnValue = trace.ReturnValue;
+
+            var inlineTxWithIdList = trace.GetAllInlineTransactions().Where(tx => NeedTransactionId(tx.MethodName));
+            foreach (var inlineTx in inlineTxWithIdList)
+            {
+                var inlineTxId = inlineTx.GetHash();
+                var inlineReturnSet = new ExecutionReturnSet
+                {
+                    TransactionId = inlineTxId,
+                    Status = TransactionResultStatus.Mined,
+                    TransactionResult = new TransactionResult
+                    {
+                        TransactionId = inlineTxId,
+                        BlockNumber = result.BlockNumber,
+                        Status = TransactionResultStatus.Mined
+                    }
+                };
+
+                // No need to execute GetReturnSet method, because changes are already set to `returnSet`.
+
+                returnSets.Add(inlineReturnSet);
+
+                Logger.LogWarning($"Inline tx id: {inlineTx.GetHash().ToHex()}\n{inlineTx}");
+                var log = new InlineTransactionCreated()
+                {
+                    Transaction = inlineTx
+                };
+                returnSet.TransactionResult.Logs.Add(log.ToLogEvent(inlineTx.To));
+            }
         }
         else
         {
@@ -426,7 +517,7 @@ private ExecutionReturnSet GetReturnSet(TransactionTrace trace, TransactionResul
         var reads = trace.GetFlattenedReads();
         foreach (var read in reads) returnSet.StateAccesses[read.Key] = read.Value;
 
-        return returnSet;
+        return returnSets;
     }
 
     private ExecutionReturnSet GetReturnSet(ExecutionReturnSet returnSet,
@@ -476,6 +567,7 @@ protected ITransactionContext CreateTransactionContext(SingleTransactionExecutin
             singleTxExecutingDto.ChainContext, singleTxExecutingDto.OriginTransactionId, origin,
             singleTxExecutingDto.Depth, singleTxExecutingDto.CurrentBlockTime);
 
+        txContext.InlineWithTransactionIdCounter = singleTxExecutingDto.InlineWithTransactionIdCounter;
         return txContext;
     }
 }

src/AElf.Kernel.SmartContract/Dto/SingleTransactionExecutingDto.cs

@@ -13,4 +13,5 @@ public class SingleTransactionExecutingDto
     public bool IsCancellable { get; set; } = true;
 
     public Hash OriginTransactionId { get; set; }
+    public InlineWithTransactionIdCounter InlineWithTransactionIdCounter { get; set; }
 }