package wire

import (
	"net"
	"reflect"
	"strings"
	"testing"
	
	"github.com/davecgh/go-spew/spew"
)

// TestVersion tests the MsgVersion API.
func TestVersion(t *testing.T) {
	pver := ProtocolVersion
	// Create version message data.
	lastBlock := int32(234234)
	tcpAddrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 11047}
	me := NewNetAddress(tcpAddrMe, SFNodeNetwork)
	tcpAddrYou := &net.TCPAddr{IP: net.ParseIP("192.168.0.1"), Port: 11047}
	you := NewNetAddress(tcpAddrYou, SFNodeNetwork)
	nonce, e := RandomUint64()
	if e != nil {
		t.Errorf("RandomUint64: error generating nonce: %v", e)
	}
	// Ensure we get the correct data back out.
	msg := NewMsgVersion(me, you, nonce, lastBlock)
	if msg.ProtocolVersion != int32(pver) {
		t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
			msg.ProtocolVersion, pver,
		)
	}
	if !reflect.DeepEqual(&msg.AddrMe, me) {
		t.Errorf("NewMsgVersion: wrong me address - got %v, want %v",
			spew.Sdump(&msg.AddrMe), spew.Sdump(me),
		)
	}
	if !reflect.DeepEqual(&msg.AddrYou, you) {
		t.Errorf("NewMsgVersion: wrong you address - got %v, want %v",
			spew.Sdump(&msg.AddrYou), spew.Sdump(you),
		)
	}
	if msg.Nonce != nonce {
		t.Errorf("NewMsgVersion: wrong nonce - got %v, want %v",
			msg.Nonce, nonce,
		)
	}
	if msg.UserAgent != DefaultUserAgent {
		t.Errorf("NewMsgVersion: wrong user agent - got %v, want %v",
			msg.UserAgent, DefaultUserAgent,
		)
	}
	if msg.LastBlock != lastBlock {
		t.Errorf("NewMsgVersion: wrong last block - got %v, want %v",
			msg.LastBlock, lastBlock,
		)
	}
	if msg.DisableRelayTx {
		t.Errorf("NewMsgVersion: disable relay tx is not false by "+
			"default - got %v, want %v", msg.DisableRelayTx, false,
		)
	}
	e = msg.AddUserAgent("myclient", "1.2.3", "optional", "comments")
	if e != nil {
		t.Log(e)
	}
	customUserAgent := DefaultUserAgent + "myclient:1.2.3(optional; comments)/"
	if msg.UserAgent != customUserAgent {
		t.Errorf("AddUserAgent: wrong user agent - got %s, want %s",
			msg.UserAgent, customUserAgent,
		)
	}
	e = msg.AddUserAgent("mygui", "3.4.5")
	if e != nil {
		t.Log(e)
	}
	customUserAgent += "mygui:3.4.5/"
	if msg.UserAgent != customUserAgent {
		t.Errorf("AddUserAgent: wrong user agent - got %s, want %s",
			msg.UserAgent, customUserAgent,
		)
	}
	// accounting for ":", "/"
	e = msg.AddUserAgent(strings.Repeat("t",
		MaxUserAgentLen-len(customUserAgent)-2+1,
	), "",
	)
	if _, ok := e.(*MessageError); !ok {
		t.Errorf("AddUserAgent: expected error not received "+
			"- got %v, want %T", e, MessageError{},
		)
	}
	// Version message should not have any services set by default.
	if msg.Services != 0 {
		t.Errorf("NewMsgVersion: wrong default services - got %v, want %v",
			msg.Services, 0,
		)
	}
	if msg.HasService(SFNodeNetwork) {
		t.Errorf("HasService: SFNodeNetwork service is set")
	}
	// Ensure the command is expected value.
	wantCmd := "version"
	if cmd := msg.Command(); cmd != wantCmd {
		t.Errorf("NewMsgVersion: wrong command - got %v want %v",
			cmd, wantCmd,
		)
	}
	// Ensure max payload is expected value. Protocol version 4 bytes + services 8 bytes + timestamp 8 bytes + remote
	// and local net addresses + nonce 8 bytes + length of user agent (varInt) + max allowed user agent length + last
	// block 4 bytes + relay transactions flag 1 byte.
	wantPayload := uint32(358)
	maxPayload := msg.MaxPayloadLength(pver)
	if maxPayload != wantPayload {
		t.Errorf("MaxPayloadLength: wrong max payload length for "+
			"protocol version %d - got %v, want %v", pver,
			maxPayload, wantPayload,
		)
	}
	// Ensure adding the full service node flag works.
	msg.AddService(SFNodeNetwork)
	if msg.Services != SFNodeNetwork {
		t.Errorf("AddService: wrong services - got %v, want %v",
			msg.Services, SFNodeNetwork,
		)
	}
	if !msg.HasService(SFNodeNetwork) {
		t.Errorf("HasService: SFNodeNetwork service not set")
	}
}

// // TestVersionWire tests the MsgVersion wire encode and decode for various protocol versions.
// func TestVersionWire(// 	t *testing.T) {
// 	// verRelayTxFalse and verRelayTxFalseEncoded is a version message as of BIP0037Version with the transaction relay disabled.
// 	baseVersionBIP0037Copy := *baseVersionBIP0037
// 	verRelayTxFalse := &baseVersionBIP0037Copy
// 	verRelayTxFalse.DisableRelayTx = true
// 	verRelayTxFalseEncoded := make([]byte, len(baseVersionBIP0037Encoded))
// 	copy(verRelayTxFalseEncoded, baseVersionBIP0037Encoded)
// 	verRelayTxFalseEncoded[len(verRelayTxFalseEncoded)-1] = 0
// 	tests := []struct {
// 		in   *MsgVersion     // Message to encode
// 		out  *MsgVersion     // Expected decoded message
// 		buf  []byte          // Wire encoding
// 		pver uint32          // Protocol version for wire encoding
// 		enc  MessageEncoding // Message encoding format
// 	}{
// 		// Latest protocol version.
// 		{
// 			baseVersionBIP0037,
// 			baseVersionBIP0037,
// 			baseVersionBIP0037Encoded,
// 			ProtocolVersion,
// 			BaseEncoding,
// 		},
// 		// Protocol version BIP0037Version with relay transactions field true.
// 		{
// 			baseVersionBIP0037,
// 			baseVersionBIP0037,
// 			baseVersionBIP0037Encoded,
// 			BIP0037Version,
// 			BaseEncoding,
// 		},
// 		// Protocol version BIP0037Version with relay transactions field false.
// 		{
// 			verRelayTxFalse,
// 			verRelayTxFalse,
// 			verRelayTxFalseEncoded,
// 			BIP0037Version,
// 			BaseEncoding,
// 		},
// 		// Protocol version BIP0035Version.
// 		{
// 			baseVersion,
// 			baseVersion,
// 			baseVersionEncoded,
// 			BIP0035Version,
// 			BaseEncoding,
// 		},
// 		// Protocol version BIP0031Version.
// 		{
// 			baseVersion,
// 			baseVersion,
// 			baseVersionEncoded,
// 			BIP0031Version,
// 			BaseEncoding,
// 		},
// 		// Protocol version NetAddressTimeVersion.
// 		{
// 			baseVersion,
// 			baseVersion,
// 			baseVersionEncoded,
// 			NetAddressTimeVersion,
// 			BaseEncoding,
// 		},
// 		// Protocol version MultipleAddressVersion.
// 		{
// 			baseVersion,
// 			baseVersion,
// 			baseVersionEncoded,
// 			MultipleAddressVersion,
// 			BaseEncoding,
// 		},
// 	}
// 	t.Logf("Running %d tests", len(tests))
// 	for i, test := range tests {
// 		// Encode the message to wire format.
// 		var buf bytes.Buffer
// 		e := test.in.BtcEncode(&buf, test.pver, test.enc)
// 		if e != nil  {
// 			t.Errorf("BtcEncode #%d error %v", i, err)
// 			continue
// 		}
// 		if !bytes.Equal(buf.Hash(), test.buf) {
// 			t.Errorf("BtcEncode #%d\n got: %s want: %s", i,
// 				spew.Sdump(buf.Hash()), spew.Sdump(test.buf))
// 			continue
// 		}
// 		// Decode the message from wire format.
// 		var msg MsgVersion
// 		rbuf := bytes.NewBuffer(test.buf)
// 		e = msg.BtcDecode(rbuf, test.pver, test.enc)
// 		if e != nil  {
// 			t.Errorf("BtcDecode #%d error %v", i, err)
// 			continue
// 		}
// 		if !reflect.DeepEqual(&msg, test.out) {
// 			t.Errorf("BtcDecode #%d\n got: %s want: %s", i,
// 				spew.Sdump(msg), spew.Sdump(test.out))
// 			continue
// 		}
// 	}
// }

// // TestVersionWireErrors performs negative tests against wire encode and decode of MsgGetHeaders to confirm error paths work correctly.
// func TestVersionWireErrors(// 	t *testing.T) {
// 	// Use protocol version 60002 specifically here instead of the latest because the test data is using bytes encoded with that protocol version.
// 	pver := uint32(60002)
// 	enc := BaseEncoding
// 	wireErr := &MessageError{}
// 	// Ensure calling MsgVersion.BtcDecode with a non *bytes.Buffer returns error.
// 	fr := newFixedReader(0, []byte{})
// 	if e := baseVersion.BtcDecode(fr, pver, enc); e ==  nil {
// 		t.Errorf("Did not received error when calling " +
// 			"MsgVersion.BtcDecode with non *bytes.Buffer")
// 	}
// 	// Copy the base version and change the user agent to exceed max limits.
// 	bvc := *baseVersion
// 	exceedUAVer := &bvc
// 	newUA := "/" + strings.Repeat("t", MaxUserAgentLen-8+1) + ":0.0.1/"
// 	exceedUAVer.UserAgent = newUA
// 	// Encode the new UA length as a varint.
// 	var newUAVarIntBuf bytes.Buffer
// 	e := WriteVarInt(&newUAVarIntBuf, pver, uint64(len(newUA)))
// 	if e != nil  {
// 		t.Errorf("WriteVarInt: error %v", err)
// 	}
// 	// Make a new buffer big enough to hold the base version plus the new bytes for the bigger varint to hold the new size of the user agent and the new user agent string.  Then stich it all together.
// 	newLen := len(baseVersionEncoded) - len(baseVersion.UserAgent)
// 	newLen = newLen + len(newUAVarIntBuf.Hash()) - 1 + len(newUA)
// 	exceedUAVerEncoded := make([]byte, newLen)
// 	copy(exceedUAVerEncoded, baseVersionEncoded[0:80])
// 	copy(exceedUAVerEncoded[80:], newUAVarIntBuf.Hash())
// 	copy(exceedUAVerEncoded[83:], []byte(newUA))
// 	copy(exceedUAVerEncoded[83+len(newUA):], baseVersionEncoded[97:100])
// 	tests := []struct {
// 		in       *MsgVersion     // value to encode
// 		buf      []byte          // Wire encoding
// 		pver     uint32          // Protocol version for wire encoding
// 		enc      MessageEncoding // Message encoding format
// 		max      int             // Max size of fixed buffer to induce errors
// 		writeErr error           // Expected write error
// 		readErr  error           // Expected read error
// 	}{
// 		// Force error in protocol version.
// 		{baseVersion, baseVersionEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// 		// Force error in services.
// 		{baseVersion, baseVersionEncoded, pver, BaseEncoding, 4, io.ErrShortWrite, io.EOF},
// 		// Force error in timestamp.
// 		{baseVersion, baseVersionEncoded, pver, BaseEncoding, 12, io.ErrShortWrite, io.EOF},
// 		// Force error in remote address.
// 		{baseVersion, baseVersionEncoded, pver, BaseEncoding, 20, io.ErrShortWrite, io.EOF},
// 		// Force error in local address.
// 		{baseVersion, baseVersionEncoded, pver, BaseEncoding, 47, io.ErrShortWrite, io.ErrUnexpectedEOF},
// 		// Force error in nonce.
// 		{baseVersion, baseVersionEncoded, pver, BaseEncoding, 73, io.ErrShortWrite, io.ErrUnexpectedEOF},
// 		// Force error in user agent length.
// 		{baseVersion, baseVersionEncoded, pver, BaseEncoding, 81, io.ErrShortWrite, io.EOF},
// 		// Force error in user agent.
// 		{baseVersion, baseVersionEncoded, pver, BaseEncoding, 82, io.ErrShortWrite, io.ErrUnexpectedEOF},
// 		// Force error in last block.
// 		{baseVersion, baseVersionEncoded, pver, BaseEncoding, 98, io.ErrShortWrite, io.ErrUnexpectedEOF},
// 		// Force error in relay tx - no read error should happen since it's optional.
// 		{
// 			baseVersionBIP0037, baseVersionBIP0037Encoded,
// 			BIP0037Version, BaseEncoding, 101, io.ErrShortWrite, nil,
// 		},
// 		// Force error due to user agent too big
// 		{exceedUAVer, exceedUAVerEncoded, pver, BaseEncoding, newLen, wireErr, wireErr},
// 	}
// 	t.Logf("Running %d tests", len(tests))
// 	for i, test := range tests {
// 		// Encode to wire format.
// 		w := newFixedWriter(test.max)
// 		e := test.in.BtcEncode(w, test.pver, test.enc)
// 		if reflect.TypeOf(err) != reflect.TypeOf(test.writeErr) {
// 			t.Errorf("BtcEncode #%d wrong error got: %v, want: %v",
// 				i, e, test.writeErr)
// 			continue
// 		}
// 		// For errors which are not of type MessageError, check them for equality.
// 		if _, ok := err.(*MessageError); !ok {
// 			if err != test.writeErr {
// 				t.Errorf("BtcEncode #%d wrong error got: %v, "+
// 					"want: %v", i, e, test.writeErr)
// 				continue
// 			}
// 		}
// 		// Decode from wire format.
// 		var msg MsgVersion
// 		buf := bytes.NewBuffer(test.buf[0:test.max])
// 		e = msg.BtcDecode(buf, test.pver, test.enc)
// 		if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
// 			t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
// 				i, e, test.readErr)
// 			continue
// 		}
// 		// For errors which are not of type MessageError, check them for equality.
// 		if _, ok := err.(*MessageError); !ok {
// 			if err != test.readErr {
// 				t.Errorf("BtcDecode #%d wrong error got: %v, "+
// 					"want: %v", i, e, test.readErr)
// 				continue
// 			}
// 		}
// 	}
// }

// // TestVersionOptionalFields performs tests to ensure that an encoded version messages that omit optional fields are handled correctly.
// func TestVersionOptionalFields(// 	t *testing.T) {
// 	// onlyRequiredVersion is a version message that only contains the required versions and all other values set to their default values.
// 	onlyRequiredVersion := MsgVersion{
// 		ProtocolVersion: 60002,
// 		Services:        SFNodeNetwork,
// 		Timestamp:       time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST)
// 		AddrYou: NetAddress{
// 			Timestamp: time.Time{}, // Zero value -- no timestamp in version
// 			Services:  SFNodeNetwork,
// 			IP:        net.ParseIP("192.168.0.1"),
// 			Port:      11047,
// 		},
// 	}
// 	onlyRequiredVersionEncoded := make([]byte, len(baseVersionEncoded)-55)
// 	copy(onlyRequiredVersionEncoded, baseVersionEncoded)
// 	// addrMeVersion is a version message that contains all fields through the AddrMe field.
// 	addrMeVersion := onlyRequiredVersion
// 	addrMeVersion.AddrMe = NetAddress{
// 		Timestamp: time.Time{}, // Zero value -- no timestamp in version
// 		Services:  SFNodeNetwork,
// 		IP:        net.ParseIP("127.0.0.1"),
// 		Port:      11047,
// 	}
// 	addrMeVersionEncoded := make([]byte, len(baseVersionEncoded)-29)
// 	copy(addrMeVersionEncoded, baseVersionEncoded)
// 	// nonceVersion is a version message that contains all fields through the Nonce field.
// 	nonceVersion := addrMeVersion
// 	nonceVersion.Nonce = 123123 // 0x1e0f3
// 	nonceVersionEncoded := make([]byte, len(baseVersionEncoded)-21)
// 	copy(nonceVersionEncoded, baseVersionEncoded)
// 	// uaVersion is a version message that contains all fields through the UserAgent field.
// 	uaVersion := nonceVersion
// 	uaVersion.UserAgent = "/podtest:0.0.1/"
// 	uaVersionEncoded := make([]byte, len(baseVersionEncoded)-4)
// 	copy(uaVersionEncoded, baseVersionEncoded)
// 	// lastBlockVersion is a version message that contains all fields through the LastBlock field.
// 	lastBlockVersion := uaVersion
// 	lastBlockVersion.LastBlock = 234234 // 0x392fa
// 	lastBlockVersionEncoded := make([]byte, len(baseVersionEncoded))
// 	copy(lastBlockVersionEncoded, baseVersionEncoded)
// 	tests := []struct {
// 		msg  *MsgVersion     // Expected message
// 		buf  []byte          // Wire encoding
// 		pver uint32          // Protocol version for wire encoding
// 		enc  MessageEncoding // Message encoding format
// 	}{
// 		{
// 			&onlyRequiredVersion,
// 			onlyRequiredVersionEncoded,
// 			ProtocolVersion,
// 			BaseEncoding,
// 		},
// 		{
// 			&addrMeVersion,
// 			addrMeVersionEncoded,
// 			ProtocolVersion,
// 			BaseEncoding,
// 		},
// 		{
// 			&nonceVersion,
// 			nonceVersionEncoded,
// 			ProtocolVersion,
// 			BaseEncoding,
// 		},
// 		{
// 			&uaVersion,
// 			uaVersionEncoded,
// 			ProtocolVersion,
// 			BaseEncoding,
// 		},
// 		{
// 			&lastBlockVersion,
// 			lastBlockVersionEncoded,
// 			ProtocolVersion,
// 			BaseEncoding,
// 		},
// 	}
// 	for i, test := range tests {
// 		// Decode the message from wire format.
// 		var msg MsgVersion
// 		rbuf := bytes.NewBuffer(test.buf)
// 		e := msg.BtcDecode(rbuf, test.pver, test.enc)
// 		if e != nil  {
// 			t.Errorf("BtcDecode #%d error %v", i, err)
// 			continue
// 		}
// 		if !reflect.DeepEqual(&msg, test.msg) {
// 			t.Errorf("BtcDecode #%d\n got: %s want: %s", i,
// 				spew.Sdump(msg), spew.Sdump(test.msg))
// 			continue
// 		}
// 	}
// }

// // baseVersion is used in the various tests as a baseline MsgVersion.
// var baseVersion = &MsgVersion{
// 	ProtocolVersion: 60002,
// 	Services:        SFNodeNetwork,
// 	Timestamp:       time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST)
// 	AddrYou: NetAddress{
// 		Timestamp: time.Time{}, // Zero value -- no timestamp in version
// 		Services:  SFNodeNetwork,
// 		IP:        net.ParseIP("192.168.0.1"),
// 		Port:      11047,
// 	},
// 	AddrMe: NetAddress{
// 		Timestamp: time.Time{}, // Zero value -- no timestamp in version
// 		Services:  SFNodeNetwork,
// 		IP:        net.ParseIP("127.0.0.1"),
// 		Port:      11047,
// 	},
// 	Nonce:     123123, // 0x1e0f3
// 	UserAgent: "/podtest:0.0.1/",
// 	LastBlock: 234234, // 0x392fa
// }

// // baseVersionEncoded is the wire encoded bytes for baseVersion using protocol version 60002 and is used in the various tests.
// var baseVersionEncoded = []byte{
// 	0x62, 0xea, 0x00, 0x00, // Protocol version 60002
// 	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
// 	0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // 64-bit Timestamp
// 	// AddrYou -- No timestamp for NetAddress in version message
// 	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
// 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 	0x00, 0x00, 0xff, 0xff, 0xc0, 0xa8, 0x00, 0x01, // IP 192.168.0.1
// 	0x20, 0x8d, // Port 11047 in big-endian
// 	// AddrMe -- No timestamp for NetAddress in version message
// 	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
// 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 	0x00, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x01, // IP 127.0.0.1
// 	0x20, 0x8d, // Port 11047 in big-endian
// 	0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Nonce
// 	0x10, // Varint for user agent length
// 	0x2f, 0x62, 0x74, 0x63, 0x64, 0x74, 0x65, 0x73,
// 	0x74, 0x3a, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x2f, // User agent
// 	0xfa, 0x92, 0x03, 0x00, // Last block
// }

// // baseVersionBIP0037 is used in the various tests as a baseline MsgVersion for BIP0037.
// var baseVersionBIP0037 = &MsgVersion{
// 	ProtocolVersion: 70001,
// 	Services:        SFNodeNetwork,
// 	Timestamp:       time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST)
// 	AddrYou: NetAddress{
// 		Timestamp: time.Time{}, // Zero value -- no timestamp in version
// 		Services:  SFNodeNetwork,
// 		IP:        net.ParseIP("192.168.0.1"),
// 		Port:      11047,
// 	},
// 	AddrMe: NetAddress{
// 		Timestamp: time.Time{}, // Zero value -- no timestamp in version
// 		Services:  SFNodeNetwork,
// 		IP:        net.ParseIP("127.0.0.1"),
// 		Port:      11047,
// 	},
// 	Nonce:     123123, // 0x1e0f3
// 	UserAgent: "/podtest:0.0.1/",
// 	LastBlock: 234234, // 0x392fa
// }

// // baseVersionBIP0037Encoded is the wire encoded bytes for baseVersionBIP0037 using protocol version BIP0037Version and is used in the various tests.
// var baseVersionBIP0037Encoded = []byte{
// 	0x71, 0x11, 0x01, 0x00, // Protocol version 70001
// 	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
// 	0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // 64-bit Timestamp
// 	// AddrYou -- No timestamp for NetAddress in version message
// 	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
// 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 	0x00, 0x00, 0xff, 0xff, 0xc0, 0xa8, 0x00, 0x01, // IP 192.168.0.1
// 	0x20, 0x8d, // Port 11047 in big-endian
// 	// AddrMe -- No timestamp for NetAddress in version message
// 	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SFNodeNetwork
// 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// 	0x00, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x01, // IP 127.0.0.1
// 	0x20, 0x8d, // Port 11047 in big-endian
// 	0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Nonce
// 	0x10, // Varint for user agent length
// 	0x2f, 0x62, 0x74, 0x63, 0x64, 0x74, 0x65, 0x73,
// 	0x74, 0x3a, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x2f, // User agent
// 	0xfa, 0x92, 0x03, 0x00, // Last block
// 	0x01, // Relay tx
// }