public async Task <long> GetUnacceptableDistanceToLastIrreversibleBlockHeightAsync(Hash blockHash)
        {
            PrepareBloomForIrreversibleBlockHeightUnacceptable();

            var block = await _blockchainService.GetBlockByHashAsync(blockHash);

            if (_bloomOfLibUnacceptable.IsIn(new Bloom(block.Header.Bloom.ToByteArray())))
            {
                foreach (var transactionId in block.Body.TransactionIds)
                {
                    var result = await _transactionResultQueryService.GetTransactionResultAsync(transactionId);

                    if (result == null)
                    {
                        Logger.LogTrace($"Transaction result is null, transactionId: {transactionId}");
                        continue;
                    }

                    if (result.Status == TransactionResultStatus.Failed)
                    {
                        Logger.LogTrace(
                            $"Transaction failed, transactionId: {transactionId}, error: {result.Error}");
                        continue;
                    }

                    if (result.Bloom.Length == 0 || !_bloomOfLibUnacceptable.IsIn(new Bloom(result.Bloom.ToByteArray())))
                    {
                        continue;
                    }

                    foreach (var log in result.Logs)
                    {
                        if (log.Address != _contractAddress || log.Name != _logEventOfLibUnacceptable.Name)
                        {
                            continue;
                        }

                        var message = new IrreversibleBlockHeightUnacceptable();
                        message.MergeFrom(log);
                        Logger.LogTrace(
                            $"IrreversibleBlockHeightUnacceptable detected: {message}");
                        return(message.DistanceToIrreversibleBlockHeight);
                    }
                }
            }

            return(0);
        }
Ejemplo n.º 2
0
        public async Task HandleAsync(Block block, TransactionResult transactionResult, LogEvent logEvent)
        {
            var distanceToLib = new IrreversibleBlockHeightUnacceptable();

            distanceToLib.MergeFrom(logEvent);

            if (distanceToLib.DistanceToIrreversibleBlockHeight > 0)
            {
                Logger.LogDebug($"Distance to lib height: {distanceToLib.DistanceToIrreversibleBlockHeight}");
                _transactionPackingService.DisableTransactionPacking();
            }
            else
            {
                _transactionPackingService.EnableTransactionPacking();
            }

            await Task.CompletedTask;
        }
Ejemplo n.º 3
0
        public async Task ProcessAsync(Block block, TransactionResult transactionResult, LogEvent logEvent)
        {
            var distanceToLib = new IrreversibleBlockHeightUnacceptable();

            distanceToLib.MergeFrom(logEvent);

            if (distanceToLib.DistanceToIrreversibleBlockHeight > 0)
            {
                Logger.LogDebug($"Distance to lib height: {distanceToLib.DistanceToIrreversibleBlockHeight}");
                _transactionPackingOptions.IsTransactionPackable = false;
            }
            else
            {
                _transactionPackingOptions.IsTransactionPackable = true;
            }

            await Task.CompletedTask;
        }
        protected override Task ProcessLogEventAsync(Block block, LogEvent logEvent)
        {
            var distanceToLib = new IrreversibleBlockHeightUnacceptable();

            distanceToLib.MergeFrom(logEvent);

            var blockIndex = new BlockIndex
            {
                BlockHash   = block.GetHash(),
                BlockHeight = block.Height
            };

            if (distanceToLib.DistanceToIrreversibleBlockHeight > 0)
            {
                Logger.LogDebug($"Distance to lib height: {distanceToLib.DistanceToIrreversibleBlockHeight}");
                _transactionPackingOptionProvider.SetTransactionPackingOptionAsync(blockIndex, false);
            }
            else
            {
                _transactionPackingOptionProvider.SetTransactionPackingOptionAsync(blockIndex, true);
            }

            return(Task.CompletedTask);
        }