public async Task HandleAsync(string walletAddress)
        {
            var walletOwnerResponse = await _walletOwnersRepository.GetByWalletAddressAsync(walletAddress);

            if (walletOwnerResponse == null)
            {
                _log.Error(message: "Wallet Owner not found for staked operation", context: walletAddress);
                return;
            }

            await _balanceService.ForceBalanceUpdateAsync(walletOwnerResponse.OwnerId, OperationType.StakeOperation, Guid.Empty);
        }
        public async Task HandleAsync(
            string sourceAddress,
            string targetAddress,
            Money18 amount,
            string transactionHash,
            DateTime observedAt)
        {
            #region Validation

            if (string.IsNullOrEmpty(sourceAddress))
            {
                _log.Warning("Source address is empty");
                return;
            }

            if (string.IsNullOrEmpty(targetAddress))
            {
                _log.Warning("Target address is empty");
                return;
            }

            if (sourceAddress.Equals(EmptyWalletAddress) || targetAddress.Equals(EmptyWalletAddress))
            {
                return;
            }

            if (amount <= 0)
            {
                _log.Warning("Amount is less or equal 0");
                return;
            }

            if (string.IsNullOrEmpty(transactionHash))
            {
                _log.Warning("Transaction hash is empty");
                return;
            }

            #endregion

            #region Find operation

            var operation = await _operationsFetcher.GetByHashAsync(transactionHash);

            if (operation == null)
            {
                var transactionState = await _executorClient.TransactionsApi.GetTransactionStateAsync(transactionHash);

                if (transactionState.Error != GetTransactionStateError.None)
                {
                    _log.Error(message: "Already processed operation was not found by hash",
                               context: new { transactionHash, sourceAddress, targetAddress });
                    return;
                }

                if (!transactionState.OperationId.HasValue)
                {
                    _log.Warning("Operation id is empty",
                                 context: new { transactionHash, sourceAddress, targetAddress });
                    return;
                }

                operation = await _operationsFetcher.GetByIdAsync(transactionState.OperationId.Value);

                if (operation == null)
                {
                    _log.Error(message: "Already processed operation was not found by id",
                               context: new
                    {
                        id = transactionState.OperationId.Value, transactionHash, sourceAddress, targetAddress
                    });
                    return;
                }
            }

            #endregion

            var tasksForBalanceUpdate = new List <Task>();

            var sourceWalletOwner = await _walletOwnersRepository.GetByWalletAddressAsync(sourceAddress);

            if (sourceWalletOwner == null)
            {
                _log.Info("Transfer with unknown source wallet owner", context: sourceAddress);
            }
            else
            {
                tasksForBalanceUpdate.Add(_balanceService.ForceBalanceUpdateAsync(sourceWalletOwner.OwnerId, operation.Type, operation.Id));
            }

            var targetWalletOwner = await _walletOwnersRepository.GetByWalletAddressAsync(targetAddress);

            if (targetWalletOwner == null)
            {
                _log.Info("Transfer with unknown target wallet owner", context: targetAddress);
            }
            else
            {
                tasksForBalanceUpdate.Add(_balanceService.ForceBalanceUpdateAsync(targetWalletOwner.OwnerId, operation.Type, operation.Id));
            }

            await Task.WhenAll(tasksForBalanceUpdate);

            var context = JsonConvert.DeserializeObject <TokensTransferContext>(operation.ContextJson);

            //If there is not customer behind one of the wallets then this is not P2P transfer
            if (sourceWalletOwner != null && targetWalletOwner != null)
            {
                await _p2PTransferPublisher.PublishAsync(new P2PTransferDetectedEvent
                {
                    TransactionHash    = transactionHash,
                    SenderCustomerId   = sourceWalletOwner.OwnerId,
                    ReceiverCustomerId = targetWalletOwner.OwnerId,
                    Amount             = amount,
                    Timestamp          = observedAt,
                    RequestId          = context.RequestId
                });
            }

            await _transferDetectedPublisher.PublishAsync(new TransferDetectedEvent
            {
                TransactionHash    = transactionHash,
                SenderCustomerId   = sourceWalletOwner?.OwnerId,
                ReceiverCustomerId = targetWalletOwner?.OwnerId,
                Amount             = amount,
                Timestamp          = observedAt,
                RequestId          = context.RequestId
            });
        }
        public async Task HandleAsync(string transactionHash, Money18 amount, string walletAddress, DateTime observedAt)
        {
            if (string.IsNullOrEmpty(transactionHash))
            {
                _log.Warning("Mint event with empty hash received");
                return;
            }

            if (amount <= 0)
            {
                _log.Warning("Invalid amount for handling MintEvent",
                             context: new { amount, hash = transactionHash });
                return;
            }

            var walletOwner = await _walletOwnersRepository.GetByWalletAddressAsync(walletAddress);

            if (walletOwner == null)
            {
                _log.Error(message: "Mint event for wallet address which does not exist", context: walletAddress);
                return;
            }

            var operation = await _operationsFetcher.GetByHashAsync(transactionHash);

            if (operation == null)
            {
                var transactionState = await _executorClient.TransactionsApi.GetTransactionStateAsync(transactionHash);

                if (transactionState.Error != GetTransactionStateError.None)
                {
                    _log.Error(message: "Already processed operation was not found by hash",
                               context: new { hash = transactionHash, walletOwner, walletAddress });
                    return;
                }

                if (!transactionState.OperationId.HasValue)
                {
                    _log.Warning("Operation id is empty", context: new { hash = transactionHash, amount, walletAddress });
                    return;
                }

                operation = await _operationsFetcher.GetByIdAsync(transactionState.OperationId.Value);

                if (operation == null)
                {
                    _log.Error(message: "Already processed operation was not found by id",
                               context: new { id = transactionState.OperationId.Value, transactionHash, walletOwner, walletAddress });
                    return;
                }
            }

            await _balanceService.ForceBalanceUpdateAsync(walletOwner.OwnerId, operation.Type, operation.Id);

            var bonusRewardContext = JsonConvert.DeserializeObject <CustomerBonusRewardContext>(operation.ContextJson);

            await _bonusRewardDetectedPublisher.PublishAsync(new BonusRewardDetectedEvent
            {
                Amount      = amount,
                Timestamp   = observedAt,
                CustomerId  = walletOwner.OwnerId,
                RequestId   = bonusRewardContext.RequestId,
                BonusReason = bonusRewardContext.BonusReason,
                CampaignId  = bonusRewardContext.CampaignId,
                ConditionId = bonusRewardContext.ConditionId
            });
        }