public VersionPayload(byte[] buffer, int offset)
            : base(buffer, offset)
        {
            Contract.Requires<ArgumentNullException>(buffer != null, "buffer");
            Contract.Requires<ArgumentException>(buffer.Length >= VersionPayload.MinimumByteSize, "buffer");
            Contract.Requires<ArgumentOutOfRangeException>(offset >= 0, "offset");
            Contract.Requires<ArgumentOutOfRangeException>(offset <= buffer.Length - VersionPayload.MinimumByteSize, "offset");

            Version = buffer.ReadUInt32(offset);
            Services = (Services)buffer.ReadUInt64(offset + SERVICES_OFFSET);
            Timestamp = buffer.ReadUInt64(offset + TIMESTAMP_OFFSET);
            EmittingAddress = new NetworkAddress(buffer, offset + EMIT_ADDRESS_OFFSET);
            if (Version >= 106)
            {
                ReceivingAddress = new NetworkAddress(buffer, offset + RECV_ADDRESS_OFFSET);
                Nonce = buffer.ReadUInt64(offset + NONCE_OFFSET);
                SubVersionNum = new VarString(buffer, offset + SUBVER_OFFSET);
            }
            else
            {
                ReceivingAddress = NetworkAddress.IPv6Any;
            }
            if (Version >= 209)
            {
                StartHeight = buffer.ReadUInt32(offset + STARTHEIGHT_OFFSET);
            }

            ByteSize = CalculateByteSize();
        }
        public TimestampedNetworkAddress(NetworkAddress address, uint timestamp)
        {
            Contract.Requires<ArgumentNullException>(address != null, "address");

            Timestamp = timestamp;
            Address = address;

            ByteSize = (uint)TimestampedNetworkAddress.ConstantByteSize;
        }
        public TimestampedNetworkAddress(byte[] buffer, int offset)
            : base(buffer, offset)
        {
            Contract.Requires<ArgumentNullException>(buffer != null, "buffer");
            Contract.Requires<ArgumentException>(buffer.Length >= TimestampedNetworkAddress.ConstantByteSize, "buffer");
            Contract.Requires<ArgumentOutOfRangeException>(offset >= 0, "offset");
            Contract.Requires<ArgumentOutOfRangeException>(offset <= buffer.Length - TimestampedNetworkAddress.ConstantByteSize, "offset");

            Timestamp = buffer.ReadUInt32(offset);
            Address = new NetworkAddress(buffer, offset + NETADDR_OFFSET);

            ByteSize = (uint)TimestampedNetworkAddress.ConstantByteSize;
        }
        public VersionPayload(uint version, Services services, ulong timestamp, NetworkAddress emittingAddress,
            NetworkAddress receivingAddress, ulong nonce, VarString subVersionNum, uint startHeight)
        {
            Contract.Requires<ArgumentNullException>(emittingAddress != null);
            Contract.Requires<ArgumentNullException>(receivingAddress != null);

            Version = version;
            Services = services;
            Timestamp = timestamp;
            EmittingAddress = emittingAddress;
            ReceivingAddress = receivingAddress;
            Nonce = nonce;
            SubVersionNum = subVersionNum;
            StartHeight = startHeight;

            ByteSize = CalculateByteSize();
        }