LBRYCommunity/lbcd
1
0
Fork 0
Code Issues 17 Pull requests 4 Projects Releases 28 Packages Wiki Activity

BIP0144+wire: add a MessageEncoding variant for serialization/deserialization

Browse source 
This commit modifies the existing wire.Message interface to introduce a
new MessageEncoding variant which dictates the exact encoding to be
used when serializing and deserializing messages. Such an option is now
necessary due to the segwit soft-fork package, as btcd will need to be
able to optionally encode transactions/blocks without witness data to
un-upgraded peers.

Two new functions have been introduced: ReadMessageWithEncodingN and
WriteMessageWithEncodingN which wrap BtcDecode/BtcEncode with the
desired encoding format.
This commit is contained in:
Olaoluwa Osuntokun 2016-10-18 16:21:48 -07:00 committed by Dave Collins
parent 1b359e1131
commit 48abfdf87c
51 changed files with 862 additions and 515 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
wire/bench_test.go
View file

@ -394,7 +394,7 @@ func BenchmarkDecodeGetHeaders(b *testing.B) {
// Serialize it so the bytes are available to test the decode below.
var bb bytes.Buffer
if err := m.BtcEncode(&bb, pver); err != nil {
if err := m.BtcEncode(&bb, pver, LatestEncoding); err != nil {
b.Fatalf("MsgGetHeaders.BtcEncode: unexpected error: %v", err)
}
buf := bb.Bytes()
@ -404,7 +404,7 @@ func BenchmarkDecodeGetHeaders(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
r.Seek(0, 0)
msg.BtcDecode(r, pver)
msg.BtcDecode(r, pver, LatestEncoding)
}
}
@ -424,7 +424,7 @@ func BenchmarkDecodeHeaders(b *testing.B) {
// Serialize it so the bytes are available to test the decode below.
var bb bytes.Buffer
if err := m.BtcEncode(&bb, pver); err != nil {
if err := m.BtcEncode(&bb, pver, LatestEncoding); err != nil {
b.Fatalf("MsgHeaders.BtcEncode: unexpected error: %v", err)
}
buf := bb.Bytes()
@ -434,7 +434,7 @@ func BenchmarkDecodeHeaders(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
r.Seek(0, 0)
msg.BtcDecode(r, pver)
msg.BtcDecode(r, pver, LatestEncoding)
}
}
@ -454,7 +454,7 @@ func BenchmarkDecodeGetBlocks(b *testing.B) {
// Serialize it so the bytes are available to test the decode below.
var bb bytes.Buffer
if err := m.BtcEncode(&bb, pver); err != nil {
if err := m.BtcEncode(&bb, pver, LatestEncoding); err != nil {
b.Fatalf("MsgGetBlocks.BtcEncode: unexpected error: %v", err)
}
buf := bb.Bytes()
@ -464,7 +464,7 @@ func BenchmarkDecodeGetBlocks(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
r.Seek(0, 0)
msg.BtcDecode(r, pver)
msg.BtcDecode(r, pver, LatestEncoding)
}
}
@ -481,7 +481,7 @@ func BenchmarkDecodeAddr(b *testing.B) {
// Serialize it so the bytes are available to test the decode below.
var bb bytes.Buffer
if err := ma.BtcEncode(&bb, pver); err != nil {
if err := ma.BtcEncode(&bb, pver, LatestEncoding); err != nil {
b.Fatalf("MsgAddr.BtcEncode: unexpected error: %v", err)
}
buf := bb.Bytes()
@ -491,7 +491,7 @@ func BenchmarkDecodeAddr(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
r.Seek(0, 0)
msg.BtcDecode(r, pver)
msg.BtcDecode(r, pver, LatestEncoding)
}
}
@ -511,7 +511,7 @@ func BenchmarkDecodeInv(b *testing.B) {
// Serialize it so the bytes are available to test the decode below.
var bb bytes.Buffer
if err := m.BtcEncode(&bb, pver); err != nil {
if err := m.BtcEncode(&bb, pver, LatestEncoding); err != nil {
b.Fatalf("MsgInv.BtcEncode: unexpected error: %v", err)
}
buf := bb.Bytes()
@ -521,7 +521,7 @@ func BenchmarkDecodeInv(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
r.Seek(0, 0)
msg.BtcDecode(r, pver)
msg.BtcDecode(r, pver, LatestEncoding)
}
}
@ -541,7 +541,7 @@ func BenchmarkDecodeNotFound(b *testing.B) {
// Serialize it so the bytes are available to test the decode below.
var bb bytes.Buffer
if err := m.BtcEncode(&bb, pver); err != nil {
if err := m.BtcEncode(&bb, pver, LatestEncoding); err != nil {
b.Fatalf("MsgNotFound.BtcEncode: unexpected error: %v", err)
}
buf := bb.Bytes()
@ -551,7 +551,7 @@ func BenchmarkDecodeNotFound(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
r.Seek(0, 0)
msg.BtcDecode(r, pver)
msg.BtcDecode(r, pver, LatestEncoding)
}
}
@ -579,7 +579,7 @@ func BenchmarkDecodeMerkleBlock(b *testing.B) {
// Serialize it so the bytes are available to test the decode below.
var bb bytes.Buffer
if err := m.BtcEncode(&bb, pver); err != nil {
if err := m.BtcEncode(&bb, pver, LatestEncoding); err != nil {
b.Fatalf("MsgMerkleBlock.BtcEncode: unexpected error: %v", err)
}
buf := bb.Bytes()
@ -589,7 +589,7 @@ func BenchmarkDecodeMerkleBlock(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
r.Seek(0, 0)
msg.BtcDecode(r, pver)
msg.BtcDecode(r, pver, LatestEncoding)
}
}

4
wire/blockheader.go
View file

@ -60,7 +60,7 @@ func (h *BlockHeader) BlockHash() chainhash.Hash {
// This is part of the Message interface implementation.
// See Deserialize for decoding block headers stored to disk, such as in a
// database, as opposed to decoding block headers from the wire.
func (h *BlockHeader) BtcDecode(r io.Reader, pver uint32) error {
func (h *BlockHeader) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
return readBlockHeader(r, pver, h)
}
@ -68,7 +68,7 @@ func (h *BlockHeader) BtcDecode(r io.Reader, pver uint32) error {
// This is part of the Message interface implementation.
// See Serialize for encoding block headers to be stored to disk, such as in a
// database, as opposed to encoding block headers for the wire.
func (h *BlockHeader) BtcEncode(w io.Writer, pver uint32) error {
func (h *BlockHeader) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
return writeBlockHeader(w, pver, h)
}

18
wire/blockheader_test.go
View file

@ -79,10 +79,11 @@ func TestBlockHeaderWire(t *testing.T) {
}
tests := []struct {
in *BlockHeader // Data to encode
out *BlockHeader // Expected decoded data
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *BlockHeader // Data to encode
out *BlockHeader // Expected decoded data
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding variant to use
}{
// Latest protocol version.
{
@ -90,6 +91,7 @@ func TestBlockHeaderWire(t *testing.T) {
baseBlockHdr,
baseBlockHdrEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version.
@ -98,6 +100,7 @@ func TestBlockHeaderWire(t *testing.T) {
baseBlockHdr,
baseBlockHdrEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version.
@ -106,6 +109,7 @@ func TestBlockHeaderWire(t *testing.T) {
baseBlockHdr,
baseBlockHdrEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion.
@ -114,6 +118,7 @@ func TestBlockHeaderWire(t *testing.T) {
baseBlockHdr,
baseBlockHdrEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion.
@ -122,6 +127,7 @@ func TestBlockHeaderWire(t *testing.T) {
baseBlockHdr,
baseBlockHdrEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -141,7 +147,7 @@ func TestBlockHeaderWire(t *testing.T) {
}
buf.Reset()
err = test.in.BtcEncode(&buf, pver)
err = test.in.BtcEncode(&buf, pver, 0)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -167,7 +173,7 @@ func TestBlockHeaderWire(t *testing.T) {
}
rbuf = bytes.NewReader(test.buf)
err = bh.BtcDecode(rbuf, pver)
err = bh.BtcDecode(rbuf, pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue

9
wire/fakemessage_test.go
View file

@ -15,15 +15,16 @@ type fakeMessage struct {
forceLenErr bool
}
// BtcDecode doesn't do anything. It just satisfies the Message interface.
func (msg *fakeMessage) BtcDecode(r io.Reader, pver uint32) error {
// BtcDecode doesn't do anything. It just satisfies the wire.Message
// interface.
func (msg *fakeMessage) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
return nil
}
// BtcEncode writes the payload field of the fake message or forces an error
// if the forceEncodeErr flag of the fake message is set. It also satisfies the
// Message interface.
func (msg *fakeMessage) BtcEncode(w io.Writer, pver uint32) error {
// wire.Message interface.
func (msg *fakeMessage) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
if msg.forceEncodeErr {
err := &MessageError{
Func: "fakeMessage.BtcEncode",

79
wire/message.go
View file

@ -53,13 +53,31 @@ const (
CmdFeeFilter = "feefilter"
)
// WireEncoding represents the wire message encoding format to be used.
type MessageEncoding uint32
const (
// BaseEncoding encodes all messages in the default format specified
// for the Bitcoin wire protocol.
BaseEncoding MessageEncoding = 1 << iota
// WitnessEncoding encodes all messages other than transaction messages
// using the default Bitcoin wire protocol specification. For transaction
// messages, the new encoding format detailed in BIP0144 will be used.
WitnessEncoding
)
// LatestEncoding is the most recently specified encoding for the Bitcoin wire
// protocol.
var LatestEncoding = WitnessEncoding
// Message is an interface that describes a bitcoin message. A type that
// implements Message has complete control over the representation of its data
// and may therefore contain additional or fewer fields than those which
// are used directly in the protocol encoded message.
type Message interface {
BtcDecode(io.Reader, uint32) error
BtcEncode(io.Writer, uint32) error
BtcDecode(io.Reader, uint32, MessageEncoding) error
BtcEncode(io.Writer, uint32, MessageEncoding) error
Command() string
MaxPayloadLength(uint32) uint32
}
@ -200,6 +218,27 @@ func discardInput(r io.Reader, n uint32) {
// information and returns the number of bytes written. This function is the
// same as WriteMessage except it also returns the number of bytes written.
func WriteMessageN(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) (int, error) {
return WriteMessageWithEncodingN(w, msg, pver, btcnet, BaseEncoding)
}
// WriteMessage writes a bitcoin Message to w including the necessary header
// information. This function is the same as WriteMessageN except it doesn't
// doesn't return the number of bytes written. This function is mainly provided
// for backwards compatibility with the original API, but it's also useful for
// callers that don't care about byte counts.
func WriteMessage(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) error {
_, err := WriteMessageN(w, msg, pver, btcnet)
return err
}
// WriteMessageWithEncodingN writes a bitcoin Message to w including the
// necessary header information and returns the number of bytes written.
// This function is the same as WriteMessageN except it also allows the caller
// to specify the message encoding format to be used when serializing wire
// messages.
func WriteMessageWithEncodingN(w io.Writer, msg Message, pver uint32,
btcnet BitcoinNet, encoding MessageEncoding) (int, error) {
totalBytes := 0
// Enforce max command size.
@ -214,7 +253,7 @@ func WriteMessageN(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) (in
// Encode the message payload.
var bw bytes.Buffer
err := msg.BtcEncode(&bw, pver)
err := msg.BtcEncode(&bw, pver, encoding)
if err != nil {
return totalBytes, err
}
@ -264,22 +303,15 @@ func WriteMessageN(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) (in
return totalBytes, err
}
// WriteMessage writes a bitcoin Message to w including the necessary header
// information. This function is the same as WriteMessageN except it doesn't
// doesn't return the number of bytes written. This function is mainly provided
// for backwards compatibility with the original API, but it's also useful for
// callers that don't care about byte counts.
func WriteMessage(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) error {
_, err := WriteMessageN(w, msg, pver, btcnet)
return err
}
// ReadMessageWithEncodingN reads, validates, and parses the next bitcoin Message
// from r for the provided protocol version and bitcoin network. It returns the
// number of bytes read in addition to the parsed Message and raw bytes which
// comprise the message. This function is the same as ReadMessageN except it
// allows the caller to specify which message encoding is to to consult when
// decoding wire messages.
func ReadMessageWithEncodingN(r io.Reader, pver uint32, btcnet BitcoinNet,
enc MessageEncoding) (int, Message, []byte, error) {
// ReadMessageN reads, validates, and parses the next bitcoin Message from r for
// the provided protocol version and bitcoin network. It returns the number of
// bytes read in addition to the parsed Message and raw bytes which comprise the
// message. This function is the same as ReadMessage except it also returns the
// number of bytes read.
func ReadMessageN(r io.Reader, pver uint32, btcnet BitcoinNet) (int, Message, []byte, error) {
totalBytes := 0
n, hdr, err := readMessageHeader(r)
totalBytes += n
@ -351,7 +383,7 @@ func ReadMessageN(r io.Reader, pver uint32, btcnet BitcoinNet) (int, Message, []
// Unmarshal message. NOTE: This must be a *bytes.Buffer since the
// MsgVersion BtcDecode function requires it.
pr := bytes.NewBuffer(payload)
err = msg.BtcDecode(pr, pver)
err = msg.BtcDecode(pr, pver, enc)
if err != nil {
return totalBytes, nil, nil, err
}
@ -359,6 +391,15 @@ func ReadMessageN(r io.Reader, pver uint32, btcnet BitcoinNet) (int, Message, []
return totalBytes, msg, payload, nil
}
// ReadMessageN reads, validates, and parses the next bitcoin Message from r for
// the provided protocol version and bitcoin network. It returns the number of
// bytes read in addition to the parsed Message and raw bytes which comprise the
// message. This function is the same as ReadMessage except it also returns the
// number of bytes read.
func ReadMessageN(r io.Reader, pver uint32, btcnet BitcoinNet) (int, Message, []byte, error) {
return ReadMessageWithEncodingN(r, pver, btcnet, BaseEncoding)
}
// ReadMessage reads, validates, and parses the next bitcoin Message from r for
// the provided protocol version and bitcoin network. It returns the parsed
// Message and raw bytes which comprise the message. This function only differs

4
wire/msgaddr.go
View file

@ -57,7 +57,7 @@ func (msg *MsgAddr) ClearAddresses() {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgAddr) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgAddr) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
count, err := ReadVarInt(r, pver)
if err != nil {
return err
@ -85,7 +85,7 @@ func (msg *MsgAddr) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgAddr) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgAddr) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
// Protocol versions before MultipleAddressVersion only allowed 1 address
// per message.
count := len(msg.AddrList)

41
wire/msgaddr_test.go
View file

@ -139,10 +139,11 @@ func TestAddrWire(t *testing.T) {
}
tests := []struct {
in *MsgAddr // Message to encode
out *MsgAddr // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgAddr // Message to encode
out *MsgAddr // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version with no addresses.
{
@ -150,6 +151,7 @@ func TestAddrWire(t *testing.T) {
noAddr,
noAddrEncoded,
ProtocolVersion,
BaseEncoding,
},
// Latest protocol version with multiple addresses.
@ -158,6 +160,7 @@ func TestAddrWire(t *testing.T) {
multiAddr,
multiAddrEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion-1 with no addresses.
@ -166,6 +169,7 @@ func TestAddrWire(t *testing.T) {
noAddr,
noAddrEncoded,
MultipleAddressVersion - 1,
BaseEncoding,
},
}
@ -173,7 +177,7 @@ func TestAddrWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -187,7 +191,7 @@ func TestAddrWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgAddr
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -251,30 +255,31 @@ func TestAddrWireErrors(t *testing.T) {
}
tests := []struct {
in *MsgAddr // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgAddr // 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
}{
// Latest protocol version with intentional read/write errors.
// Force error in addresses count
{baseAddr, baseAddrEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{baseAddr, baseAddrEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in address list.
{baseAddr, baseAddrEncoded, pver, 1, io.ErrShortWrite, io.EOF},
{baseAddr, baseAddrEncoded, pver, BaseEncoding, 1, io.ErrShortWrite, io.EOF},
// Force error with greater than max inventory vectors.
{maxAddr, maxAddrEncoded, pver, 3, wireErr, wireErr},
{maxAddr, maxAddrEncoded, pver, BaseEncoding, 3, wireErr, wireErr},
// Force error with greater than max inventory vectors for
// protocol versions before multiple addresses were allowed.
{maxAddr, maxAddrEncoded, pverMA - 1, 3, wireErr, wireErr},
{maxAddr, maxAddrEncoded, pverMA - 1, BaseEncoding, 3, wireErr, wireErr},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -294,7 +299,7 @@ func TestAddrWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgAddr
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msgalert.go
View file

@ -333,7 +333,7 @@ type MsgAlert struct {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgAlert) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgAlert) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
var err error
msg.SerializedPayload, err = ReadVarBytes(r, pver, MaxMessagePayload,
@ -354,7 +354,7 @@ func (msg *MsgAlert) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgAlert) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgAlert) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
var err error
var serializedpayload []byte
if msg.Payload != nil {

55
wire/msgalert_test.go
View file

@ -16,6 +16,7 @@ import (
// TestMsgAlert tests the MsgAlert API.
func TestMsgAlert(t *testing.T) {
pver := ProtocolVersion
encoding := BaseEncoding
serializedpayload := []byte("some message")
signature := []byte("some sig")
@ -48,7 +49,7 @@ func TestMsgAlert(t *testing.T) {
// Test BtcEncode with Payload == nil
var buf bytes.Buffer
err := msg.BtcEncode(&buf, pver)
err := msg.BtcEncode(&buf, pver, encoding)
if err != nil {
t.Error(err.Error())
}
@ -65,7 +66,7 @@ func TestMsgAlert(t *testing.T) {
// note: Payload is an empty Alert but not nil
msg.Payload = new(Alert)
buf = *new(bytes.Buffer)
err = msg.BtcEncode(&buf, pver)
err = msg.BtcEncode(&buf, pver, encoding)
if err != nil {
t.Error(err.Error())
}
@ -94,10 +95,11 @@ func TestMsgAlertWire(t *testing.T) {
}
tests := []struct {
in *MsgAlert // Message to encode
out *MsgAlert // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgAlert // Message to encode
out *MsgAlert // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version.
{
@ -105,6 +107,7 @@ func TestMsgAlertWire(t *testing.T) {
baseMsgAlert,
baseMsgAlertEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version.
@ -113,6 +116,7 @@ func TestMsgAlertWire(t *testing.T) {
baseMsgAlert,
baseMsgAlertEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version.
@ -121,6 +125,7 @@ func TestMsgAlertWire(t *testing.T) {
baseMsgAlert,
baseMsgAlertEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion.
@ -129,6 +134,7 @@ func TestMsgAlertWire(t *testing.T) {
baseMsgAlert,
baseMsgAlertEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion.
@ -137,6 +143,7 @@ func TestMsgAlertWire(t *testing.T) {
baseMsgAlert,
baseMsgAlertEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -144,7 +151,7 @@ func TestMsgAlertWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -158,7 +165,7 @@ func TestMsgAlertWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgAlert
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -175,6 +182,7 @@ func TestMsgAlertWire(t *testing.T) {
// of MsgAlert to confirm error paths work correctly.
func TestMsgAlertWireErrors(t *testing.T) {
pver := ProtocolVersion
encoding := BaseEncoding
baseMsgAlert := NewMsgAlert([]byte("some payload"), []byte("somesig"))
baseMsgAlertEncoded := []byte{
@ -186,28 +194,29 @@ func TestMsgAlertWireErrors(t *testing.T) {
}
tests := []struct {
in *MsgAlert // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgAlert // 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 payload length.
{baseMsgAlert, baseMsgAlertEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{baseMsgAlert, baseMsgAlertEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in payload.
{baseMsgAlert, baseMsgAlertEncoded, pver, 1, io.ErrShortWrite, io.EOF},
{baseMsgAlert, baseMsgAlertEncoded, pver, BaseEncoding, 1, io.ErrShortWrite, io.EOF},
// Force error in signature length.
{baseMsgAlert, baseMsgAlertEncoded, pver, 13, io.ErrShortWrite, io.EOF},
{baseMsgAlert, baseMsgAlertEncoded, pver, BaseEncoding, 13, io.ErrShortWrite, io.EOF},
// Force error in signature.
{baseMsgAlert, baseMsgAlertEncoded, pver, 14, io.ErrShortWrite, io.EOF},
{baseMsgAlert, baseMsgAlertEncoded, pver, BaseEncoding, 14, io.ErrShortWrite, io.EOF},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -227,7 +236,7 @@ func TestMsgAlertWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgAlert
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)
@ -248,7 +257,7 @@ func TestMsgAlertWireErrors(t *testing.T) {
// Test Error on empty Payload
baseMsgAlert.SerializedPayload = []byte{}
w := new(bytes.Buffer)
err := baseMsgAlert.BtcEncode(w, pver)
err := baseMsgAlert.BtcEncode(w, pver, encoding)
if _, ok := err.(*MessageError); !ok {
t.Errorf("MsgAlert.BtcEncode wrong error got: %T, want: %T",
err, MessageError{})
@ -259,7 +268,7 @@ func TestMsgAlertWireErrors(t *testing.T) {
baseMsgAlert.Payload = new(Alert)
baseMsgAlert.Payload.SetCancel = make([]int32, maxCountSetCancel+1)
buf := *new(bytes.Buffer)
err = baseMsgAlert.BtcEncode(&buf, pver)
err = baseMsgAlert.BtcEncode(&buf, pver, encoding)
if _, ok := err.(*MessageError); !ok {
t.Errorf("MsgAlert.BtcEncode wrong error got: %T, want: %T",
err, MessageError{})
@ -269,7 +278,7 @@ func TestMsgAlertWireErrors(t *testing.T) {
baseMsgAlert.Payload = new(Alert)
baseMsgAlert.Payload.SetSubVer = make([]string, maxCountSetSubVer+1)
buf = *new(bytes.Buffer)
err = baseMsgAlert.BtcEncode(&buf, pver)
err = baseMsgAlert.BtcEncode(&buf, pver, encoding)
if _, ok := err.(*MessageError); !ok {
t.Errorf("MsgAlert.BtcEncode wrong error got: %T, want: %T",
err, MessageError{})

37
wire/msgblock.go
View file

@ -60,7 +60,7 @@ func (msg *MsgBlock) ClearTransactions() {
// This is part of the Message interface implementation.
// See Deserialize for decoding blocks stored to disk, such as in a database, as
// opposed to decoding blocks from the wire.
func (msg *MsgBlock) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgBlock) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
err := readBlockHeader(r, pver, &msg.Header)
if err != nil {
return err
@ -83,7 +83,7 @@ func (msg *MsgBlock) BtcDecode(r io.Reader, pver uint32) error {
msg.Transactions = make([]*MsgTx, 0, txCount)
for i := uint64(0); i < txCount; i++ {
tx := MsgTx{}
err := tx.BtcDecode(r, pver)
err := tx.BtcDecode(r, pver, enc)
if err != nil {
return err
}
@ -106,7 +106,19 @@ func (msg *MsgBlock) Deserialize(r io.Reader) error {
// At the current time, there is no difference between the wire encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of BtcDecode.
return msg.BtcDecode(r, 0)
//
// Passing an encoding type of WitnessEncoding to BtcEncode for the
// MessageEncoding parameter indicates that the transactions within the
// block are expected to be serialized according to the new
// serialization structure defined in BIP0141.
return msg.BtcDecode(r, 0, WitnessEncoding)
}
// DeserializeWitness decodes a block from r into the receiver similar to
// Deserialize, however DeserializeWitness strips all (if any) witness data
// from the transactions within the block before encoding them.
func (msg *MsgBlock) DeserializeNoWitness(r io.Reader) error {
return msg.BtcDecode(r, 0, BaseEncoding)
}
// DeserializeTxLoc decodes r in the same manner Deserialize does, but it takes
@ -160,7 +172,7 @@ func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
// This is part of the Message interface implementation.
// See Serialize for encoding blocks to be stored to disk, such as in a
// database, as opposed to encoding blocks for the wire.
func (msg *MsgBlock) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgBlock) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
err := writeBlockHeader(w, pver, &msg.Header)
if err != nil {
return err
@ -172,7 +184,7 @@ func (msg *MsgBlock) BtcEncode(w io.Writer, pver uint32) error {
}
for _, tx := range msg.Transactions {
err = tx.BtcEncode(w, pver)
err = tx.BtcEncode(w, pver, enc)
if err != nil {
return err
}
@ -194,7 +206,20 @@ func (msg *MsgBlock) Serialize(w io.Writer) error {
// At the current time, there is no difference between the wire encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of BtcEncode.
return msg.BtcEncode(w, 0)
//
// Passing WitnessEncoding as the encoding type here indicates that
// each of the transactions should be serialized using the witness
// serialization structure defined in BIP0141.
return msg.BtcEncode(w, 0, WitnessEncoding)
}
// SerializeWitness encodes a block to w using an identical format to Serialize,
// with all (if any) witness data stripped from all transactions.
// This method is provided in additon to the regular Serialize, in order to
// allow one to selectively encode transaction witness data to non-upgraded
// peers which are unaware of the new encoding.
func (msg *MsgBlock) SerializeNoWitness(w io.Writer) error {
return msg.BtcEncode(w, 0, BaseEncoding)
}
// SerializeSize returns the number of bytes it would take to serialize the

67
wire/msgblock_test.go
View file

@ -36,7 +36,7 @@ func TestBlock(t *testing.T) {
// Ensure max payload is expected value for latest protocol version.
// Num addresses (varInt) + max allowed addresses.
wantPayload := uint32(1000000)
wantPayload := uint32(4000000)
maxPayload := msg.MaxPayloadLength(pver)
if maxPayload != wantPayload {
t.Errorf("MaxPayloadLength: wrong max payload length for "+
@ -110,11 +110,12 @@ func TestBlockHash(t *testing.T) {
// of transaction inputs and outputs and protocol versions.
func TestBlockWire(t *testing.T) {
tests := []struct {
in *MsgBlock // Message to encode
out *MsgBlock // Expected decoded message
buf []byte // Wire encoding
txLocs []TxLoc // Expected transaction locations
pver uint32 // Protocol version for wire encoding
in *MsgBlock // Message to encode
out *MsgBlock // Expected decoded message
buf []byte // Wire encoding
txLocs []TxLoc // Expected transaction locations
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version.
{
@ -123,6 +124,7 @@ func TestBlockWire(t *testing.T) {
blockOneBytes,
blockOneTxLocs,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version.
@ -132,6 +134,7 @@ func TestBlockWire(t *testing.T) {
blockOneBytes,
blockOneTxLocs,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version.
@ -141,6 +144,7 @@ func TestBlockWire(t *testing.T) {
blockOneBytes,
blockOneTxLocs,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion.
@ -150,6 +154,7 @@ func TestBlockWire(t *testing.T) {
blockOneBytes,
blockOneTxLocs,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion.
@ -159,14 +164,16 @@ func TestBlockWire(t *testing.T) {
blockOneBytes,
blockOneTxLocs,
MultipleAddressVersion,
BaseEncoding,
},
// TODO(roasbeef): add case for witnessy block
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -180,7 +187,7 @@ func TestBlockWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgBlock
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -202,36 +209,37 @@ func TestBlockWireErrors(t *testing.T) {
pver := uint32(60002)
tests := []struct {
in *MsgBlock // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgBlock // 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 version.
{&blockOne, blockOneBytes, pver, 0, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in prev block hash.
{&blockOne, blockOneBytes, pver, 4, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, pver, BaseEncoding, 4, io.ErrShortWrite, io.EOF},
// Force error in merkle root.
{&blockOne, blockOneBytes, pver, 36, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, pver, BaseEncoding, 36, io.ErrShortWrite, io.EOF},
// Force error in timestamp.
{&blockOne, blockOneBytes, pver, 68, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, pver, BaseEncoding, 68, io.ErrShortWrite, io.EOF},
// Force error in difficulty bits.
{&blockOne, blockOneBytes, pver, 72, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, pver, BaseEncoding, 72, io.ErrShortWrite, io.EOF},
// Force error in header nonce.
{&blockOne, blockOneBytes, pver, 76, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, pver, BaseEncoding, 76, io.ErrShortWrite, io.EOF},
// Force error in transaction count.
{&blockOne, blockOneBytes, pver, 80, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, pver, BaseEncoding, 80, io.ErrShortWrite, io.EOF},
// Force error in transactions.
{&blockOne, blockOneBytes, pver, 81, io.ErrShortWrite, io.EOF},
{&blockOne, blockOneBytes, pver, BaseEncoding, 81, io.ErrShortWrite, io.EOF},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := test.in.BtcEncode(w, test.pver, test.enc)
if err != test.writeErr {
t.Errorf("BtcEncode #%d wrong error got: %v, want: %v",
i, err, test.writeErr)
@ -241,7 +249,7 @@ func TestBlockWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgBlock
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if err != test.readErr {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)
@ -388,9 +396,10 @@ func TestBlockOverflowErrors(t *testing.T) {
pver := uint32(70001)
tests := []struct {
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
err error // Expected error
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
err error // Expected error
}{
// Block that claims to have ~uint64(0) transactions.
{
@ -409,7 +418,7 @@ func TestBlockOverflowErrors(t *testing.T) {
0x01, 0xe3, 0x62, 0x99, // Nonce
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, // TxnCount
}, pver, &MessageError{},
}, pver, BaseEncoding, &MessageError{},
},
}
@ -418,7 +427,7 @@ func TestBlockOverflowErrors(t *testing.T) {
// Decode from wire format.
var msg MsgBlock
r := bytes.NewReader(test.buf)
err := msg.BtcDecode(r, test.pver)
err := msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, reflect.TypeOf(test.err))

4
wire/msgfeefilter.go
View file

@ -21,7 +21,7 @@ type MsgFeeFilter struct {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgFeeFilter) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgFeeFilter) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
if pver < FeeFilterVersion {
str := fmt.Sprintf("feefilter message invalid for protocol "+
"version %d", pver)
@ -33,7 +33,7 @@ func (msg *MsgFeeFilter) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgFeeFilter) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgFeeFilter) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
if pver < FeeFilterVersion {
str := fmt.Sprintf("feefilter message invalid for protocol "+
"version %d", pver)

12
wire/msgfeefilter_test.go
View file

@ -43,14 +43,14 @@ func TestFeeFilterLatest(t *testing.T) {
// Test encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, pver)
err := msg.BtcEncode(&buf, pver, BaseEncoding)
if err != nil {
t.Errorf("encode of MsgFeeFilter failed %v err <%v>", msg, err)
}
// Test decode with latest protocol version.
readmsg := NewMsgFeeFilter(0)
err = readmsg.BtcDecode(&buf, pver)
err = readmsg.BtcDecode(&buf, pver, BaseEncoding)
if err != nil {
t.Errorf("decode of MsgFeeFilter failed [%v] err <%v>", buf, err)
}
@ -91,7 +91,7 @@ func TestFeeFilterWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, BaseEncoding)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -105,7 +105,7 @@ func TestFeeFilterWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgFeeFilter
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, BaseEncoding)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -149,7 +149,7 @@ func TestFeeFilterWireErrors(t *testing.T) {
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := test.in.BtcEncode(w, test.pver, BaseEncoding)
if reflect.TypeOf(err) != reflect.TypeOf(test.writeErr) {
t.Errorf("BtcEncode #%d wrong error got: %v, want: %v",
i, err, test.writeErr)
@ -169,7 +169,7 @@ func TestFeeFilterWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgFeeFilter
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, BaseEncoding)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msgfilteradd.go
View file

@ -27,7 +27,7 @@ type MsgFilterAdd struct {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgFilterAdd) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgFilterAdd) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
if pver < BIP0037Version {
str := fmt.Sprintf("filteradd message invalid for protocol "+
"version %d", pver)
@ -42,7 +42,7 @@ func (msg *MsgFilterAdd) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgFilterAdd) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgFilterAdd) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
if pver < BIP0037Version {
str := fmt.Sprintf("filteradd message invalid for protocol "+
"version %d", pver)

36
wire/msgfilteradd_test.go
View file

@ -14,6 +14,7 @@ import (
// TestFilterAddLatest tests the MsgFilterAdd API against the latest protocol
// version.
func TestFilterAddLatest(t *testing.T) {
enc := BaseEncoding
pver := ProtocolVersion
data := []byte{0x01, 0x02}
@ -37,14 +38,14 @@ func TestFilterAddLatest(t *testing.T) {
// Test encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, pver)
err := msg.BtcEncode(&buf, pver, enc)
if err != nil {
t.Errorf("encode of MsgFilterAdd failed %v err <%v>", msg, err)
}
// Test decode with latest protocol version.
var readmsg MsgFilterAdd
err = readmsg.BtcDecode(&buf, pver)
err = readmsg.BtcDecode(&buf, pver, enc)
if err != nil {
t.Errorf("decode of MsgFilterAdd failed [%v] err <%v>", buf, err)
}
@ -61,14 +62,14 @@ func TestFilterAddCrossProtocol(t *testing.T) {
// Encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, ProtocolVersion)
err := msg.BtcEncode(&buf, ProtocolVersion, LatestEncoding)
if err != nil {
t.Errorf("encode of MsgFilterAdd failed %v err <%v>", msg, err)
}
// Decode with old protocol version.
var readmsg MsgFilterAdd
err = readmsg.BtcDecode(&buf, BIP0031Version)
err = readmsg.BtcDecode(&buf, BIP0031Version, LatestEncoding)
if err == nil {
t.Errorf("decode of MsgFilterAdd succeeded when it shouldn't "+
"have %v", msg)
@ -89,7 +90,7 @@ func TestFilterAddMaxDataSize(t *testing.T) {
// Encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, ProtocolVersion)
err := msg.BtcEncode(&buf, ProtocolVersion, LatestEncoding)
if err == nil {
t.Errorf("encode of MsgFilterAdd succeeded when it shouldn't "+
"have %v", msg)
@ -97,7 +98,7 @@ func TestFilterAddMaxDataSize(t *testing.T) {
// Decode with latest protocol version.
readbuf := bytes.NewReader(data)
err = msg.BtcDecode(readbuf, ProtocolVersion)
err = msg.BtcDecode(readbuf, ProtocolVersion, LatestEncoding)
if err == nil {
t.Errorf("decode of MsgFilterAdd succeeded when it shouldn't "+
"have %v", msg)
@ -116,27 +117,28 @@ func TestFilterAddWireErrors(t *testing.T) {
baseFilterAddEncoded := append([]byte{0x04}, baseData...)
tests := []struct {
in *MsgFilterAdd // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgFilterAdd // 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
}{
// Latest protocol version with intentional read/write errors.
// Force error in data size.
{
baseFilterAdd, baseFilterAddEncoded, pver, 0,
baseFilterAdd, baseFilterAddEncoded, pver, BaseEncoding, 0,
io.ErrShortWrite, io.EOF,
},
// Force error in data.
{
baseFilterAdd, baseFilterAddEncoded, pver, 1,
baseFilterAdd, baseFilterAddEncoded, pver, BaseEncoding, 1,
io.ErrShortWrite, io.EOF,
},
// Force error due to unsupported protocol version.
{
baseFilterAdd, baseFilterAddEncoded, pverNoFilterAdd, 5,
baseFilterAdd, baseFilterAddEncoded, pverNoFilterAdd, BaseEncoding, 5,
wireErr, wireErr,
},
}
@ -145,7 +147,7 @@ func TestFilterAddWireErrors(t *testing.T) {
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -165,7 +167,7 @@ func TestFilterAddWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgFilterAdd
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msgfilterclear.go
View file

@ -18,7 +18,7 @@ type MsgFilterClear struct{}
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgFilterClear) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgFilterClear) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
if pver < BIP0037Version {
str := fmt.Sprintf("filterclear message invalid for protocol "+
"version %d", pver)
@ -30,7 +30,7 @@ func (msg *MsgFilterClear) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgFilterClear) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgFilterClear) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
if pver < BIP0037Version {
str := fmt.Sprintf("filterclear message invalid for protocol "+
"version %d", pver)

19
wire/msgfilterclear_test.go
View file

@ -43,14 +43,14 @@ func TestFilterClearCrossProtocol(t *testing.T) {
// Encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, ProtocolVersion)
err := msg.BtcEncode(&buf, ProtocolVersion, LatestEncoding)
if err != nil {
t.Errorf("encode of MsgFilterClear failed %v err <%v>", msg, err)
}
// Decode with old protocol version.
var readmsg MsgFilterClear
err = readmsg.BtcDecode(&buf, BIP0031Version)
err = readmsg.BtcDecode(&buf, BIP0031Version, LatestEncoding)
if err == nil {
t.Errorf("decode of MsgFilterClear succeeded when it "+
"shouldn't have %v", msg)
@ -68,6 +68,7 @@ func TestFilterClearWire(t *testing.T) {
out *MsgFilterClear // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version.
{
@ -75,6 +76,7 @@ func TestFilterClearWire(t *testing.T) {
msgFilterClear,
msgFilterClearEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0037Version + 1.
@ -83,6 +85,7 @@ func TestFilterClearWire(t *testing.T) {
msgFilterClear,
msgFilterClearEncoded,
BIP0037Version + 1,
BaseEncoding,
},
// Protocol version BIP0037Version.
@ -91,6 +94,7 @@ func TestFilterClearWire(t *testing.T) {
msgFilterClear,
msgFilterClearEncoded,
BIP0037Version,
BaseEncoding,
},
}
@ -98,7 +102,7 @@ func TestFilterClearWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -112,7 +116,7 @@ func TestFilterClearWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgFilterClear
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -138,6 +142,7 @@ func TestFilterClearWireErrors(t *testing.T) {
in *MsgFilterClear // 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
@ -145,7 +150,7 @@ func TestFilterClearWireErrors(t *testing.T) {
// Force error due to unsupported protocol version.
{
baseFilterClear, baseFilterClearEncoded,
pverNoFilterClear, 4, wireErr, wireErr,
pverNoFilterClear, BaseEncoding, 4, wireErr, wireErr,
},
}
@ -153,7 +158,7 @@ func TestFilterClearWireErrors(t *testing.T) {
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -173,7 +178,7 @@ func TestFilterClearWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgFilterClear
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msgfilterload.go
View file

@ -51,7 +51,7 @@ type MsgFilterLoad struct {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgFilterLoad) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgFilterLoad) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
if pver < BIP0037Version {
str := fmt.Sprintf("filterload message invalid for protocol "+
"version %d", pver)
@ -81,7 +81,7 @@ func (msg *MsgFilterLoad) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgFilterLoad) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgFilterLoad) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
if pver < BIP0037Version {
str := fmt.Sprintf("filterload message invalid for protocol "+
"version %d", pver)

46
wire/msgfilterload_test.go
View file

@ -15,6 +15,7 @@ import (
// version.
func TestFilterLoadLatest(t *testing.T) {
pver := ProtocolVersion
enc := BaseEncoding
data := []byte{0x01, 0x02}
msg := NewMsgFilterLoad(data, 10, 0, 0)
@ -37,14 +38,14 @@ func TestFilterLoadLatest(t *testing.T) {
// Test encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, pver)
err := msg.BtcEncode(&buf, pver, enc)
if err != nil {
t.Errorf("encode of MsgFilterLoad failed %v err <%v>", msg, err)
}
// Test decode with latest protocol version.
readmsg := MsgFilterLoad{}
err = readmsg.BtcDecode(&buf, pver)
err = readmsg.BtcDecode(&buf, pver, enc)
if err != nil {
t.Errorf("decode of MsgFilterLoad failed [%v] err <%v>", buf, err)
}
@ -58,7 +59,7 @@ func TestFilterLoadCrossProtocol(t *testing.T) {
// Encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, ProtocolVersion)
err := msg.BtcEncode(&buf, ProtocolVersion, BaseEncoding)
if err != nil {
t.Errorf("encode of NewMsgFilterLoad failed %v err <%v>", msg,
err)
@ -66,7 +67,7 @@ func TestFilterLoadCrossProtocol(t *testing.T) {
// Decode with old protocol version.
var readmsg MsgFilterLoad
err = readmsg.BtcDecode(&buf, BIP0031Version)
err = readmsg.BtcDecode(&buf, BIP0031Version, BaseEncoding)
if err == nil {
t.Errorf("decode of MsgFilterLoad succeeded when it shouldn't have %v",
msg)
@ -80,7 +81,7 @@ func TestFilterLoadMaxFilterSize(t *testing.T) {
// Encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, ProtocolVersion)
err := msg.BtcEncode(&buf, ProtocolVersion, BaseEncoding)
if err == nil {
t.Errorf("encode of MsgFilterLoad succeeded when it shouldn't "+
"have %v", msg)
@ -88,7 +89,7 @@ func TestFilterLoadMaxFilterSize(t *testing.T) {
// Decode with latest protocol version.
readbuf := bytes.NewReader(data)
err = msg.BtcDecode(readbuf, ProtocolVersion)
err = msg.BtcDecode(readbuf, ProtocolVersion, BaseEncoding)
if err == nil {
t.Errorf("decode of MsgFilterLoad succeeded when it shouldn't "+
"have %v", msg)
@ -102,7 +103,7 @@ func TestFilterLoadMaxHashFuncsSize(t *testing.T) {
// Encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, ProtocolVersion)
err := msg.BtcEncode(&buf, ProtocolVersion, BaseEncoding)
if err == nil {
t.Errorf("encode of MsgFilterLoad succeeded when it shouldn't have %v",
msg)
@ -117,7 +118,7 @@ func TestFilterLoadMaxHashFuncsSize(t *testing.T) {
}
// Decode with latest protocol version.
readbuf := bytes.NewReader(newBuf)
err = msg.BtcDecode(readbuf, ProtocolVersion)
err = msg.BtcDecode(readbuf, ProtocolVersion, BaseEncoding)
if err == nil {
t.Errorf("decode of MsgFilterLoad succeeded when it shouldn't have %v",
msg)
@ -140,42 +141,43 @@ func TestFilterLoadWireErrors(t *testing.T) {
0x00) // Flags
tests := []struct {
in *MsgFilterLoad // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgFilterLoad // 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
}{
// Latest protocol version with intentional read/write errors.
// Force error in filter size.
{
baseFilterLoad, baseFilterLoadEncoded, pver, 0,
baseFilterLoad, baseFilterLoadEncoded, pver, BaseEncoding, 0,
io.ErrShortWrite, io.EOF,
},
// Force error in filter.
{
baseFilterLoad, baseFilterLoadEncoded, pver, 1,
baseFilterLoad, baseFilterLoadEncoded, pver, BaseEncoding, 1,
io.ErrShortWrite, io.EOF,
},
// Force error in hash funcs.
{
baseFilterLoad, baseFilterLoadEncoded, pver, 5,
baseFilterLoad, baseFilterLoadEncoded, pver, BaseEncoding, 5,
io.ErrShortWrite, io.EOF,
},
// Force error in tweak.
{
baseFilterLoad, baseFilterLoadEncoded, pver, 9,
baseFilterLoad, baseFilterLoadEncoded, pver, BaseEncoding, 9,
io.ErrShortWrite, io.EOF,
},
// Force error in flags.
{
baseFilterLoad, baseFilterLoadEncoded, pver, 13,
baseFilterLoad, baseFilterLoadEncoded, pver, BaseEncoding, 13,
io.ErrShortWrite, io.EOF,
},
// Force error due to unsupported protocol version.
{
baseFilterLoad, baseFilterLoadEncoded, pverNoFilterLoad,
baseFilterLoad, baseFilterLoadEncoded, pverNoFilterLoad, BaseEncoding,
10, wireErr, wireErr,
},
}
@ -184,7 +186,7 @@ func TestFilterLoadWireErrors(t *testing.T) {
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -204,7 +206,7 @@ func TestFilterLoadWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgFilterLoad
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msggetaddr.go
View file

@ -18,13 +18,13 @@ type MsgGetAddr struct{}
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgGetAddr) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgGetAddr) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
return nil
}
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgGetAddr) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgGetAddr) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
return nil
}

18
wire/msggetaddr_test.go
View file

@ -42,10 +42,11 @@ func TestGetAddrWire(t *testing.T) {
msgGetAddrEncoded := []byte{}
tests := []struct {
in *MsgGetAddr // Message to encode
out *MsgGetAddr // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgGetAddr // Message to encode
out *MsgGetAddr // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding variant.
}{
// Latest protocol version.
{
@ -53,6 +54,7 @@ func TestGetAddrWire(t *testing.T) {
msgGetAddr,
msgGetAddrEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version.
@ -61,6 +63,7 @@ func TestGetAddrWire(t *testing.T) {
msgGetAddr,
msgGetAddrEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version.
@ -69,6 +72,7 @@ func TestGetAddrWire(t *testing.T) {
msgGetAddr,
msgGetAddrEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion.
@ -77,6 +81,7 @@ func TestGetAddrWire(t *testing.T) {
msgGetAddr,
msgGetAddrEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion.
@ -85,6 +90,7 @@ func TestGetAddrWire(t *testing.T) {
msgGetAddr,
msgGetAddrEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -92,7 +98,7 @@ func TestGetAddrWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -106,7 +112,7 @@ func TestGetAddrWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgGetAddr
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue

4
wire/msggetblocks.go
View file

@ -50,7 +50,7 @@ func (msg *MsgGetBlocks) AddBlockLocatorHash(hash *chainhash.Hash) error {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgGetBlocks) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgGetBlocks) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
err := readElement(r, &msg.ProtocolVersion)
if err != nil {
return err
@ -85,7 +85,7 @@ func (msg *MsgGetBlocks) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgGetBlocks) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgGetBlocks) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
count := len(msg.BlockLocatorHashes)
if count > MaxBlockLocatorsPerMsg {
str := fmt.Sprintf("too many block locator hashes for message "+

50
wire/msggetblocks_test.go
View file

@ -142,10 +142,11 @@ func TestGetBlocksWire(t *testing.T) {
}
tests := []struct {
in *MsgGetBlocks // Message to encode
out *MsgGetBlocks // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgGetBlocks // Message to encode
out *MsgGetBlocks // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version with no block locators.
{
@ -153,6 +154,7 @@ func TestGetBlocksWire(t *testing.T) {
noLocators,
noLocatorsEncoded,
ProtocolVersion,
BaseEncoding,
},
// Latest protocol version with multiple block locators.
@ -161,6 +163,7 @@ func TestGetBlocksWire(t *testing.T) {
multiLocators,
multiLocatorsEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version with no block locators.
@ -169,6 +172,7 @@ func TestGetBlocksWire(t *testing.T) {
noLocators,
noLocatorsEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0035Version with multiple block locators.
@ -177,6 +181,7 @@ func TestGetBlocksWire(t *testing.T) {
multiLocators,
multiLocatorsEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version with no block locators.
@ -185,6 +190,7 @@ func TestGetBlocksWire(t *testing.T) {
noLocators,
noLocatorsEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version BIP0031Versionwith multiple block locators.
@ -193,6 +199,7 @@ func TestGetBlocksWire(t *testing.T) {
multiLocators,
multiLocatorsEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion with no block locators.
@ -201,6 +208,7 @@ func TestGetBlocksWire(t *testing.T) {
noLocators,
noLocatorsEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion multiple block locators.
@ -209,6 +217,7 @@ func TestGetBlocksWire(t *testing.T) {
multiLocators,
multiLocatorsEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion with no block locators.
@ -217,6 +226,7 @@ func TestGetBlocksWire(t *testing.T) {
noLocators,
noLocatorsEncoded,
MultipleAddressVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion multiple block locators.
@ -225,6 +235,7 @@ func TestGetBlocksWire(t *testing.T) {
multiLocators,
multiLocatorsEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -232,7 +243,7 @@ func TestGetBlocksWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -246,7 +257,7 @@ func TestGetBlocksWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgGetBlocks
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -325,30 +336,31 @@ func TestGetBlocksWireErrors(t *testing.T) {
}
tests := []struct {
in *MsgGetBlocks // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgGetBlocks // 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.
{baseGetBlocks, baseGetBlocksEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{baseGetBlocks, baseGetBlocksEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in block locator hash count.
{baseGetBlocks, baseGetBlocksEncoded, pver, 4, io.ErrShortWrite, io.EOF},
{baseGetBlocks, baseGetBlocksEncoded, pver, BaseEncoding, 4, io.ErrShortWrite, io.EOF},
// Force error in block locator hashes.
{baseGetBlocks, baseGetBlocksEncoded, pver, 5, io.ErrShortWrite, io.EOF},
{baseGetBlocks, baseGetBlocksEncoded, pver, BaseEncoding, 5, io.ErrShortWrite, io.EOF},
// Force error in stop hash.
{baseGetBlocks, baseGetBlocksEncoded, pver, 69, io.ErrShortWrite, io.EOF},
{baseGetBlocks, baseGetBlocksEncoded, pver, BaseEncoding, 69, io.ErrShortWrite, io.EOF},
// Force error with greater than max block locator hashes.
{maxGetBlocks, maxGetBlocksEncoded, pver, 7, wireErr, wireErr},
{maxGetBlocks, maxGetBlocksEncoded, pver, BaseEncoding, 7, wireErr, wireErr},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -368,7 +380,7 @@ func TestGetBlocksWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgGetBlocks
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msggetdata.go
View file

@ -37,7 +37,7 @@ func (msg *MsgGetData) AddInvVect(iv *InvVect) error {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgGetData) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgGetData) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
count, err := ReadVarInt(r, pver)
if err != nil {
return err
@ -67,7 +67,7 @@ func (msg *MsgGetData) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgGetData) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgGetData) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
// Limit to max inventory vectors per message.
count := len(msg.InvList)
if count > MaxInvPerMsg {

46
wire/msggetdata_test.go
View file

@ -113,10 +113,11 @@ func TestGetDataWire(t *testing.T) {
}
tests := []struct {
in *MsgGetData // Message to encode
out *MsgGetData // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgGetData // Message to encode
out *MsgGetData // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version with no inv vectors.
{
@ -124,6 +125,7 @@ func TestGetDataWire(t *testing.T) {
NoInv,
NoInvEncoded,
ProtocolVersion,
BaseEncoding,
},
// Latest protocol version with multiple inv vectors.
@ -132,6 +134,7 @@ func TestGetDataWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version no inv vectors.
@ -140,6 +143,7 @@ func TestGetDataWire(t *testing.T) {
NoInv,
NoInvEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0035Version with multiple inv vectors.
@ -148,6 +152,7 @@ func TestGetDataWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version no inv vectors.
@ -156,6 +161,7 @@ func TestGetDataWire(t *testing.T) {
NoInv,
NoInvEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version BIP0031Version with multiple inv vectors.
@ -164,6 +170,7 @@ func TestGetDataWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion no inv vectors.
@ -172,6 +179,7 @@ func TestGetDataWire(t *testing.T) {
NoInv,
NoInvEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion with multiple inv vectors.
@ -180,6 +188,7 @@ func TestGetDataWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion no inv vectors.
@ -188,6 +197,7 @@ func TestGetDataWire(t *testing.T) {
NoInv,
NoInvEncoded,
MultipleAddressVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion with multiple inv vectors.
@ -196,6 +206,7 @@ func TestGetDataWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -203,7 +214,7 @@ func TestGetDataWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -217,7 +228,7 @@ func TestGetDataWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgGetData
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -269,27 +280,28 @@ func TestGetDataWireErrors(t *testing.T) {
}
tests := []struct {
in *MsgGetData // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgGetData // 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
}{
// Latest protocol version with intentional read/write errors.
// Force error in inventory vector count
{baseGetData, baseGetDataEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{baseGetData, baseGetDataEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in inventory list.
{baseGetData, baseGetDataEncoded, pver, 1, io.ErrShortWrite, io.EOF},
{baseGetData, baseGetDataEncoded, pver, BaseEncoding, 1, io.ErrShortWrite, io.EOF},
// Force error with greater than max inventory vectors.
{maxGetData, maxGetDataEncoded, pver, 3, wireErr, wireErr},
{maxGetData, maxGetDataEncoded, pver, BaseEncoding, 3, wireErr, wireErr},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -309,7 +321,7 @@ func TestGetDataWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgGetData
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msggetheaders.go
View file

@ -47,7 +47,7 @@ func (msg *MsgGetHeaders) AddBlockLocatorHash(hash *chainhash.Hash) error {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgGetHeaders) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgGetHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
err := readElement(r, &msg.ProtocolVersion)
if err != nil {
return err
@ -82,7 +82,7 @@ func (msg *MsgGetHeaders) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgGetHeaders) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgGetHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
// Limit to max block locator hashes per message.
count := len(msg.BlockLocatorHashes)
if count > MaxBlockLocatorsPerMsg {

50
wire/msggetheaders_test.go
View file

@ -132,10 +132,11 @@ func TestGetHeadersWire(t *testing.T) {
}
tests := []struct {
in *MsgGetHeaders // Message to encode
out *MsgGetHeaders // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgGetHeaders // Message to encode
out *MsgGetHeaders // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version with no block locators.
{
@ -143,6 +144,7 @@ func TestGetHeadersWire(t *testing.T) {
noLocators,
noLocatorsEncoded,
ProtocolVersion,
BaseEncoding,
},
// Latest protocol version with multiple block locators.
@ -151,6 +153,7 @@ func TestGetHeadersWire(t *testing.T) {
multiLocators,
multiLocatorsEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version with no block locators.
@ -159,6 +162,7 @@ func TestGetHeadersWire(t *testing.T) {
noLocators,
noLocatorsEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0035Version with multiple block locators.
@ -167,6 +171,7 @@ func TestGetHeadersWire(t *testing.T) {
multiLocators,
multiLocatorsEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version with no block locators.
@ -175,6 +180,7 @@ func TestGetHeadersWire(t *testing.T) {
noLocators,
noLocatorsEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version BIP0031Versionwith multiple block locators.
@ -183,6 +189,7 @@ func TestGetHeadersWire(t *testing.T) {
multiLocators,
multiLocatorsEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion with no block locators.
@ -191,6 +198,7 @@ func TestGetHeadersWire(t *testing.T) {
noLocators,
noLocatorsEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion multiple block locators.
@ -199,6 +207,7 @@ func TestGetHeadersWire(t *testing.T) {
multiLocators,
multiLocatorsEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion with no block locators.
@ -207,6 +216,7 @@ func TestGetHeadersWire(t *testing.T) {
noLocators,
noLocatorsEncoded,
MultipleAddressVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion multiple block locators.
@ -215,6 +225,7 @@ func TestGetHeadersWire(t *testing.T) {
multiLocators,
multiLocatorsEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -222,7 +233,7 @@ func TestGetHeadersWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -236,7 +247,7 @@ func TestGetHeadersWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgGetHeaders
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -316,30 +327,31 @@ func TestGetHeadersWireErrors(t *testing.T) {
}
tests := []struct {
in *MsgGetHeaders // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgGetHeaders // 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.
{baseGetHeaders, baseGetHeadersEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{baseGetHeaders, baseGetHeadersEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in block locator hash count.
{baseGetHeaders, baseGetHeadersEncoded, pver, 4, io.ErrShortWrite, io.EOF},
{baseGetHeaders, baseGetHeadersEncoded, pver, BaseEncoding, 4, io.ErrShortWrite, io.EOF},
// Force error in block locator hashes.
{baseGetHeaders, baseGetHeadersEncoded, pver, 5, io.ErrShortWrite, io.EOF},
{baseGetHeaders, baseGetHeadersEncoded, pver, BaseEncoding, 5, io.ErrShortWrite, io.EOF},
// Force error in stop hash.
{baseGetHeaders, baseGetHeadersEncoded, pver, 69, io.ErrShortWrite, io.EOF},
{baseGetHeaders, baseGetHeadersEncoded, pver, BaseEncoding, 69, io.ErrShortWrite, io.EOF},
// Force error with greater than max block locator hashes.
{maxGetHeaders, maxGetHeadersEncoded, pver, 7, wireErr, wireErr},
{maxGetHeaders, maxGetHeadersEncoded, pver, BaseEncoding, 7, wireErr, wireErr},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -359,7 +371,7 @@ func TestGetHeadersWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgGetHeaders
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msgheaders.go
View file

@ -36,7 +36,7 @@ func (msg *MsgHeaders) AddBlockHeader(bh *BlockHeader) error {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgHeaders) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
count, err := ReadVarInt(r, pver)
if err != nil {
return err
@ -79,7 +79,7 @@ func (msg *MsgHeaders) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgHeaders) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
// Limit to max block headers per message.
count := len(msg.Headers)
if count > MaxBlockHeadersPerMsg {

50
wire/msgheaders_test.go
View file

@ -95,10 +95,11 @@ func TestHeadersWire(t *testing.T) {
}
tests := []struct {
in *MsgHeaders // Message to encode
out *MsgHeaders // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgHeaders // Message to encode
out *MsgHeaders // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version with no headers.
{
@ -106,6 +107,7 @@ func TestHeadersWire(t *testing.T) {
noHeaders,
noHeadersEncoded,
ProtocolVersion,
BaseEncoding,
},
// Latest protocol version with one header.
@ -114,6 +116,7 @@ func TestHeadersWire(t *testing.T) {
oneHeader,
oneHeaderEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version with no headers.
@ -122,6 +125,7 @@ func TestHeadersWire(t *testing.T) {
noHeaders,
noHeadersEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0035Version with one header.
@ -130,6 +134,7 @@ func TestHeadersWire(t *testing.T) {
oneHeader,
oneHeaderEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version with no headers.
@ -138,6 +143,7 @@ func TestHeadersWire(t *testing.T) {
noHeaders,
noHeadersEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version BIP0031Version with one header.
@ -146,6 +152,7 @@ func TestHeadersWire(t *testing.T) {
oneHeader,
oneHeaderEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion with no headers.
{
@ -153,6 +160,7 @@ func TestHeadersWire(t *testing.T) {
noHeaders,
noHeadersEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion with one header.
@ -161,6 +169,7 @@ func TestHeadersWire(t *testing.T) {
oneHeader,
oneHeaderEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion with no headers.
@ -169,6 +178,7 @@ func TestHeadersWire(t *testing.T) {
noHeaders,
noHeadersEncoded,
MultipleAddressVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion with one header.
@ -177,6 +187,7 @@ func TestHeadersWire(t *testing.T) {
oneHeader,
oneHeaderEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -184,7 +195,7 @@ func TestHeadersWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -198,7 +209,7 @@ func TestHeadersWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgHeaders
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -282,31 +293,32 @@ func TestHeadersWireErrors(t *testing.T) {
}
tests := []struct {
in *MsgHeaders // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgHeaders // 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
}{
// Latest protocol version with intentional read/write errors.
// Force error in header count.
{oneHeader, oneHeaderEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{oneHeader, oneHeaderEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in block header.
{oneHeader, oneHeaderEncoded, pver, 5, io.ErrShortWrite, io.EOF},
{oneHeader, oneHeaderEncoded, pver, BaseEncoding, 5, io.ErrShortWrite, io.EOF},
// Force error with greater than max headers.
{maxHeaders, maxHeadersEncoded, pver, 3, wireErr, wireErr},
{maxHeaders, maxHeadersEncoded, pver, BaseEncoding, 3, wireErr, wireErr},
// Force error with number of transactions.
{transHeader, transHeaderEncoded, pver, 81, io.ErrShortWrite, io.EOF},
{transHeader, transHeaderEncoded, pver, BaseEncoding, 81, io.ErrShortWrite, io.EOF},
// Force error with included transactions.
{transHeader, transHeaderEncoded, pver, len(transHeaderEncoded), nil, wireErr},
{transHeader, transHeaderEncoded, pver, BaseEncoding, len(transHeaderEncoded), nil, wireErr},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -326,7 +338,7 @@ func TestHeadersWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgHeaders
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msginv.go
View file

@ -45,7 +45,7 @@ func (msg *MsgInv) AddInvVect(iv *InvVect) error {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgInv) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgInv) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
count, err := ReadVarInt(r, pver)
if err != nil {
return err
@ -75,7 +75,7 @@ func (msg *MsgInv) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgInv) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgInv) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
// Limit to max inventory vectors per message.
count := len(msg.InvList)
if count > MaxInvPerMsg {

46
wire/msginv_test.go
View file

@ -113,10 +113,11 @@ func TestInvWire(t *testing.T) {
}
tests := []struct {
in *MsgInv // Message to encode
out *MsgInv // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgInv // Message to encode
out *MsgInv // Expected decoded message
buf []byte // Wire encoding pver uint32
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encodinf format
}{
// Latest protocol version with no inv vectors.
{
@ -124,6 +125,7 @@ func TestInvWire(t *testing.T) {
NoInv,
NoInvEncoded,
ProtocolVersion,
BaseEncoding,
},
// Latest protocol version with multiple inv vectors.
@ -132,6 +134,7 @@ func TestInvWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version no inv vectors.
@ -140,6 +143,7 @@ func TestInvWire(t *testing.T) {
NoInv,
NoInvEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0035Version with multiple inv vectors.
@ -148,6 +152,7 @@ func TestInvWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version no inv vectors.
@ -156,6 +161,7 @@ func TestInvWire(t *testing.T) {
NoInv,
NoInvEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version BIP0031Version with multiple inv vectors.
@ -164,6 +170,7 @@ func TestInvWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion no inv vectors.
@ -172,6 +179,7 @@ func TestInvWire(t *testing.T) {
NoInv,
NoInvEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion with multiple inv vectors.
@ -180,6 +188,7 @@ func TestInvWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion no inv vectors.
@ -188,6 +197,7 @@ func TestInvWire(t *testing.T) {
NoInv,
NoInvEncoded,
MultipleAddressVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion with multiple inv vectors.
@ -196,6 +206,7 @@ func TestInvWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -203,7 +214,7 @@ func TestInvWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -217,7 +228,7 @@ func TestInvWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgInv
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -269,27 +280,28 @@ func TestInvWireErrors(t *testing.T) {
}
tests := []struct {
in *MsgInv // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgInv // 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
}{
// Latest protocol version with intentional read/write errors.
// Force error in inventory vector count
{baseInv, baseInvEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{baseInv, baseInvEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in inventory list.
{baseInv, baseInvEncoded, pver, 1, io.ErrShortWrite, io.EOF},
{baseInv, baseInvEncoded, pver, BaseEncoding, 1, io.ErrShortWrite, io.EOF},
// Force error with greater than max inventory vectors.
{maxInv, maxInvEncoded, pver, 3, wireErr, wireErr},
{maxInv, maxInvEncoded, pver, BaseEncoding, 3, wireErr, wireErr},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -309,7 +321,7 @@ func TestInvWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgInv
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msgmempool.go
View file

@ -19,7 +19,7 @@ type MsgMemPool struct{}
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgMemPool) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgMemPool) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
if pver < BIP0035Version {
str := fmt.Sprintf("mempool message invalid for protocol "+
"version %d", pver)
@ -31,7 +31,7 @@ func (msg *MsgMemPool) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgMemPool) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgMemPool) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
if pver < BIP0035Version {
str := fmt.Sprintf("mempool message invalid for protocol "+
"version %d", pver)

9
wire/msgmempool_test.go
View file

@ -11,6 +11,7 @@ import (
func TestMemPool(t *testing.T) {
pver := ProtocolVersion
enc := BaseEncoding
// Ensure the command is expected value.
wantCmd := "mempool"
@ -31,7 +32,7 @@ func TestMemPool(t *testing.T) {
// Test encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, pver)
err := msg.BtcEncode(&buf, pver, enc)
if err != nil {
t.Errorf("encode of MsgMemPool failed %v err <%v>", msg, err)
}
@ -39,7 +40,7 @@ func TestMemPool(t *testing.T) {
// Older protocol versions should fail encode since message didn't
// exist yet.
oldPver := BIP0035Version - 1
err = msg.BtcEncode(&buf, oldPver)
err = msg.BtcEncode(&buf, oldPver, enc)
if err == nil {
s := "encode of MsgMemPool passed for old protocol version %v err <%v>"
t.Errorf(s, msg, err)
@ -47,14 +48,14 @@ func TestMemPool(t *testing.T) {
// Test decode with latest protocol version.
readmsg := NewMsgMemPool()
err = readmsg.BtcDecode(&buf, pver)
err = readmsg.BtcDecode(&buf, pver, enc)
if err != nil {
t.Errorf("decode of MsgMemPool failed [%v] err <%v>", buf, err)
}
// Older protocol versions should fail decode since message didn't
// exist yet.
err = readmsg.BtcDecode(&buf, oldPver)
err = readmsg.BtcDecode(&buf, oldPver, enc)
if err == nil {
s := "decode of MsgMemPool passed for old protocol version %v err <%v>"
t.Errorf(s, msg, err)

4
wire/msgmerkleblock.go
View file

@ -42,7 +42,7 @@ func (msg *MsgMerkleBlock) AddTxHash(hash *chainhash.Hash) error {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgMerkleBlock) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgMerkleBlock) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
if pver < BIP0037Version {
str := fmt.Sprintf("merkleblock message invalid for protocol "+
"version %d", pver)
@ -90,7 +90,7 @@ func (msg *MsgMerkleBlock) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgMerkleBlock) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgMerkleBlock) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
if pver < BIP0037Version {
str := fmt.Sprintf("merkleblock message invalid for protocol "+
"version %d", pver)

66
wire/msgmerkleblock_test.go
View file

@ -19,6 +19,7 @@ import (
// TestMerkleBlock tests the MsgMerkleBlock API.
func TestMerkleBlock(t *testing.T) {
pver := ProtocolVersion
enc := BaseEncoding
// Block 1 header.
prevHash := &blockOne.Header.PrevBlock
@ -37,7 +38,7 @@ func TestMerkleBlock(t *testing.T) {
// Ensure max payload is expected value for latest protocol version.
// Num addresses (varInt) + max allowed addresses.
wantPayload := uint32(1000000)
wantPayload := uint32(4000000)
maxPayload := msg.MaxPayloadLength(pver)
if maxPayload != wantPayload {
t.Errorf("MaxPayloadLength: wrong max payload length for "+
@ -76,21 +77,21 @@ func TestMerkleBlock(t *testing.T) {
// Test encode with latest protocol version.
var buf bytes.Buffer
err = msg.BtcEncode(&buf, pver)
err = msg.BtcEncode(&buf, pver, enc)
if err != nil {
t.Errorf("encode of MsgMerkleBlock failed %v err <%v>", msg, err)
}
// Test decode with latest protocol version.
readmsg := MsgMerkleBlock{}
err = readmsg.BtcDecode(&buf, pver)
err = readmsg.BtcDecode(&buf, pver, enc)
if err != nil {
t.Errorf("decode of MsgMerkleBlock failed [%v] err <%v>", buf, err)
}
// Force extra hash to test maxTxPerBlock.
msg.Hashes = append(msg.Hashes, hash)
err = msg.BtcEncode(&buf, pver)
err = msg.BtcEncode(&buf, pver, enc)
if err == nil {
t.Errorf("encode of MsgMerkleBlock succeeded with too many " +
"tx hashes when it should have failed")
@ -101,7 +102,7 @@ func TestMerkleBlock(t *testing.T) {
// Reset the number of hashes back to a valid value.
msg.Hashes = msg.Hashes[len(msg.Hashes)-1:]
msg.Flags = make([]byte, maxFlagsPerMerkleBlock+1)
err = msg.BtcEncode(&buf, pver)
err = msg.BtcEncode(&buf, pver, enc)
if err == nil {
t.Errorf("encode of MsgMerkleBlock succeeded with too many " +
"flag bytes when it should have failed")
@ -123,7 +124,7 @@ func TestMerkleBlockCrossProtocol(t *testing.T) {
// Encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, ProtocolVersion)
err := msg.BtcEncode(&buf, ProtocolVersion, BaseEncoding)
if err != nil {
t.Errorf("encode of NewMsgFilterLoad failed %v err <%v>", msg,
err)
@ -131,7 +132,7 @@ func TestMerkleBlockCrossProtocol(t *testing.T) {
// Decode with old protocol version.
var readmsg MsgFilterLoad
err = readmsg.BtcDecode(&buf, BIP0031Version)
err = readmsg.BtcDecode(&buf, BIP0031Version, BaseEncoding)
if err == nil {
t.Errorf("decode of MsgFilterLoad succeeded when it shouldn't have %v",
msg)
@ -146,17 +147,18 @@ func TestMerkleBlockWire(t *testing.T) {
out *MsgMerkleBlock // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version.
{
&merkleBlockOne, &merkleBlockOne, merkleBlockOneBytes,
ProtocolVersion,
ProtocolVersion, BaseEncoding,
},
// Protocol version BIP0037Version.
{
&merkleBlockOne, &merkleBlockOne, merkleBlockOneBytes,
BIP0037Version,
BIP0037Version, BaseEncoding,
},
}
@ -164,7 +166,7 @@ func TestMerkleBlockWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -178,7 +180,7 @@ func TestMerkleBlockWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgMerkleBlock
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -205,69 +207,70 @@ func TestMerkleBlockWireErrors(t *testing.T) {
in *MsgMerkleBlock // 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 version.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 0,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 0,
io.ErrShortWrite, io.EOF,
},
// Force error in prev block hash.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 4,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 4,
io.ErrShortWrite, io.EOF,
},
// Force error in merkle root.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 36,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 36,
io.ErrShortWrite, io.EOF,
},
// Force error in timestamp.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 68,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 68,
io.ErrShortWrite, io.EOF,
},
// Force error in difficulty bits.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 72,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 72,
io.ErrShortWrite, io.EOF,
},
// Force error in header nonce.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 76,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 76,
io.ErrShortWrite, io.EOF,
},
// Force error in transaction count.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 80,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 80,
io.ErrShortWrite, io.EOF,
},
// Force error in num hashes.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 84,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 84,
io.ErrShortWrite, io.EOF,
},
// Force error in hashes.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 85,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 85,
io.ErrShortWrite, io.EOF,
},
// Force error in num flag bytes.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 117,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 117,
io.ErrShortWrite, io.EOF,
},
// Force error in flag bytes.
{
&merkleBlockOne, merkleBlockOneBytes, pver, 118,
&merkleBlockOne, merkleBlockOneBytes, pver, BaseEncoding, 118,
io.ErrShortWrite, io.EOF,
},
// Force error due to unsupported protocol version.
{
&merkleBlockOne, merkleBlockOneBytes, pverNoMerkleBlock,
119, wireErr, wireErr,
BaseEncoding, 119, wireErr, wireErr,
},
}
@ -275,7 +278,7 @@ func TestMerkleBlockWireErrors(t *testing.T) {
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -295,7 +298,7 @@ func TestMerkleBlockWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgMerkleBlock
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)
@ -343,14 +346,15 @@ func TestMerkleBlockOverflowErrors(t *testing.T) {
exceedMaxFlagBytes = append(exceedMaxFlagBytes, buf.Bytes()...)
tests := []struct {
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
err error // Expected error
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
err error // Expected error
}{
// Block that claims to have more than max allowed hashes.
{exceedMaxHashes, pver, &MessageError{}},
{exceedMaxHashes, pver, BaseEncoding, &MessageError{}},
// Block that claims to have more than max allowed flag bytes.
{exceedMaxFlagBytes, pver, &MessageError{}},
{exceedMaxFlagBytes, pver, BaseEncoding, &MessageError{}},
}
t.Logf("Running %d tests", len(tests))
@ -358,7 +362,7 @@ func TestMerkleBlockOverflowErrors(t *testing.T) {
// Decode from wire format.
var msg MsgMerkleBlock
r := bytes.NewReader(test.buf)
err := msg.BtcDecode(r, test.pver)
err := msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, reflect.TypeOf(test.err))

4
wire/msgnotfound.go
View file

@ -34,7 +34,7 @@ func (msg *MsgNotFound) AddInvVect(iv *InvVect) error {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgNotFound) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgNotFound) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
count, err := ReadVarInt(r, pver)
if err != nil {
return err
@ -64,7 +64,7 @@ func (msg *MsgNotFound) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgNotFound) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgNotFound) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
// Limit to max inventory vectors per message.
count := len(msg.InvList)
if count > MaxInvPerMsg {

46
wire/msgnotfound_test.go
View file

@ -104,10 +104,11 @@ func TestNotFoundWire(t *testing.T) {
}
tests := []struct {
in *MsgNotFound // Message to encode
out *MsgNotFound // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgNotFound // Message to encode
out *MsgNotFound // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version with no inv vectors.
{
@ -115,6 +116,7 @@ func TestNotFoundWire(t *testing.T) {
NoInv,
NoInvEncoded,
ProtocolVersion,
BaseEncoding,
},
// Latest protocol version with multiple inv vectors.
@ -123,6 +125,7 @@ func TestNotFoundWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version no inv vectors.
@ -131,6 +134,7 @@ func TestNotFoundWire(t *testing.T) {
NoInv,
NoInvEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0035Version with multiple inv vectors.
@ -139,6 +143,7 @@ func TestNotFoundWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version no inv vectors.
@ -147,6 +152,7 @@ func TestNotFoundWire(t *testing.T) {
NoInv,
NoInvEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version BIP0031Version with multiple inv vectors.
@ -155,6 +161,7 @@ func TestNotFoundWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion no inv vectors.
@ -163,6 +170,7 @@ func TestNotFoundWire(t *testing.T) {
NoInv,
NoInvEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion with multiple inv vectors.
@ -171,6 +179,7 @@ func TestNotFoundWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion no inv vectors.
@ -179,6 +188,7 @@ func TestNotFoundWire(t *testing.T) {
NoInv,
NoInvEncoded,
MultipleAddressVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion with multiple inv vectors.
@ -187,6 +197,7 @@ func TestNotFoundWire(t *testing.T) {
MultiInv,
MultiInvEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -194,7 +205,7 @@ func TestNotFoundWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -208,7 +219,7 @@ func TestNotFoundWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgNotFound
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -260,26 +271,27 @@ func TestNotFoundWireErrors(t *testing.T) {
}
tests := []struct {
in *MsgNotFound // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgNotFound // 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 inventory vector count
{baseNotFound, baseNotFoundEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{baseNotFound, baseNotFoundEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in inventory list.
{baseNotFound, baseNotFoundEncoded, pver, 1, io.ErrShortWrite, io.EOF},
{baseNotFound, baseNotFoundEncoded, pver, BaseEncoding, 1, io.ErrShortWrite, io.EOF},
// Force error with greater than max inventory vectors.
{maxNotFound, maxNotFoundEncoded, pver, 3, wireErr, wireErr},
{maxNotFound, maxNotFoundEncoded, pver, BaseEncoding, 3, wireErr, wireErr},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -299,7 +311,7 @@ func TestNotFoundWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgNotFound
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msgping.go
View file

@ -27,7 +27,7 @@ type MsgPing struct {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgPing) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgPing) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
// There was no nonce for BIP0031Version and earlier.
// NOTE: > is not a mistake here. The BIP0031 was defined as AFTER
// the version unlike most others.
@ -43,7 +43,7 @@ func (msg *MsgPing) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgPing) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgPing) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
// There was no nonce for BIP0031Version and earlier.
// NOTE: > is not a mistake here. The BIP0031 was defined as AFTER
// the version unlike most others.

43
wire/msgping_test.go
View file

@ -50,6 +50,7 @@ func TestPing(t *testing.T) {
func TestPingBIP0031(t *testing.T) {
// Use the protocol version just prior to BIP0031Version changes.
pver := BIP0031Version
enc := BaseEncoding
nonce, err := RandomUint64()
if err != nil {
@ -72,14 +73,14 @@ func TestPingBIP0031(t *testing.T) {
// Test encode with old protocol version.
var buf bytes.Buffer
err = msg.BtcEncode(&buf, pver)
err = msg.BtcEncode(&buf, pver, enc)
if err != nil {
t.Errorf("encode of MsgPing failed %v err <%v>", msg, err)
}
// Test decode with old protocol version.
readmsg := NewMsgPing(0)
err = readmsg.BtcDecode(&buf, pver)
err = readmsg.BtcDecode(&buf, pver, enc)
if err != nil {
t.Errorf("decode of MsgPing failed [%v] err <%v>", buf, err)
}
@ -106,14 +107,14 @@ func TestPingCrossProtocol(t *testing.T) {
// Encode with latest protocol version.
var buf bytes.Buffer
err = msg.BtcEncode(&buf, ProtocolVersion)
err = msg.BtcEncode(&buf, ProtocolVersion, BaseEncoding)
if err != nil {
t.Errorf("encode of MsgPing failed %v err <%v>", msg, err)
}
// Decode with old protocol version.
readmsg := NewMsgPing(0)
err = readmsg.BtcDecode(&buf, BIP0031Version)
err = readmsg.BtcDecode(&buf, BIP0031Version, BaseEncoding)
if err != nil {
t.Errorf("decode of MsgPing failed [%v] err <%v>", buf, err)
}
@ -129,10 +130,11 @@ func TestPingCrossProtocol(t *testing.T) {
// versions.
func TestPingWire(t *testing.T) {
tests := []struct {
in MsgPing // Message to encode
out MsgPing // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in MsgPing // Message to encode
out MsgPing // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version.
{
@ -140,6 +142,7 @@ func TestPingWire(t *testing.T) {
MsgPing{Nonce: 123123}, // 0x1e0f3
[]byte{0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0031Version+1
@ -148,6 +151,7 @@ func TestPingWire(t *testing.T) {
MsgPing{Nonce: 456456}, // 0x6f708
[]byte{0x08, 0xf7, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00},
BIP0031Version + 1,
BaseEncoding,
},
// Protocol version BIP0031Version
@ -156,6 +160,7 @@ func TestPingWire(t *testing.T) {
MsgPing{Nonce: 0}, // No nonce for pver
[]byte{}, // No nonce for pver
BIP0031Version,
BaseEncoding,
},
}
@ -163,7 +168,7 @@ func TestPingWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -177,7 +182,7 @@ func TestPingWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgPing
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -196,18 +201,20 @@ func TestPingWireErrors(t *testing.T) {
pver := ProtocolVersion
tests := []struct {
in *MsgPing // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgPing // 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
}{
// Latest protocol version with intentional read/write errors.
{
&MsgPing{Nonce: 123123}, // 0x1e0f3
[]byte{0xf3, 0xe0, 0x01, 0x00},
pver,
BaseEncoding,
2,
io.ErrShortWrite,
io.ErrUnexpectedEOF,
@ -218,7 +225,7 @@ func TestPingWireErrors(t *testing.T) {
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := test.in.BtcEncode(w, test.pver, test.enc)
if err != test.writeErr {
t.Errorf("BtcEncode #%d wrong error got: %v, want: %v",
i, err, test.writeErr)
@ -228,7 +235,7 @@ func TestPingWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgPing
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if err != test.readErr {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msgpong.go
View file

@ -22,7 +22,7 @@ type MsgPong struct {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgPong) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgPong) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
// NOTE: <= is not a mistake here. The BIP0031 was defined as AFTER
// the version unlike most others.
if pver <= BIP0031Version {
@ -36,7 +36,7 @@ func (msg *MsgPong) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgPong) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgPong) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
// NOTE: <= is not a mistake here. The BIP0031 was defined as AFTER
// the version unlike most others.
if pver <= BIP0031Version {

50
wire/msgpong_test.go
View file

@ -15,6 +15,7 @@ import (
// TestPongLatest tests the MsgPong API against the latest protocol version.
func TestPongLatest(t *testing.T) {
enc := BaseEncoding
pver := ProtocolVersion
nonce, err := RandomUint64()
@ -45,14 +46,14 @@ func TestPongLatest(t *testing.T) {
// Test encode with latest protocol version.
var buf bytes.Buffer
err = msg.BtcEncode(&buf, pver)
err = msg.BtcEncode(&buf, pver, enc)
if err != nil {
t.Errorf("encode of MsgPong failed %v err <%v>", msg, err)
}
// Test decode with latest protocol version.
readmsg := NewMsgPong(0)
err = readmsg.BtcDecode(&buf, pver)
err = readmsg.BtcDecode(&buf, pver, enc)
if err != nil {
t.Errorf("decode of MsgPong failed [%v] err <%v>", buf, err)
}
@ -68,6 +69,7 @@ func TestPongLatest(t *testing.T) {
func TestPongBIP0031(t *testing.T) {
// Use the protocol version just prior to BIP0031Version changes.
pver := BIP0031Version
enc := BaseEncoding
nonce, err := RandomUint64()
if err != nil {
@ -87,7 +89,7 @@ func TestPongBIP0031(t *testing.T) {
// Test encode with old protocol version.
var buf bytes.Buffer
err = msg.BtcEncode(&buf, pver)
err = msg.BtcEncode(&buf, pver, enc)
if err == nil {
t.Errorf("encode of MsgPong succeeded when it shouldn't have %v",
msg)
@ -95,7 +97,7 @@ func TestPongBIP0031(t *testing.T) {
// Test decode with old protocol version.
readmsg := NewMsgPong(0)
err = readmsg.BtcDecode(&buf, pver)
err = readmsg.BtcDecode(&buf, pver, enc)
if err == nil {
t.Errorf("decode of MsgPong succeeded when it shouldn't have %v",
spew.Sdump(buf))
@ -122,14 +124,14 @@ func TestPongCrossProtocol(t *testing.T) {
// Encode with latest protocol version.
var buf bytes.Buffer
err = msg.BtcEncode(&buf, ProtocolVersion)
err = msg.BtcEncode(&buf, ProtocolVersion, BaseEncoding)
if err != nil {
t.Errorf("encode of MsgPong failed %v err <%v>", msg, err)
}
// Decode with old protocol version.
readmsg := NewMsgPong(0)
err = readmsg.BtcDecode(&buf, BIP0031Version)
err = readmsg.BtcDecode(&buf, BIP0031Version, BaseEncoding)
if err == nil {
t.Errorf("encode of MsgPong succeeded when it shouldn't have %v",
msg)
@ -146,10 +148,11 @@ func TestPongCrossProtocol(t *testing.T) {
// versions.
func TestPongWire(t *testing.T) {
tests := []struct {
in MsgPong // Message to encode
out MsgPong // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in MsgPong // Message to encode
out MsgPong // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version.
{
@ -157,6 +160,7 @@ func TestPongWire(t *testing.T) {
MsgPong{Nonce: 123123}, // 0x1e0f3
[]byte{0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0031Version+1
@ -165,6 +169,7 @@ func TestPongWire(t *testing.T) {
MsgPong{Nonce: 456456}, // 0x6f708
[]byte{0x08, 0xf7, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00},
BIP0031Version + 1,
BaseEncoding,
},
}
@ -172,7 +177,7 @@ func TestPongWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -186,7 +191,7 @@ func TestPongWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgPong
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -212,25 +217,26 @@ func TestPongWireErrors(t *testing.T) {
}
tests := []struct {
in *MsgPong // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgPong // 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
}{
// Latest protocol version with intentional read/write errors.
// Force error in nonce.
{basePong, basePongEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{basePong, basePongEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error due to unsupported protocol version.
{basePong, basePongEncoded, pverNoPong, 4, wireErr, wireErr},
{basePong, basePongEncoded, pverNoPong, BaseEncoding, 4, wireErr, wireErr},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -250,7 +256,7 @@ func TestPongWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgPong
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msgreject.go
View file

@ -73,7 +73,7 @@ type MsgReject struct {
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgReject) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgReject) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
if pver < RejectVersion {
str := fmt.Sprintf("reject message invalid for protocol "+
"version %d", pver)
@ -115,7 +115,7 @@ func (msg *MsgReject) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgReject) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgReject) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
if pver < RejectVersion {
str := fmt.Sprintf("reject message invalid for protocol "+
"version %d", pver)

54
wire/msgreject_test.go
View file

@ -45,6 +45,7 @@ func TestRejectCodeStringer(t *testing.T) {
// TestRejectLatest tests the MsgPong API against the latest protocol version.
func TestRejectLatest(t *testing.T) {
pver := ProtocolVersion
enc := BaseEncoding
// Create reject message data.
rejCommand := (&MsgBlock{}).Command()
@ -86,14 +87,14 @@ func TestRejectLatest(t *testing.T) {
// Test encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, pver)
err := msg.BtcEncode(&buf, pver, enc)
if err != nil {
t.Errorf("encode of MsgReject failed %v err <%v>", msg, err)
}
// Test decode with latest protocol version.
readMsg := MsgReject{}
err = readMsg.BtcDecode(&buf, pver)
err = readMsg.BtcDecode(&buf, pver, enc)
if err != nil {
t.Errorf("decode of MsgReject failed %v err <%v>", buf.Bytes(),
err)
@ -123,6 +124,7 @@ func TestRejectLatest(t *testing.T) {
func TestRejectBeforeAdded(t *testing.T) {
// Use the protocol version just prior to RejectVersion.
pver := RejectVersion - 1
enc := BaseEncoding
// Create reject message data.
rejCommand := (&MsgBlock{}).Command()
@ -142,7 +144,7 @@ func TestRejectBeforeAdded(t *testing.T) {
// Test encode with old protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, pver)
err := msg.BtcEncode(&buf, pver, enc)
if err == nil {
t.Errorf("encode of MsgReject succeeded when it shouldn't "+
"have %v", msg)
@ -150,7 +152,7 @@ func TestRejectBeforeAdded(t *testing.T) {
// // Test decode with old protocol version.
readMsg := MsgReject{}
err = readMsg.BtcDecode(&buf, pver)
err = readMsg.BtcDecode(&buf, pver, enc)
if err == nil {
t.Errorf("decode of MsgReject succeeded when it shouldn't "+
"have %v", spew.Sdump(buf.Bytes()))
@ -191,14 +193,14 @@ func TestRejectCrossProtocol(t *testing.T) {
// Encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, ProtocolVersion)
err := msg.BtcEncode(&buf, ProtocolVersion, BaseEncoding)
if err != nil {
t.Errorf("encode of MsgReject failed %v err <%v>", msg, err)
}
// Decode with old protocol version.
readMsg := MsgReject{}
err = readMsg.BtcDecode(&buf, RejectVersion-1)
err = readMsg.BtcDecode(&buf, RejectVersion-1, BaseEncoding)
if err == nil {
t.Errorf("encode of MsgReject succeeded when it shouldn't "+
"have %v", msg)
@ -225,9 +227,10 @@ func TestRejectCrossProtocol(t *testing.T) {
// protocol versions.
func TestRejectWire(t *testing.T) {
tests := []struct {
msg MsgReject // Message to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
msg MsgReject // Message to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version rejected command version (no hash).
{
@ -244,6 +247,7 @@ func TestRejectWire(t *testing.T) {
0x6f, 0x6e, // "duplicate version"
},
ProtocolVersion,
BaseEncoding,
},
// Latest protocol version rejected command block (has hash).
{
@ -264,6 +268,7 @@ func TestRejectWire(t *testing.T) {
0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, // mainNetGenesisHash
},
ProtocolVersion,
BaseEncoding,
},
}
@ -271,7 +276,7 @@ func TestRejectWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.msg.BtcEncode(&buf, test.pver)
err := test.msg.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -285,7 +290,7 @@ func TestRejectWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgReject
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -319,31 +324,32 @@ func TestRejectWireErrors(t *testing.T) {
}
tests := []struct {
in *MsgReject // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgReject // 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
}{
// Latest protocol version with intentional read/write errors.
// Force error in reject command.
{baseReject, baseRejectEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{baseReject, baseRejectEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in reject code.
{baseReject, baseRejectEncoded, pver, 6, io.ErrShortWrite, io.EOF},
{baseReject, baseRejectEncoded, pver, BaseEncoding, 6, io.ErrShortWrite, io.EOF},
// Force error in reject reason.
{baseReject, baseRejectEncoded, pver, 7, io.ErrShortWrite, io.EOF},
{baseReject, baseRejectEncoded, pver, BaseEncoding, 7, io.ErrShortWrite, io.EOF},
// Force error in reject hash.
{baseReject, baseRejectEncoded, pver, 23, io.ErrShortWrite, io.EOF},
{baseReject, baseRejectEncoded, pver, BaseEncoding, 23, io.ErrShortWrite, io.EOF},
// Force error due to unsupported protocol version.
{baseReject, baseRejectEncoded, pverNoReject, 6, wireErr, wireErr},
{baseReject, baseRejectEncoded, pverNoReject, BaseEncoding, 6, wireErr, wireErr},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -363,7 +369,7 @@ func TestRejectWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgReject
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)

4
wire/msgsendheaders.go
View file

@ -19,7 +19,7 @@ type MsgSendHeaders struct{}
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgSendHeaders) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgSendHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
if pver < SendHeadersVersion {
str := fmt.Sprintf("sendheaders message invalid for protocol "+
"version %d", pver)
@ -31,7 +31,7 @@ func (msg *MsgSendHeaders) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgSendHeaders) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgSendHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
if pver < SendHeadersVersion {
str := fmt.Sprintf("sendheaders message invalid for protocol "+
"version %d", pver)

27
wire/msgsendheaders_test.go
View file

@ -16,6 +16,7 @@ import (
// version.
func TestSendHeaders(t *testing.T) {
pver := ProtocolVersion
enc := BaseEncoding
// Ensure the command is expected value.
wantCmd := "sendheaders"
@ -36,7 +37,7 @@ func TestSendHeaders(t *testing.T) {
// Test encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, pver)
err := msg.BtcEncode(&buf, pver, enc)
if err != nil {
t.Errorf("encode of MsgSendHeaders failed %v err <%v>", msg,
err)
@ -45,7 +46,7 @@ func TestSendHeaders(t *testing.T) {
// Older protocol versions should fail encode since message didn't
// exist yet.
oldPver := SendHeadersVersion - 1
err = msg.BtcEncode(&buf, oldPver)
err = msg.BtcEncode(&buf, oldPver, enc)
if err == nil {
s := "encode of MsgSendHeaders passed for old protocol " +
"version %v err <%v>"
@ -54,7 +55,7 @@ func TestSendHeaders(t *testing.T) {
// Test decode with latest protocol version.
readmsg := NewMsgSendHeaders()
err = readmsg.BtcDecode(&buf, pver)
err = readmsg.BtcDecode(&buf, pver, enc)
if err != nil {
t.Errorf("decode of MsgSendHeaders failed [%v] err <%v>", buf,
err)
@ -62,7 +63,7 @@ func TestSendHeaders(t *testing.T) {
// Older protocol versions should fail decode since message didn't
// exist yet.
err = readmsg.BtcDecode(&buf, oldPver)
err = readmsg.BtcDecode(&buf, oldPver, enc)
if err == nil {
s := "decode of MsgSendHeaders passed for old protocol " +
"version %v err <%v>"
@ -75,12 +76,13 @@ func TestSendHeaders(t *testing.T) {
func TestSendHeadersBIP0130(t *testing.T) {
// Use the protocol version just prior to SendHeadersVersion changes.
pver := SendHeadersVersion - 1
enc := BaseEncoding
msg := NewMsgSendHeaders()
// Test encode with old protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, pver)
err := msg.BtcEncode(&buf, pver, enc)
if err == nil {
t.Errorf("encode of MsgSendHeaders succeeded when it should " +
"have failed")
@ -88,7 +90,7 @@ func TestSendHeadersBIP0130(t *testing.T) {
// Test decode with old protocol version.
readmsg := NewMsgSendHeaders()
err = readmsg.BtcDecode(&buf, pver)
err = readmsg.BtcDecode(&buf, pver, enc)
if err == nil {
t.Errorf("decode of MsgSendHeaders succeeded when it should " +
"have failed")
@ -98,11 +100,12 @@ func TestSendHeadersBIP0130(t *testing.T) {
// TestSendHeadersCrossProtocol tests the MsgSendHeaders API when encoding with
// the latest protocol version and decoding with SendHeadersVersion.
func TestSendHeadersCrossProtocol(t *testing.T) {
enc := BaseEncoding
msg := NewMsgSendHeaders()
// Encode with latest protocol version.
var buf bytes.Buffer
err := msg.BtcEncode(&buf, ProtocolVersion)
err := msg.BtcEncode(&buf, ProtocolVersion, enc)
if err != nil {
t.Errorf("encode of MsgSendHeaders failed %v err <%v>", msg,
err)
@ -110,7 +113,7 @@ func TestSendHeadersCrossProtocol(t *testing.T) {
// Decode with old protocol version.
readmsg := NewMsgSendHeaders()
err = readmsg.BtcDecode(&buf, SendHeadersVersion)
err = readmsg.BtcDecode(&buf, SendHeadersVersion, enc)
if err != nil {
t.Errorf("decode of MsgSendHeaders failed [%v] err <%v>", buf,
err)
@ -128,6 +131,7 @@ func TestSendHeadersWire(t *testing.T) {
out *MsgSendHeaders // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version.
{
@ -135,6 +139,7 @@ func TestSendHeadersWire(t *testing.T) {
msgSendHeaders,
msgSendHeadersEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version SendHeadersVersion+1
@ -143,6 +148,7 @@ func TestSendHeadersWire(t *testing.T) {
msgSendHeaders,
msgSendHeadersEncoded,
SendHeadersVersion + 1,
BaseEncoding,
},
// Protocol version SendHeadersVersion
@ -151,6 +157,7 @@ func TestSendHeadersWire(t *testing.T) {
msgSendHeaders,
msgSendHeadersEncoded,
SendHeadersVersion,
BaseEncoding,
},
}
@ -158,7 +165,7 @@ func TestSendHeadersWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -172,7 +179,7 @@ func TestSendHeadersWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgSendHeaders
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue

27
wire/msgtx.go
View file

@ -334,7 +334,7 @@ func (msg *MsgTx) Copy() *MsgTx {
// This is part of the Message interface implementation.
// See Deserialize for decoding transactions stored to disk, such as in a
// database, as opposed to decoding transactions from the wire.
func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
version, err := binarySerializer.Uint32(r, littleEndian)
if err != nil {
return err
@ -498,14 +498,22 @@ func (msg *MsgTx) Deserialize(r io.Reader) error {
// At the current time, there is no difference between the wire encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of BtcDecode.
return msg.BtcDecode(r, 0)
return msg.BtcDecode(r, 0, WitnessEncoding)
}
// DeserializeNoWitness decodes a transaction from r into the receiver, where
// the transaction encoding format within r MUST NOT utilize the new
// serialization format created to encode transaction bearing witness data
// within inputs.
func (msg *MsgTx) DeserializeNoWitness(r io.Reader) error {
return msg.BtcDecode(r, 0, BaseEncoding)
}
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
// See Serialize for encoding transactions to be stored to disk, such as in a
// database, as opposed to encoding transactions for the wire.
func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
err := binarySerializer.PutUint32(w, littleEndian, uint32(msg.Version))
if err != nil {
return err
@ -554,8 +562,19 @@ func (msg *MsgTx) Serialize(w io.Writer) error {
// At the current time, there is no difference between the wire encoding
// at protocol version 0 and the stable long-term storage format. As
// a result, make use of BtcEncode.
return msg.BtcEncode(w, 0)
//
// Passing a encoding type of WitnessEncoding to BtcEncode for MsgTx
// indicates that the transaction's witnesses (if any) should be
// serialized according to the new serialization structure defined in
// BIP0144.
return msg.BtcEncode(w, 0, WitnessEncoding)
}
// SerializeWitness encodes the transaction to w in an identical manner to
// Serialize, however even if the source transaction has inputs with witness
// data, the old serialization format will still be used.
func (msg *MsgTx) SerializeNoWitness(w io.Writer) error {
return msg.BtcEncode(w, 0, BaseEncoding)
}
// SerializeSize returns the number of bytes it would take to serialize the

166
wire/msgtx_test.go
View file

@ -174,6 +174,83 @@ func TestTxHash(t *testing.T) {
}
}
// TestTxSha tests the ability to generate the wtxid, and txid of a transaction
// with witness inputs accurately.
func TestWTxSha(t *testing.T) {
hashStrTxid := "0f167d1385a84d1518cfee208b653fc9163b605ccf1b75347e2850b3e2eb19f3"
wantHashTxid, err := chainhash.NewHashFromStr(hashStrTxid)
if err != nil {
t.Errorf("NewShaHashFromStr: %v", err)
return
}
hashStrWTxid := "0858eab78e77b6b033da30f46699996396cf48fcf625a783c85a51403e175e74"
wantHashWTxid, err := chainhash.NewHashFromStr(hashStrWTxid)
if err != nil {
t.Errorf("NewShaHashFromStr: %v", err)
return
}
// From block 23157 in a past version of segnet.
msgTx := NewMsgTx(1)
txIn := TxIn{
PreviousOutPoint: OutPoint{
Hash: chainhash.Hash{
0xa5, 0x33, 0x52, 0xd5, 0x13, 0x57, 0x66, 0xf0,
0x30, 0x76, 0x59, 0x74, 0x18, 0x26, 0x3d, 0xa2,
0xd9, 0xc9, 0x58, 0x31, 0x59, 0x68, 0xfe, 0xa8,
0x23, 0x52, 0x94, 0x67, 0x48, 0x1f, 0xf9, 0xcd,
},
Index: 19,
},
Witness: [][]byte{
[]byte{ // 70-byte signature
0x30, 0x43, 0x02, 0x1f, 0x4d, 0x23, 0x81, 0xdc,
0x97, 0xf1, 0x82, 0xab, 0xd8, 0x18, 0x5f, 0x51,
0x75, 0x30, 0x18, 0x52, 0x32, 0x12, 0xf5, 0xdd,
0xc0, 0x7c, 0xc4, 0xe6, 0x3a, 0x8d, 0xc0, 0x36,
0x58, 0xda, 0x19, 0x02, 0x20, 0x60, 0x8b, 0x5c,
0x4d, 0x92, 0xb8, 0x6b, 0x6d, 0xe7, 0xd7, 0x8e,
0xf2, 0x3a, 0x2f, 0xa7, 0x35, 0xbc, 0xb5, 0x9b,
0x91, 0x4a, 0x48, 0xb0, 0xe1, 0x87, 0xc5, 0xe7,
0x56, 0x9a, 0x18, 0x19, 0x70, 0x01,
},
[]byte{ // 33-byte serialize pub key
0x03, 0x07, 0xea, 0xd0, 0x84, 0x80, 0x7e, 0xb7,
0x63, 0x46, 0xdf, 0x69, 0x77, 0x00, 0x0c, 0x89,
0x39, 0x2f, 0x45, 0xc7, 0x64, 0x25, 0xb2, 0x61,
0x81, 0xf5, 0x21, 0xd7, 0xf3, 0x70, 0x06, 0x6a,
0x8f,
},
},
Sequence: 0xffffffff,
}
txOut := TxOut{
Value: 395019,
PkScript: []byte{
0x00, // Version 0 witness program
0x14, // OP_DATA_20
0x9d, 0xda, 0xc6, 0xf3, 0x9d, 0x51, 0xe0, 0x39,
0x8e, 0x53, 0x2a, 0x22, 0xc4, 0x1b, 0xa1, 0x89,
0x40, 0x6a, 0x85, 0x23, // 20-byte pub key hash
},
}
msgTx.AddTxIn(&txIn)
msgTx.AddTxOut(&txOut)
msgTx.LockTime = 0
// Ensure the correct txid, and wtxid is produced as expected.
txid := msgTx.TxHash()
if !txid.IsEqual(wantHashTxid) {
t.Errorf("TxSha: wrong hash - got %v, want %v",
spew.Sprint(txid), spew.Sprint(wantHashTxid))
}
wtxid := msgTx.WitnessHash()
if !wtxid.IsEqual(wantHashWTxid) {
t.Errorf("WTxSha: wrong hash - got %v, want %v",
spew.Sprint(wtxid), spew.Sprint(wantHashWTxid))
}
}
// TestTxWire tests the MsgTx wire encode and decode for various numbers
// of transaction inputs and outputs and protocol versions.
func TestTxWire(t *testing.T) {
@ -188,17 +265,18 @@ func TestTxWire(t *testing.T) {
}
tests := []struct {
in *MsgTx // Message to encode
out *MsgTx // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgTx // Message to encode
out *MsgTx // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version with no transactions.
{
noTx,
noTx,
noTxEncoded,
noTx, noTxEncoded,
ProtocolVersion,
BaseEncoding,
},
// Latest protocol version with multiple transactions.
@ -207,6 +285,7 @@ func TestTxWire(t *testing.T) {
multiTx,
multiTxEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version with no transactions.
@ -215,6 +294,7 @@ func TestTxWire(t *testing.T) {
noTx,
noTxEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0035Version with multiple transactions.
@ -223,6 +303,7 @@ func TestTxWire(t *testing.T) {
multiTx,
multiTxEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version with no transactions.
@ -231,6 +312,7 @@ func TestTxWire(t *testing.T) {
noTx,
noTxEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version BIP0031Version with multiple transactions.
@ -239,6 +321,7 @@ func TestTxWire(t *testing.T) {
multiTx,
multiTxEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion with no transactions.
@ -247,6 +330,7 @@ func TestTxWire(t *testing.T) {
noTx,
noTxEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion with multiple transactions.
@ -255,6 +339,7 @@ func TestTxWire(t *testing.T) {
multiTx,
multiTxEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion with no transactions.
@ -263,6 +348,7 @@ func TestTxWire(t *testing.T) {
noTx,
noTxEncoded,
MultipleAddressVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion with multiple transactions.
@ -271,6 +357,7 @@ func TestTxWire(t *testing.T) {
multiTx,
multiTxEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -278,7 +365,7 @@ func TestTxWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -292,7 +379,7 @@ func TestTxWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgTx
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -314,44 +401,45 @@ func TestTxWireErrors(t *testing.T) {
pver := uint32(60002)
tests := []struct {
in *MsgTx // Value to encode
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
in *MsgTx // 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 version.
{multiTx, multiTxEncoded, pver, 0, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in number of transaction inputs.
{multiTx, multiTxEncoded, pver, 4, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 4, io.ErrShortWrite, io.EOF},
// Force error in transaction input previous block hash.
{multiTx, multiTxEncoded, pver, 5, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 5, io.ErrShortWrite, io.EOF},
// Force error in transaction input previous block output index.
{multiTx, multiTxEncoded, pver, 37, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 37, io.ErrShortWrite, io.EOF},
// Force error in transaction input signature script length.
{multiTx, multiTxEncoded, pver, 41, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 41, io.ErrShortWrite, io.EOF},
// Force error in transaction input signature script.
{multiTx, multiTxEncoded, pver, 42, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 42, io.ErrShortWrite, io.EOF},
// Force error in transaction input sequence.
{multiTx, multiTxEncoded, pver, 49, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 49, io.ErrShortWrite, io.EOF},
// Force error in number of transaction outputs.
{multiTx, multiTxEncoded, pver, 53, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 53, io.ErrShortWrite, io.EOF},
// Force error in transaction output value.
{multiTx, multiTxEncoded, pver, 54, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 54, io.ErrShortWrite, io.EOF},
// Force error in transaction output pk script length.
{multiTx, multiTxEncoded, pver, 62, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 62, io.ErrShortWrite, io.EOF},
// Force error in transaction output pk script.
{multiTx, multiTxEncoded, pver, 63, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 63, io.ErrShortWrite, io.EOF},
// Force error in transaction output lock time.
{multiTx, multiTxEncoded, pver, 206, io.ErrShortWrite, io.EOF},
{multiTx, multiTxEncoded, pver, BaseEncoding, 206, io.ErrShortWrite, io.EOF},
}
t.Logf("Running %d tests", len(tests))
for i, test := range tests {
// Encode to wire format.
w := newFixedWriter(test.max)
err := test.in.BtcEncode(w, test.pver)
err := test.in.BtcEncode(w, test.pver, test.enc)
if err != test.writeErr {
t.Errorf("BtcEncode #%d wrong error got: %v, want: %v",
i, err, test.writeErr)
@ -361,7 +449,7 @@ func TestTxWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgTx
r := newFixedReader(test.max, test.buf)
err = msg.BtcDecode(r, test.pver)
err = msg.BtcDecode(r, test.pver, test.enc)
if err != test.readErr {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, test.readErr)
@ -386,6 +474,7 @@ func TestTxSerialize(t *testing.T) {
out *MsgTx // Expected decoded message
buf []byte // Serialized data
pkScriptLocs []int // Expected output script locations
witness bool // Serialize using the witness encoding
}{
// No transactions.
{
@ -393,6 +482,7 @@ func TestTxSerialize(t *testing.T) {
noTx,
noTxEncoded,
nil,
false,
},
// Multiple transactions.
@ -401,6 +491,7 @@ func TestTxSerialize(t *testing.T) {
multiTx,
multiTxEncoded,
multiTxPkScriptLocs,
false,
},
}
@ -525,10 +616,11 @@ func TestTxOverflowErrors(t *testing.T) {
txVer := uint32(1)
tests := []struct {
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
version uint32 // Transaction version
err error // Expected error
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
version uint32 // Transaction version
err error // Expected error
}{
// Transaction that claims to have ~uint64(0) inputs.
{
@ -536,7 +628,7 @@ func TestTxOverflowErrors(t *testing.T) {
0x00, 0x00, 0x00, 0x01, // Version
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, // Varint for number of input transactions
}, pver, txVer, &MessageError{},
}, pver, BaseEncoding, txVer, &MessageError{},
},
// Transaction that claims to have ~uint64(0) outputs.
@ -546,7 +638,7 @@ func TestTxOverflowErrors(t *testing.T) {
0x00, // Varint for number of input transactions
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, // Varint for number of output transactions
}, pver, txVer, &MessageError{},
}, pver, BaseEncoding, txVer, &MessageError{},
},
// Transaction that has an input with a signature script that
@ -562,7 +654,7 @@ func TestTxOverflowErrors(t *testing.T) {
0xff, 0xff, 0xff, 0xff, // Prevous output index
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, // Varint for length of signature script
}, pver, txVer, &MessageError{},
}, pver, BaseEncoding, txVer, &MessageError{},
},
// Transaction that has an output with a public key script
@ -582,7 +674,7 @@ func TestTxOverflowErrors(t *testing.T) {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Transaction amount
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, // Varint for length of public key script
}, pver, txVer, &MessageError{},
}, pver, BaseEncoding, txVer, &MessageError{},
},
}
@ -591,7 +683,7 @@ func TestTxOverflowErrors(t *testing.T) {
// Decode from wire format.
var msg MsgTx
r := bytes.NewReader(test.buf)
err := msg.BtcDecode(r, test.pver)
err := msg.BtcDecode(r, test.pver, test.enc)
if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
i, err, reflect.TypeOf(test.err))

4
wire/msgverack.go
View file

@ -17,13 +17,13 @@ type MsgVerAck struct{}
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgVerAck) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgVerAck) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
return nil
}
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgVerAck) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgVerAck) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
return nil
}

18
wire/msgverack_test.go
View file

@ -41,10 +41,11 @@ func TestVerAckWire(t *testing.T) {
msgVerAckEncoded := []byte{}
tests := []struct {
in *MsgVerAck // Message to encode
out *MsgVerAck // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
in *MsgVerAck // Message to encode
out *MsgVerAck // Expected decoded message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
enc MessageEncoding // Message encoding format
}{
// Latest protocol version.
{
@ -52,6 +53,7 @@ func TestVerAckWire(t *testing.T) {
msgVerAck,
msgVerAckEncoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0035Version.
@ -60,6 +62,7 @@ func TestVerAckWire(t *testing.T) {
msgVerAck,
msgVerAckEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version.
@ -68,6 +71,7 @@ func TestVerAckWire(t *testing.T) {
msgVerAck,
msgVerAckEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion.
@ -76,6 +80,7 @@ func TestVerAckWire(t *testing.T) {
msgVerAck,
msgVerAckEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion.
@ -84,6 +89,7 @@ func TestVerAckWire(t *testing.T) {
msgVerAck,
msgVerAckEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -91,7 +97,7 @@ func TestVerAckWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -105,7 +111,7 @@ func TestVerAckWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgVerAck
rbuf := bytes.NewReader(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue

4
wire/msgversion.go
View file

@ -76,7 +76,7 @@ func (msg *MsgVersion) AddService(service ServiceFlag) {
// *bytes.Buffer so the number of remaining bytes can be ascertained.
//
// This is part of the Message interface implementation.
func (msg *MsgVersion) BtcDecode(r io.Reader, pver uint32) error {
func (msg *MsgVersion) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
buf, ok := r.(*bytes.Buffer)
if !ok {
return fmt.Errorf("MsgVersion.BtcDecode reader is not a " +
@ -149,7 +149,7 @@ func (msg *MsgVersion) BtcDecode(r io.Reader, pver uint32) error {
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgVersion) BtcEncode(w io.Writer, pver uint32) error {
func (msg *MsgVersion) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
err := validateUserAgent(msg.UserAgent)
if err != nil {
return err

76
wire/msgversion_test.go
View file

@ -139,10 +139,11 @@ func TestVersionWire(t *testing.T) {
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
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.
{
@ -150,6 +151,7 @@ func TestVersionWire(t *testing.T) {
baseVersionBIP0037,
baseVersionBIP0037Encoded,
ProtocolVersion,
BaseEncoding,
},
// Protocol version BIP0037Version with relay transactions field
@ -159,6 +161,7 @@ func TestVersionWire(t *testing.T) {
baseVersionBIP0037,
baseVersionBIP0037Encoded,
BIP0037Version,
BaseEncoding,
},
// Protocol version BIP0037Version with relay transactions field
@ -168,6 +171,7 @@ func TestVersionWire(t *testing.T) {
verRelayTxFalse,
verRelayTxFalseEncoded,
BIP0037Version,
BaseEncoding,
},
// Protocol version BIP0035Version.
@ -176,6 +180,7 @@ func TestVersionWire(t *testing.T) {
baseVersion,
baseVersionEncoded,
BIP0035Version,
BaseEncoding,
},
// Protocol version BIP0031Version.
@ -184,6 +189,7 @@ func TestVersionWire(t *testing.T) {
baseVersion,
baseVersionEncoded,
BIP0031Version,
BaseEncoding,
},
// Protocol version NetAddressTimeVersion.
@ -192,6 +198,7 @@ func TestVersionWire(t *testing.T) {
baseVersion,
baseVersionEncoded,
NetAddressTimeVersion,
BaseEncoding,
},
// Protocol version MultipleAddressVersion.
@ -200,6 +207,7 @@ func TestVersionWire(t *testing.T) {
baseVersion,
baseVersionEncoded,
MultipleAddressVersion,
BaseEncoding,
},
}
@ -207,7 +215,7 @@ func TestVersionWire(t *testing.T) {
for i, test := range tests {
// Encode the message to wire format.
var buf bytes.Buffer
err := test.in.BtcEncode(&buf, test.pver)
err := test.in.BtcEncode(&buf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcEncode #%d error %v", i, err)
continue
@ -221,7 +229,7 @@ func TestVersionWire(t *testing.T) {
// Decode the message from wire format.
var msg MsgVersion
rbuf := bytes.NewBuffer(test.buf)
err = msg.BtcDecode(rbuf, test.pver)
err = msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue
@ -241,12 +249,13 @@ func TestVersionWireErrors(t *testing.T) {
// 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 err := baseVersion.BtcDecode(fr, pver); err == nil {
if err := baseVersion.BtcDecode(fr, pver, enc); err == nil {
t.Errorf("Did not received error when calling " +
"MsgVersion.BtcDecode with non *bytes.Buffer")
}
@ -276,46 +285,47 @@ func TestVersionWireErrors(t *testing.T) {
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
max int // Max size of fixed buffer to induce errors
writeErr error // Expected write error
readErr error // Expected read error
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, 0, io.ErrShortWrite, io.EOF},
{baseVersion, baseVersionEncoded, pver, BaseEncoding, 0, io.ErrShortWrite, io.EOF},
// Force error in services.
{baseVersion, baseVersionEncoded, pver, 4, io.ErrShortWrite, io.EOF},
{baseVersion, baseVersionEncoded, pver, BaseEncoding, 4, io.ErrShortWrite, io.EOF},
// Force error in timestamp.
{baseVersion, baseVersionEncoded, pver, 12, io.ErrShortWrite, io.EOF},
{baseVersion, baseVersionEncoded, pver, BaseEncoding, 12, io.ErrShortWrite, io.EOF},
// Force error in remote address.
{baseVersion, baseVersionEncoded, pver, 20, io.ErrShortWrite, io.EOF},
{baseVersion, baseVersionEncoded, pver, BaseEncoding, 20, io.ErrShortWrite, io.EOF},
// Force error in local address.
{baseVersion, baseVersionEncoded, pver, 47, io.ErrShortWrite, io.ErrUnexpectedEOF},
{baseVersion, baseVersionEncoded, pver, BaseEncoding, 47, io.ErrShortWrite, io.ErrUnexpectedEOF},
// Force error in nonce.
{baseVersion, baseVersionEncoded, pver, 73, io.ErrShortWrite, io.ErrUnexpectedEOF},
{baseVersion, baseVersionEncoded, pver, BaseEncoding, 73, io.ErrShortWrite, io.ErrUnexpectedEOF},
// Force error in user agent length.
{baseVersion, baseVersionEncoded, pver, 81, io.ErrShortWrite, io.EOF},
{baseVersion, baseVersionEncoded, pver, BaseEncoding, 81, io.ErrShortWrite, io.EOF},
// Force error in user agent.
{baseVersion, baseVersionEncoded, pver, 82, io.ErrShortWrite, io.ErrUnexpectedEOF},
{baseVersion, baseVersionEncoded, pver, BaseEncoding, 82, io.ErrShortWrite, io.ErrUnexpectedEOF},
// Force error in last block.
{baseVersion, baseVersionEncoded, pver, 98, io.ErrShortWrite, io.ErrUnexpectedEOF},
{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, 101, io.ErrShortWrite, nil,
BIP0037Version, BaseEncoding, 101, io.ErrShortWrite, nil,
},
// Force error due to user agent too big
{exceedUAVer, exceedUAVerEncoded, pver, newLen, wireErr, wireErr},
{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)
err := test.in.BtcEncode(w, test.pver)
err := 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, err, test.writeErr)
@ -335,7 +345,7 @@ func TestVersionWireErrors(t *testing.T) {
// Decode from wire format.
var msg MsgVersion
buf := bytes.NewBuffer(test.buf[0:test.max])
err = msg.BtcDecode(buf, test.pver)
err = 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, err, test.readErr)
@ -407,34 +417,40 @@ func TestVersionOptionalFields(t *testing.T) {
copy(lastBlockVersionEncoded, baseVersionEncoded)
tests := []struct {
msg *MsgVersion // Expected message
buf []byte // Wire encoding
pver uint32 // Protocol version for wire encoding
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,
},
}
@ -442,7 +458,7 @@ func TestVersionOptionalFields(t *testing.T) {
// Decode the message from wire format.
var msg MsgVersion
rbuf := bytes.NewBuffer(test.buf)
err := msg.BtcDecode(rbuf, test.pver)
err := msg.BtcDecode(rbuf, test.pver, test.enc)
if err != nil {
t.Errorf("BtcDecode #%d error %v", i, err)
continue