public async Task <IExchangeEntity> MapAsync(EventLog <NewExchangeEventDTO> eventLog)
        {
            var exchangeAddress = eventLog.Event.Exchange;
            var tokenAddress    = eventLog.Event.Token;
            var tokenInfo       = await _tokenInfoProvider.GetAsync(tokenAddress);

            var blockNumber    = (ulong)(BigInteger)eventLog.Log.BlockNumber;
            var tokenLiquidity = await _tokenLiquidityProvider.GetAsync(tokenAddress, exchangeAddress);

            var ethLiquidity = await _ethLiquidityProvider.GetAsync(exchangeAddress);

            var totalSupply = await _exchangeTotalSupplyProvider.GetAsync(exchangeAddress);

            var theme = await _exchangeThemeProvider.GetAsync(tokenInfo.Symbol);

            return(_exchangeEntityFactory.Create(exchangeAddress, tokenAddress, tokenInfo, blockNumber, ethLiquidity, tokenLiquidity, totalSupply, theme));
        }
예제 #2
0
        public async Task ProcessAsync(IEnumerable <IEventLog> events)
        {
            var groupedByExchangeEvents = events.GroupBy(x => x.Log.Address);

            foreach (var exchangeEvents in groupedByExchangeEvents)
            {
                var groupedAndOrderedByBlockNumberEvents =
                    exchangeEvents.GroupBy(x => x.Log.BlockNumber).OrderBy(x => x.Key.Value);

                foreach (var orderedBlockEvents in groupedAndOrderedByBlockNumberEvents)
                {
                    var previousBlockNumber = (ulong)orderedBlockEvents.Key.Value - 1;
                    var tokenAddress        = await _exchangeGatewayFactory(exchangeEvents.Key).GetTokenAddressAsync();

                    var exchangeState = new ExchangeState()
                    {
                        EthLiquidity = await _ethLiquidityProvider.GetAsync(exchangeEvents.Key,
                                                                            previousBlockNumber),
                        TokenLiquidity = await _tokenLiquidityProvider.GetAsync(tokenAddress,
                                                                                exchangeEvents.Key, previousBlockNumber)
                    };

                    foreach (var eventLog in orderedBlockEvents)
                    {
                        var entity = await _exchangeEventMapper.MapAsync(eventLog, exchangeState, tokenAddress);

                        exchangeState.Update(entity);

                        var totalSupply = await _exchangeTotalSupplyProvider.GetAsync(entity.ExchangeAddress);

                        await _exchangeRepository.Update(entity.ExchangeAddress, entity.EthLiquidityAfterEvent,
                                                         entity.TokenLiquidityAfterEvent, totalSupply);

                        await _exchangeEventsRepository.AddOrUpdateAsync(entity);

                        _logger.LogInformation("Event txHash {txHash} logIndex {logIndex} was processed",
                                               eventLog.Log.TransactionHash, eventLog.Log.LogIndex.Value);
                        _logger.LogInformation("Updated state: {state}", ObjectDumper.Dump(exchangeState));
                    }
                }
            }
        }