diff --git a/contract/AElf.Contracts.MultiToken/TokenContract_Helper.cs b/contract/AElf.Contracts.MultiToken/TokenContract_Helper.cs
index f318c9fd27..3a78c60cbe 100644
--- a/contract/AElf.Contracts.MultiToken/TokenContract_Helper.cs
+++ b/contract/AElf.Contracts.MultiToken/TokenContract_Helper.cs
@@ -215,16 +215,10 @@ private Address ExtractTokenContractAddress(ByteString bytes)
     private void AssertCrossChainTransaction(Transaction originalTransaction, Address validAddress,
         params string[] validMethodNames)
     {
-        var validateResult = validMethodNames.Contains(MaybeRecoverInlineTransactionFunctionName(originalTransaction.MethodName))
+        var validateResult = validMethodNames.Contains(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)
     {
diff --git a/protobuf/test_virtual_address_contract.proto b/protobuf/test_virtual_address_contract.proto
index 992ad86fbf..cdfb14fa05 100644
--- a/protobuf/test_virtual_address_contract.proto
+++ b/protobuf/test_virtual_address_contract.proto
@@ -14,7 +14,6 @@ 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);
@@ -33,11 +32,6 @@ 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;
diff --git a/src/AElf.ContractTestKit.AEDPoSExtension/UnitTestPlainTransactionExecutingService.cs b/src/AElf.ContractTestKit.AEDPoSExtension/UnitTestPlainTransactionExecutingService.cs
index c3eabef06d..37f1b50c43 100644
--- a/src/AElf.ContractTestKit.AEDPoSExtension/UnitTestPlainTransactionExecutingService.cs
+++ b/src/AElf.ContractTestKit.AEDPoSExtension/UnitTestPlainTransactionExecutingService.cs
@@ -2,7 +2,6 @@
 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;
@@ -14,8 +13,8 @@ public class UnitTestPlainTransactionExecutingService : PlainTransactionExecutin
 {
     public UnitTestPlainTransactionExecutingService(ISmartContractExecutiveService smartContractExecutiveService,
         IEnumerable<IPostExecutionPlugin> postPlugins, IEnumerable<IPreExecutionPlugin> prePlugins,
-        ITransactionContextFactory transactionContextFactory, IFeatureDisableService featureDisableService,IBlockchainService blockchainService) : base(
-        smartContractExecutiveService, postPlugins, prePlugins, transactionContextFactory, featureDisableService,blockchainService)
+        ITransactionContextFactory transactionContextFactory, IFeatureDisableService featureDisableService) : base(
+        smartContractExecutiveService, postPlugins, prePlugins, transactionContextFactory, featureDisableService)
     {
     }
 
diff --git a/src/AElf.Kernel.Core/Extensions/TransactionExtensions.cs b/src/AElf.Kernel.Core/Extensions/TransactionExtensions.cs
index 6a845b9df4..4c3e8e3242 100644
--- a/src/AElf.Kernel.Core/Extensions/TransactionExtensions.cs
+++ b/src/AElf.Kernel.Core/Extensions/TransactionExtensions.cs
@@ -16,10 +16,6 @@ public static int Size(this Transaction transaction)
 
     public static bool VerifySignature(this Transaction transaction)
     {
-        if (transaction.IsInlineWithTransactionId())
-        {
-            return true;
-        }
         if (!transaction.VerifyFields())
             return false;
 
@@ -31,16 +27,7 @@ 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(".");
-    }
 }
\ No newline at end of file
diff --git a/src/AElf.Kernel.SmartContract/AElf.Kernel.SmartContract.csproj b/src/AElf.Kernel.SmartContract/AElf.Kernel.SmartContract.csproj
index 2358852342..ab2cf443cf 100644
--- a/src/AElf.Kernel.SmartContract/AElf.Kernel.SmartContract.csproj
+++ b/src/AElf.Kernel.SmartContract/AElf.Kernel.SmartContract.csproj
@@ -22,8 +22,5 @@
         <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>
\ No newline at end of file
diff --git a/src/AElf.Kernel.SmartContract/Application/PlainTransactionExecutingService.cs b/src/AElf.Kernel.SmartContract/Application/PlainTransactionExecutingService.cs
index d3531087cd..79b09034f9 100644
--- a/src/AElf.Kernel.SmartContract/Application/PlainTransactionExecutingService.cs
+++ b/src/AElf.Kernel.SmartContract/Application/PlainTransactionExecutingService.cs
@@ -3,8 +3,6 @@
 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;
@@ -25,17 +23,14 @@ 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,
-        IBlockchainService blockchainService)
+        ITransactionContextFactory transactionContextFactory, IFeatureDisableService featureDisableService)
     {
         _smartContractExecutiveService = smartContractExecutiveService;
         _transactionContextFactory = transactionContextFactory;
         _featureDisableService = featureDisableService;
-        _blockchainService = blockchainService;
         _prePlugins = GetUniquePlugins(prePlugins);
         _postPlugins = GetUniquePlugins(postPlugins);
         Logger = NullLogger<PlainTransactionExecutingService>.Instance;
@@ -66,7 +61,6 @@ public async Task<List<ExecutionReturnSet>> ExecuteAsync(TransactionExecutingDto
                 var singleTxExecutingDto = new SingleTransactionExecutingDto
                 {
                     Depth = 0,
-                    InlineWithTransactionIdCounter = new InlineWithTransactionIdCounter(),
                     ChainContext = groupChainContext,
                     Transaction = transaction,
                     CurrentBlockTime = transactionExecutingDto.BlockHeader.Time,
@@ -77,7 +71,7 @@ public async Task<List<ExecutionReturnSet>> ExecuteAsync(TransactionExecutingDto
                     var transactionExecutionTask = Task.Run(() => ExecuteOneAsync(singleTxExecutingDto,
                         cancellationToken), cancellationToken);
 
-                    trace = await transactionExecutionTask;
+                    trace = await transactionExecutionTask.WithCancellation(cancellationToken);
                 }
                 catch (OperationCanceledException)
                 {
@@ -96,7 +90,7 @@ public async Task<List<ExecutionReturnSet>> ExecuteAsync(TransactionExecutingDto
                 var result = GetTransactionResult(trace, transactionExecutingDto.BlockHeader.Height);
 
                 var returnSet = GetReturnSet(trace, result);
-                returnSets.AddRange(returnSet);
+                returnSets.Add(returnSet);
             }
 
             return returnSets;
@@ -181,22 +175,14 @@ 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
 
@@ -235,40 +221,11 @@ 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,
@@ -289,25 +246,6 @@ 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,
@@ -455,7 +393,7 @@ private TransactionResult GetTransactionResult(TransactionTrace trace, long bloc
         return txResult;
     }
 
-    private IEnumerable<ExecutionReturnSet> GetReturnSet(TransactionTrace trace, TransactionResult result)
+    private ExecutionReturnSet GetReturnSet(TransactionTrace trace, TransactionResult result)
     {
         var returnSet = new ExecutionReturnSet
         {
@@ -464,41 +402,12 @@ private IEnumerable<ExecutionReturnSet> GetReturnSet(TransactionTrace trace, Tra
             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
         {
@@ -517,7 +426,7 @@ private IEnumerable<ExecutionReturnSet> GetReturnSet(TransactionTrace trace, Tra
         var reads = trace.GetFlattenedReads();
         foreach (var read in reads) returnSet.StateAccesses[read.Key] = read.Value;
 
-        return returnSets;
+        return returnSet;
     }
 
     private ExecutionReturnSet GetReturnSet(ExecutionReturnSet returnSet,
@@ -567,7 +476,6 @@ protected ITransactionContext CreateTransactionContext(SingleTransactionExecutin
             singleTxExecutingDto.ChainContext, singleTxExecutingDto.OriginTransactionId, origin,
             singleTxExecutingDto.Depth, singleTxExecutingDto.CurrentBlockTime);
 
-        txContext.InlineWithTransactionIdCounter = singleTxExecutingDto.InlineWithTransactionIdCounter;
         return txContext;
     }
 }
\ No newline at end of file
diff --git a/src/AElf.Kernel.SmartContract/Dto/SingleTransactionExecutingDto.cs b/src/AElf.Kernel.SmartContract/Dto/SingleTransactionExecutingDto.cs
index 9c50702cfa..7dfe93020b 100644
--- a/src/AElf.Kernel.SmartContract/Dto/SingleTransactionExecutingDto.cs
+++ b/src/AElf.Kernel.SmartContract/Dto/SingleTransactionExecutingDto.cs
@@ -13,5 +13,4 @@ public class SingleTransactionExecutingDto
     public bool IsCancellable { get; set; } = true;
 
     public Hash OriginTransactionId { get; set; }
-    public InlineWithTransactionIdCounter InlineWithTransactionIdCounter { get; set; }
 }
\ No newline at end of file
diff --git a/src/AElf.Kernel.SmartContract/ITransactionContext.cs b/src/AElf.Kernel.SmartContract/ITransactionContext.cs
index 1d4ab59fbe..0f1a3cecad 100644
--- a/src/AElf.Kernel.SmartContract/ITransactionContext.cs
+++ b/src/AElf.Kernel.SmartContract/ITransactionContext.cs
@@ -16,5 +16,4 @@ public interface ITransactionContext
     Transaction Transaction { get; set; }
     TransactionTrace Trace { get; set; }
     IStateCache StateCache { get; set; }
-    InlineWithTransactionIdCounter InlineWithTransactionIdCounter { get; set; }
 }
\ No newline at end of file
diff --git a/src/AElf.Kernel.SmartContract/InlineWithTransactionIdCounter.cs b/src/AElf.Kernel.SmartContract/InlineWithTransactionIdCounter.cs
deleted file mode 100644
index 1ae06c2504..0000000000
--- a/src/AElf.Kernel.SmartContract/InlineWithTransactionIdCounter.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using System.Threading;
-
-namespace AElf.Kernel.SmartContract;
-
-public class InlineWithTransactionIdCounter
-{
-    private int _count = 0;
-
-    public void Increment()
-    {
-        Interlocked.Increment(ref _count);
-    }
-
-    public int GetCount()
-    {
-        return _count;
-    }
-}
\ No newline at end of file
diff --git a/src/AElf.Kernel.SmartContract/TransactionContext.cs b/src/AElf.Kernel.SmartContract/TransactionContext.cs
index 2e76fcf5b1..aaf3fe79e6 100644
--- a/src/AElf.Kernel.SmartContract/TransactionContext.cs
+++ b/src/AElf.Kernel.SmartContract/TransactionContext.cs
@@ -16,5 +16,4 @@ public class TransactionContext : ITransactionContext
     public Transaction Transaction { get; set; }
     public TransactionTrace Trace { get; set; }
     public IStateCache StateCache { get; set; }
-    public InlineWithTransactionIdCounter InlineWithTransactionIdCounter { get; set; }
 }
\ No newline at end of file
diff --git a/src/AElf.Kernel.SmartContractExecution/Application/BlockExecutingService.cs b/src/AElf.Kernel.SmartContractExecution/Application/BlockExecutingService.cs
index e7538a59b0..6dcfca3178 100644
--- a/src/AElf.Kernel.SmartContractExecution/Application/BlockExecutingService.cs
+++ b/src/AElf.Kernel.SmartContractExecution/Application/BlockExecutingService.cs
@@ -55,13 +55,8 @@ public async Task<BlockExecutedSet> ExecuteBlockAsync(BlockHeader blockHeader,
         CancellationToken cancellationToken)
     {
         Logger.LogTrace("Entered ExecuteBlockAsync");
-
-        var nonCancellable = nonCancellableTransactions.ToList()
-            .Where(tx => !tx.MethodName.Contains('.')).ToList();
-
-        var cancellable = cancellableTransactions.ToList()
-            .Where(tx => !tx.MethodName.Contains('.')).ToList();
-
+        var nonCancellable = nonCancellableTransactions.ToList();
+        var cancellable = cancellableTransactions.ToList();
         var nonCancellableReturnSets =
             await _transactionExecutingService.ExecuteAsync(
                 new TransactionExecutingDto { BlockHeader = blockHeader, Transactions = nonCancellable },
@@ -73,16 +68,15 @@ await _transactionExecutingService.ExecuteAsync(
 
         if (!cancellationToken.IsCancellationRequested && cancellable.Count > 0)
         {
-            var txExecutingDto = new TransactionExecutingDto
-            {
-                BlockHeader = blockHeader,
-                Transactions = cancellable,
-                PartialBlockStateSet = returnSetCollection.ToBlockStateSet()
-            };
             cancellableReturnSets = await _transactionExecutingService.ExecuteAsync(
-                txExecutingDto, cancellationToken);
+                new TransactionExecutingDto
+                {
+                    BlockHeader = blockHeader,
+                    Transactions = cancellable,
+                    PartialBlockStateSet = returnSetCollection.ToBlockStateSet()
+                },
+                cancellationToken);
             returnSetCollection.AddRange(cancellableReturnSets);
-            cancellable = txExecutingDto.Transactions.ToList();
             Logger.LogTrace("Executed cancellable txs");
         }
 
@@ -125,15 +119,7 @@ private Task<Block> FillBlockAfterExecutionAsync(BlockHeader header,
 
         var allExecutedTransactionIds = transactions.Select(x => x.GetHash()).ToList();
         var orderedReturnSets = executionReturnSetCollection.GetExecutionReturnSetList()
-            .OrderBy(d => allExecutedTransactionIds.IndexOf(d.TransactionId) >= 0 ? allExecutedTransactionIds.IndexOf(d.TransactionId) : int.MaxValue)
-            .ThenBy(d => d.TransactionId)
-            .ToList();
-        
-        var inlineTxIds = orderedReturnSets
-            .Where(returnSet => !allExecutedTransactionIds.Contains(returnSet.TransactionId))
-            .Select(returnSet => returnSet.TransactionId)
-            .ToList();
-        allExecutedTransactionIds.AddRange(inlineTxIds);
+            .OrderBy(d => allExecutedTransactionIds.IndexOf(d.TransactionId)).ToList();
 
         var block = new Block
         {
diff --git a/src/AElf.Kernel.TransactionPool/Application/TransactionValidationService.cs b/src/AElf.Kernel.TransactionPool/Application/TransactionValidationService.cs
index 10c4edc1b3..324cfb14d6 100644
--- a/src/AElf.Kernel.TransactionPool/Application/TransactionValidationService.cs
+++ b/src/AElf.Kernel.TransactionPool/Application/TransactionValidationService.cs
@@ -49,10 +49,6 @@ public async Task<bool> ValidateTransactionWhileCollectingAsync(IChainContext ch
 
     public async Task<bool> ValidateTransactionWhileSyncingAsync(Transaction transaction)
     {
-        if (transaction.IsInlineWithTransactionId())
-        {
-            return true;
-        }
         var validationTasks = _transactionValidationProviders.AsParallel()
             .Where(provider => provider.ValidateWhileSyncing).Select(async provider =>
             {
diff --git a/src/AElf.Kernel.Types/Transaction/TransactionTrace.cs b/src/AElf.Kernel.Types/Transaction/TransactionTrace.cs
index cd1f080432..fbf78286a0 100644
--- a/src/AElf.Kernel.Types/Transaction/TransactionTrace.cs
+++ b/src/AElf.Kernel.Types/Transaction/TransactionTrace.cs
@@ -89,24 +89,4 @@ public IEnumerable<TransactionExecutingStateSet> GetStateSets()
             foreach (var stateSet in stateSets) yield return stateSet;
         }
     }
-
-    public List<Transaction> GetAllInlineTransactions()
-    {
-        var transactions = new List<Transaction>();
-        var stack = new Stack<TransactionTrace>();
-        stack.Push(this);
-
-        while (stack.Count > 0)
-        {
-            var currentTrace = stack.Pop();
-            transactions.AddRange(currentTrace.InlineTransactions);
-            if (currentTrace.InlineTraces == null) continue;
-            foreach (var inlineTrace in currentTrace.InlineTraces)
-            {
-                stack.Push(inlineTrace);
-            }
-        }
-
-        return transactions;
-    }
 }
\ No newline at end of file
diff --git a/src/AElf.Runtime.CSharp/Executive.cs b/src/AElf.Runtime.CSharp/Executive.cs
index 48df0dd737..6cb47187c6 100644
--- a/src/AElf.Runtime.CSharp/Executive.cs
+++ b/src/AElf.Runtime.CSharp/Executive.cs
@@ -63,12 +63,6 @@ public Task ApplyAsync(ITransactionContext transactionContext)
                 CurrentTransactionContext.Trace.Error = "\n" + "ExceededMaxCallDepth";
                 return Task.CompletedTask;
             }
-            if (CurrentTransactionContext.InlineWithTransactionIdCounter?.GetCount() > TransactionConsts.InlineWithTransactionIdLimit)
-            {
-                CurrentTransactionContext.Trace.ExecutionStatus = ExecutionStatus.ExceededMaxCallDepth;
-                CurrentTransactionContext.Trace.Error = "\n" + "failed.ExceededMaxInlineWithTransactionIdCount";
-                return Task.CompletedTask;
-            }
 
             Execute();
         }
diff --git a/src/AElf.Runtime.CSharp/TransactionConsts.cs b/src/AElf.Runtime.CSharp/TransactionConsts.cs
deleted file mode 100644
index 06e85b9d73..0000000000
--- a/src/AElf.Runtime.CSharp/TransactionConsts.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace AElf.Runtime.CSharp;
-
-public class TransactionConsts
-{
-    public const int InlineWithTransactionIdLimit = 5;
-}
\ No newline at end of file
diff --git a/src/AElf.WebApp.Application.Chain/Services/TransactionResultAppService.cs b/src/AElf.WebApp.Application.Chain/Services/TransactionResultAppService.cs
index 1faccef3bb..1923b9f989 100644
--- a/src/AElf.WebApp.Application.Chain/Services/TransactionResultAppService.cs
+++ b/src/AElf.WebApp.Application.Chain/Services/TransactionResultAppService.cs
@@ -24,7 +24,7 @@ namespace AElf.WebApp.Application.Chain;
 public interface ITransactionResultAppService
 {
     Task<TransactionResultDto> GetTransactionResultAsync(string transactionId);
-    
+
     Task<TransactionResultDto> GetTransactionResultV2Async(string transactionId);
 
     Task<List<TransactionResultDto>> GetTransactionResultsAsync(string blockHash, int offset = 0,
diff --git a/test/AElf.Contracts.Election.Tests/BVT/ElectionTests.cs b/test/AElf.Contracts.Election.Tests/BVT/ElectionTests.cs
index d6e44f057f..2ba363f220 100644
--- a/test/AElf.Contracts.Election.Tests/BVT/ElectionTests.cs
+++ b/test/AElf.Contracts.Election.Tests/BVT/ElectionTests.cs
@@ -1984,94 +1984,6 @@ await VirtualAddressContractStub.VirtualAddressVote.SendAsync(new VirtualAddress
         return result.ActiveVotingRecords.First().VoteId;
     }
 
-    [Fact]
-    public async Task<Hash> VirtualAddress_Vote_WithInlineTxIdTest()
-    {
-        var amount = 100;
-        const int lockTime = 100 * 60 * 60 * 24;
-        var candidatesKeyPairs = await ElectionContract_AnnounceElection_Test();
-        var candidateKeyPair = candidatesKeyPairs[0];
-        
-        var address = await VirtualAddressContractStub.GetVirtualAddress.CallAsync(new Empty());
-        var initBalance = 100000;
-
-        await TokenContractStub.Transfer.SendAsync(new TransferInput
-        {
-            Amount = initBalance,
-            Symbol = "ELF",
-            To = address,
-            Memo = "test"
-        });
-        
-        CheckBalance(address, "ELF", initBalance);
-        CheckBalance(address, "SHARE", 0);
-        CheckBalance(address, "VOTE", 0);
-
-        var virtualAddressVoteInput = new VirtualAddressVoteInput
-        {
-            PubKey = candidateKeyPair.PublicKey.ToHex(),
-            Amount = amount,
-            EndTimestamp = TimestampHelper.GetUtcNow().AddSeconds(lockTime),
-            Token = HashHelper.ComputeFrom("token A")
-        };
-
-        await VirtualAddressContractStub.VirtualAddressVoteWithInline.SendAsync(new VirtualAddressVoteWithCountInput
-        {
-            VoteInput = virtualAddressVoteInput,
-            Count = 1
-        });
-        
-        var result = await ElectionContractStub.GetElectorVote.CallAsync(new StringValue
-        {
-            Value = address.ToBase58()
-        });
-        result.ActiveVotedVotesAmount.ShouldBe(amount);
-        result = await ElectionContractStub.GetElectorVoteWithRecords.CallAsync(new StringValue
-        {
-            Value = address.ToBase58()
-        });
-        result.ActiveVotedVotesAmount.ShouldBe(amount);
-        result = await ElectionContractStub.GetElectorVoteWithAllRecords.CallAsync(new StringValue
-        {
-            Value = address.ToBase58()
-        });
-        result.AllVotedVotesAmount.ShouldBe(amount);
-        
-        CheckBalance(address, "ELF", initBalance - amount);
-        CheckBalance(address, "SHARE", amount);
-        CheckBalance(address, "VOTE", amount);
-        
-        await VirtualAddressContractStub.VirtualAddressVote.SendAsync(new VirtualAddressVoteInput
-        {
-            PubKey = candidateKeyPair.PublicKey.ToHex(),
-            Amount = amount,
-            EndTimestamp = TimestampHelper.GetUtcNow().AddSeconds(lockTime),
-            Token = HashHelper.ComputeFrom("token A")
-        });
-        
-        result = await ElectionContractStub.GetElectorVote.CallAsync(new StringValue
-        {
-            Value = address.ToBase58()
-        });
-        result.ActiveVotedVotesAmount.ShouldBe(amount + amount);
-        result = await ElectionContractStub.GetElectorVoteWithRecords.CallAsync(new StringValue
-        {
-            Value = address.ToBase58()
-        });
-        result.ActiveVotedVotesAmount.ShouldBe(amount + amount);
-        result = await ElectionContractStub.GetElectorVoteWithAllRecords.CallAsync(new StringValue
-        {
-            Value = address.ToBase58()
-        });
-        result.AllVotedVotesAmount.ShouldBe(amount + amount);
-        
-        CheckBalance(address, "ELF", initBalance - amount - amount);
-        CheckBalance(address, "SHARE", amount + amount);
-        CheckBalance(address, "VOTE", amount + amount);
-        
-        return result.ActiveVotingRecords.First().VoteId;
-    }
-
     [Fact]
     public async Task VirtualAddress_Withdraw_Test()
     {
diff --git a/test/AElf.Contracts.TestContract.VirtualAddress/Action.cs b/test/AElf.Contracts.TestContract.VirtualAddress/Action.cs
index bc8edd7a81..295830ea1c 100644
--- a/test/AElf.Contracts.TestContract.VirtualAddress/Action.cs
+++ b/test/AElf.Contracts.TestContract.VirtualAddress/Action.cs
@@ -9,27 +9,6 @@ namespace AElf.Contracts.TestContract.VirtualAddress;
 
 public partial class Action : VirtualAddressContractContainer.VirtualAddressContractBase
 {
-    
-    public override Empty VirtualAddressVoteWithInline(VirtualAddressVoteWithCountInput input)
-    {
-        if (input.Count == null) return new Empty();
-        Initialize();
-
-        for (int i = 0; i < input.Count; i++)
-        {
-            Context.SendVirtualInline(HashHelper.ComputeFrom("test"), State.ElectionContract.Value, ".Vote", new VoteMinerInput
-            {
-                CandidatePubkey = input.VoteInput.PubKey,
-                Amount = input.VoteInput.Amount,
-                EndTimestamp = input.VoteInput.EndTimestamp,
-                Token = input.VoteInput.Token
-            }.ToByteString());
-        }
-        
-
-        return new Empty();
-    }
-    
     public override Empty VirtualAddressVote(VirtualAddressVoteInput input)
     {
         Initialize();
diff --git a/test/AElf.Kernel.Core.Tests/Extensions/TransactionExtensionsTests.cs b/test/AElf.Kernel.Core.Tests/Extensions/TransactionExtensionsTests.cs
index 2fe628cb1f..daa6331365 100644
--- a/test/AElf.Kernel.Core.Tests/Extensions/TransactionExtensionsTests.cs
+++ b/test/AElf.Kernel.Core.Tests/Extensions/TransactionExtensionsTests.cs
@@ -46,14 +46,4 @@ public void VerifyExpiration_Test()
         transaction.VerifyExpiration(100).ShouldBeTrue();
         transaction.VerifyExpiration(612).ShouldBeFalse();
     }
-    
-    [Fact]
-    public void IsInlineWithTransactionId_Test()
-    {
-        var transaction = _kernelTestHelper.GenerateTransaction(100);
-        transaction.MethodName = ".vote";
-        transaction.IsInlineWithTransactionId().ShouldBeTrue();
-        transaction.MethodName = "vote";
-        transaction.IsInlineWithTransactionId().ShouldBeFalse();
-    }
 }
\ No newline at end of file
diff --git a/test/AElf.Kernel.SmartContract.ExecutionPluginForMethodFee.Tests/Service/PlainTransactionExecutingAsPluginService.cs b/test/AElf.Kernel.SmartContract.ExecutionPluginForMethodFee.Tests/Service/PlainTransactionExecutingAsPluginService.cs
index cdda3f9e59..51d07eafe4 100644
--- a/test/AElf.Kernel.SmartContract.ExecutionPluginForMethodFee.Tests/Service/PlainTransactionExecutingAsPluginService.cs
+++ b/test/AElf.Kernel.SmartContract.ExecutionPluginForMethodFee.Tests/Service/PlainTransactionExecutingAsPluginService.cs
@@ -22,8 +22,8 @@ public class PlainTransactionExecutingAsPluginService : PlainTransactionExecutin
     public PlainTransactionExecutingAsPluginService
     (ISmartContractExecutiveService smartContractExecutiveService,
         IEnumerable<IPostExecutionPlugin> postPlugins, IEnumerable<IPreExecutionPlugin> prePlugins,
-        ITransactionContextFactory transactionContextFactory, IFeatureDisableService featureDisableService, IBlockchainService blockchainService) : base(
-        smartContractExecutiveService, postPlugins, prePlugins, transactionContextFactory, featureDisableService,blockchainService)
+        ITransactionContextFactory transactionContextFactory, IFeatureDisableService featureDisableService) : base(
+        smartContractExecutiveService, postPlugins, prePlugins, transactionContextFactory, featureDisableService)
     {
         _smartContractExecutiveService = smartContractExecutiveService;
     }