Esempio n. 1
0
        public async Task HandleEventAsync(ConflictingTransactionsFoundInParallelGroupsEvent eventData)
        {
            var chainContext = new ChainContext
            {
                BlockHash   = eventData.BlockHeader.PreviousBlockHash,
                BlockHeight = eventData.BlockHeader.Height - 1
            };
            var wrongTxWithResources = await _conflictingTransactionIdentificationService.IdentifyConflictingTransactionsAsync(
                chainContext, eventData.ExistingSets, eventData.ConflictingSets);

            var wrongTransactionIds = wrongTxWithResources.Select(t => t.Transaction.GetHash()).ToArray();

            var dic = wrongTxWithResources.GroupBy(t => t.Transaction.To)
                      .ToDictionary(g => g.Key, g => new NonparallelContractCode
            {
                CodeHash = g.First().TransactionResourceInfo.ContractHash
            });

            await _nonparallelContractCodeProvider.SetNonparallelContractCodeAsync(new BlockIndex
            {
                BlockHash   = eventData.BlockHeader.GetHash(),
                BlockHeight = eventData.BlockHeader.Height
            }, dic);

            _resourceExtractionService.ClearConflictingTransactionsResourceCache(wrongTransactionIds);
        }
Esempio n. 2
0
        public async Task HandleEventAsync(ConflictingTransactionsFoundInParallelGroupsEvent eventData)
        {
            var chainContext = new ChainContext
            {
                BlockHash   = eventData.PreviousBlockHash,
                BlockHeight = eventData.PreviousBlockHeight
            };
            var wrong = await _conflictingTransactionIdentificationService.IdentifyConflictingTransactionsAsync(
                chainContext, eventData.ExistingSets, eventData.ConflictingSets);

            _resourceExtractionService.ClearConflictingTransactionsResourceCache(wrong.Select(t => t.GetHash()));
            var wrongTransactionAddresses = wrong.Select(t => t.To).Distinct();

            foreach (var address in wrongTransactionAddresses)
            {
                await _codeRemarksService.MarkUnparallelizableAsync(chainContext, address);
            }
        }
Esempio n. 3
0
        public async Task HandleEventAsync(ConflictingTransactionsFoundInParallelGroupsEvent eventData)
        {
            var chainContext = new ChainContext
            {
                BlockHash   = eventData.BlockHeader.PreviousBlockHash,
                BlockHeight = eventData.BlockHeader.Height - 1
            };
            var wrongTxWithResources = await _conflictingTransactionIdentificationService.IdentifyConflictingTransactionsAsync(
                chainContext, eventData.ExistingSets, eventData.ConflictingSets);

            var wrongTransactionIds = wrongTxWithResources.Select(t => t.Transaction.GetHash()).ToArray();

            var wrongAddressAndCodeHashMap = wrongTxWithResources.GroupBy(t => t.Transaction.To)
                                             .ToDictionary(g => g.Key, g => g.First().TransactionResourceInfo.ContractHash);
            var wrongAddresses = wrongAddressAndCodeHashMap.Keys;

            foreach (var address in wrongAddresses)
            {
                await _contractRemarksService.SetCodeRemarkAsync(address, wrongAddressAndCodeHashMap[address],
                                                                 eventData.BlockHeader);
            }

            _resourceExtractionService.ClearConflictingTransactionsResourceCache(wrongTransactionIds);
        }