public async Task Monitoring(TransactionMonitoringMessage message, QueueTriggeringContext context)
        {
            if (await _transactionService.IsTransactionExecuted(message.TxHash))
            {
                await _logger.WriteInfoAsync("TransferTransactionMonitoring", "Monitoring", message.ToJson(), "Transaction mined. Firing event.");

                if (message.Type == TransactionType.Cashin)
                {
                    var amount = BigInteger.Parse(message.Amount);

                    await _userContractRepository.DecreaseBalance(message.UserContract, amount);

                    await _issueNotifier.AddNotify(message.TxHash, message.UserContract, amount.FromBlockchainAmount(Constants.TimeCoinDecimals));

                    await _logger.WriteInfoAsync("TransferTransactionMonitoring", "Monitoring", $"{message.ToJson()}, tx: [{message.TxHash}]", "Cashin success");
                }

                if (message.Type == TransactionType.Cashout)
                {
                    await _logger.WriteInfoAsync("TransferTransactionMonitoring", "Monitoring", $"{message.ToJson()}, tx: [{message.TxHash}]", "Cashout success");
                }
            }
            else if ((DateTime.UtcNow - message.PutDateTime).TotalMinutes < _settings.TransactionExecutionTimeoutMinutes)
            {
                context.MoveMessageToEnd(message.ToJson());
                context.SetCountQueueBasedDelay(5000, 100);
            }
            else
            {
                context.MoveMessageToPoison();
                await _logger.WriteWarningAsync("TransferTransactionMonitoring", "Monitoring", message.ToJson(), "Transaction is failed");
            }
        }
        public async Task Monitor(TransactionMonitoringMessage message, QueueTriggeringContext context)
        {
            try
            {
                var response = await _qBitNinjaApiCaller.GetTransaction(message.TransactionHash);

                if (response?.Block?.Confirmations > 0)
                {
                    return;
                }
            }
            catch (QBitNinjaException ex)
            {
                if (ex.Message != message.LastError)
                {
                    await _logger.WriteWarningAsync("BroadcastMonitoringFunction", "Monitor",
                                                    $"TransactionHash: {message.TransactionHash}", $"Message: {ex.Message} StatusCode:{ex.StatusCode}");
                }
                message.LastError = ex.Message;
            }
            if (DateTime.UtcNow - message.PutDateTime > TimeSpan.FromSeconds(_settings.BroadcastMonitoringPeriodSeconds))
            {
                context.MoveMessageToPoison(message.ToJson());
            }
            else
            {
                context.MoveMessageToEnd(message.ToJson());
                context.SetCountQueueBasedDelay(10000, 100);
            }
        }