public override void HandleMessage(ZeroPacket message)
        {
            int size = message.Content.ReadableBytes;

            switch (message.PacketType)
            {
            case SnapMessageCode.GetAccountRange:
                GetAccountRangeMessage getAccountRangeMessage = Deserialize <GetAccountRangeMessage>(message.Content);
                ReportIn(getAccountRangeMessage);
                Handle(getAccountRangeMessage);
                break;

            case SnapMessageCode.AccountRange:
                AccountRangeMessage accountRangeMessage = Deserialize <AccountRangeMessage>(message.Content);
                ReportIn(accountRangeMessage);
                Handle(accountRangeMessage, size);
                break;

            case SnapMessageCode.GetStorageRanges:
                GetStorageRangeMessage getStorageRangesMessage = Deserialize <GetStorageRangeMessage>(message.Content);
                ReportIn(getStorageRangesMessage);
                Handle(getStorageRangesMessage);
                break;

            case SnapMessageCode.StorageRanges:
                StorageRangeMessage storageRangesMessage = Deserialize <StorageRangeMessage>(message.Content);
                ReportIn(storageRangesMessage);
                Handle(storageRangesMessage, size);
                break;

            case SnapMessageCode.GetByteCodes:
                GetByteCodesMessage getByteCodesMessage = Deserialize <GetByteCodesMessage>(message.Content);
                ReportIn(getByteCodesMessage);
                Handle(getByteCodesMessage);
                break;

            case SnapMessageCode.ByteCodes:
                ByteCodesMessage byteCodesMessage = Deserialize <ByteCodesMessage>(message.Content);
                ReportIn(byteCodesMessage);
                Handle(byteCodesMessage, size);
                break;

            case SnapMessageCode.GetTrieNodes:
                GetTrieNodesMessage getTrieNodesMessage = Deserialize <GetTrieNodesMessage>(message.Content);
                ReportIn(getTrieNodesMessage);
                Handle(getTrieNodesMessage);
                break;

            case SnapMessageCode.TrieNodes:
                TrieNodesMessage trieNodesMessage = Deserialize <TrieNodesMessage>(message.Content);
                ReportIn(trieNodesMessage);
                Handle(trieNodesMessage, size);
                break;
            }
        }
        public async Task <SlotsAndProofs> GetStorageRange(StorageRange range, CancellationToken token)
        {
            var request = new GetStorageRangeMessage()
            {
                StoragetRange = range,
                ResponseBytes = BYTES_LIMIT
            };

            StorageRangeMessage response = await SendRequest(request, _getStorageRangeRequests, token);

            Metrics.SnapGetStorageRangesSent++;

            return(new SlotsAndProofs()
            {
                PathsAndSlots = response.Slots, Proofs = response.Proofs
            });
        }
 private void Handle(StorageRangeMessage msg, long size)
 {
     Metrics.SnapStorageRangesReceived++;
     _getStorageRangeRequests.Handle(msg, size);
 }