public override void HandleMessage(ZeroPacket message)
        {
            base.HandleMessage(message);
            switch (message.PacketType)
            {
            case Eth65MessageCode.PooledTransactions:
                PooledTransactionsMessage pooledTxMsg
                    = Deserialize <PooledTransactionsMessage>(message.Content);
                Metrics.Eth65PooledTransactionsReceived++;
                ReportIn(pooledTxMsg);
                Handle(pooledTxMsg);
                break;

            case Eth65MessageCode.GetPooledTransactions:
                GetPooledTransactionsMessage getPooledTxMsg
                    = Deserialize <GetPooledTransactionsMessage>(message.Content);
                ReportIn(getPooledTxMsg);
                Handle(getPooledTxMsg);
                break;

            case Eth65MessageCode.NewPooledTransactionHashes:
                NewPooledTransactionHashesMessage newPooledTxMsg =
                    Deserialize <NewPooledTransactionHashesMessage>(message.Content);
                ReportIn(newPooledTxMsg);
                Handle(newPooledTxMsg);
                break;
            }
        }
Esempio n. 2
0
        private void Handle(NewPooledTransactionHashesMessage msg)
        {
            Metrics.Eth65NewPooledTransactionHashesReceived++;
            Stopwatch     stopwatch          = Stopwatch.StartNew();
            List <Keccak> discoveredTxHashes = new();

            for (int i = 0; i < msg.Hashes.Count; i++)
            {
                Keccak hash = msg.Hashes[i];
                if (!_txPool.IsInHashCache(hash))
                {
                    if (_txPool.TryAddToPendingHashes(hash))
                    {
                        discoveredTxHashes.Add(hash);
                    }
                }
            }

            int discoveredTxHashesCount = discoveredTxHashes.Count;

            if (discoveredTxHashesCount != 0)
            {
                Send(new GetPooledTransactionsMessage(discoveredTxHashes.ToArray()));
                Metrics.Eth65GetPooledTransactionsRequested++;
            }
            stopwatch.Stop();
            if (Logger.IsTrace)
            {
                Logger.Trace($"OUT {Counter:D5} {nameof(NewPooledTransactionHashesMessage)} to {Node:c} " +
                             $"in {stopwatch.Elapsed.TotalMilliseconds}ms");
            }
        }
Esempio n. 3
0
 public override void SendNewTransaction(Transaction transaction, bool isPriority)
 {
     if (isPriority)
     {
         base.SendNewTransaction(transaction, true);
     }
     else
     {
         Counter++;
         NewPooledTransactionHashesMessage msg = new NewPooledTransactionHashesMessage(new[] { transaction.Hash });
         Send(msg);
     }
 }
        protected virtual void Handle(NewPooledTransactionHashesMessage msg)
        {
            Metrics.Eth65NewPooledTransactionHashesReceived++;
            Stopwatch stopwatch = Stopwatch.StartNew();

            _pooledTxsRequestor.RequestTransactions(Send, msg.Hashes.ToArray());

            stopwatch.Stop();
            if (Logger.IsTrace)
            {
                Logger.Trace($"OUT {Counter:D5} {nameof(NewPooledTransactionHashesMessage)} to {Node:c} " +
                             $"in {stopwatch.Elapsed.TotalMilliseconds}ms");
            }
        }