BitSharp.Network.NetworkEncoder.DecodeVersionPayload C# (CSharp) 메소드

        public static VersionPayload DecodeVersionPayload(BinaryReader reader, int payloadLength)
        {
            var position = reader.BaseStream.Position;

            var versionPayload = new VersionPayload
            (
                ProtocolVersion: reader.ReadUInt32(),
                ServicesBitfield: reader.ReadUInt64(),
                Time: DateTimeOffset.FromUnixTimeSeconds((long)reader.ReadUInt64()),
                RemoteAddress: DecodeNetworkAddress(reader),
                LocalAddress: DecodeNetworkAddress(reader),
                Nonce: reader.ReadUInt64(),
                UserAgent: reader.ReadVarString(),
                StartBlockHeight: reader.ReadUInt32(),
                Relay: false
            );

            var readCount = reader.BaseStream.Position - position;
            if (versionPayload.ProtocolVersion >= VersionPayload.RELAY_VERSION && payloadLength - readCount == 1)
                versionPayload = versionPayload.With(Relay: reader.ReadBool());

            return versionPayload;
        }

        private async Task <Message> WireDecodeMessage(UInt32 magic)
        {
            var command         = DataDecoder.DecodeFixedString(await ReceiveExactly(12));
            var payloadSize     = DataDecoder.DecodeUInt32(await ReceiveExactly(4));
            var payloadChecksum = DataDecoder.DecodeUInt32(await ReceiveExactly(4));
            var payload         = await ReceiveExactly(payloadSize.ToIntChecked());

            if (!Messaging.VerifyPayloadChecksum(payloadChecksum, payload))
            {
                throw new Exception($"Checksum failed for {command}");
            }

            var message = new Message
                          (
                Magic: magic,
                Command: command,
                PayloadSize: payloadSize,
                PayloadChecksum: payloadChecksum,
                Payload: payload.ToImmutableArray()
                          );

            switch (message.Command)
            {
            case "addr":
            {
                var addressPayload = NetworkEncoder.DecodeAddressPayload(payload);

                OnReceivedAddresses?.Invoke(owner, addressPayload.NetworkAddresses);
            }
            break;

            case "alert":
            {
                var alertPayload = NetworkEncoder.DecodeAlertPayload(payload);
            }
            break;

            case "block":
            {
                var block = DataDecoder.DecodeBlock(null, payload);

                OnBlock?.Invoke(owner, block);
            }
            break;

            case "getblocks":
            {
                var getBlocksPayload = NetworkEncoder.DecodeGetBlocksPayload(payload);

                OnGetBlocks?.Invoke(owner, getBlocksPayload);
            }
            break;

            case "getheaders":
            {
                var getHeadersPayload = NetworkEncoder.DecodeGetBlocksPayload(payload);

                OnGetHeaders?.Invoke(owner, getHeadersPayload);
            }
            break;

            case "getdata":
            {
                var invPayload = NetworkEncoder.DecodeInventoryPayload(payload);

                OnGetData?.Invoke(owner, invPayload);
            }
            break;

            case "headers":
            {
                var blockHeaders = ImmutableList.CreateBuilder <BlockHeader>();

                var offset      = 0;
                var headerCount = payload.ReadVarInt(ref offset).ToIntChecked();

                for (var i = 0; i < headerCount; i++)
                {
                    var blockHeader = DataDecoder.DecodeBlockHeader(null, payload, ref offset);
                    // ignore tx count var int
                    payload.ReadVarInt(ref offset);

                    blockHeaders.Add(blockHeader);
                }

                OnBlockHeaders?.Invoke(owner, blockHeaders.ToImmutable());
            }
            break;

            case "inv":
            {
                var invPayload = NetworkEncoder.DecodeInventoryPayload(payload);

                OnInventoryVectors?.Invoke(owner, invPayload.InventoryVectors);
            }
            break;

            case "notfound":
            {
                var invPayload = NetworkEncoder.DecodeInventoryPayload(payload);

                OnNotFound?.Invoke(owner, invPayload.InventoryVectors);
            }
            break;

            case "ping":
            {
                OnPing?.Invoke(owner, payload.ToImmutableArray());
            }
            break;

            case "tx":
            {
                var tx = DataDecoder.DecodeEncodedTx(null, payload);

                OnTransaction?.Invoke(owner, tx);
            }
            break;

            case "version":
            {
                var versionPayload = NetworkEncoder.DecodeVersionPayload(payload, payload.Length);

                OnVersion?.Invoke(owner, versionPayload);
            }
            break;

            case "verack":
            {
                OnVersionAcknowledged?.Invoke(owner);
            }
            break;

            default:
            {
                logger.Warn($"Unhandled incoming message: {message.Command}");
            }
            break;
            }

            //TODO
            //if (payloadStream.Position != payloadStream.Length)
            //{
            //    var exMessage = $"Wrong number of bytes read for {message.Command}, parser error: read {payloadStream.Position} bytes from a {payloadStream.Length} byte payload";
            //    Debug.WriteLine(exMessage);
            //    throw new Exception(exMessage);
            //}

            return(message);
        }