From 74266d5bbd95ac07882b09230aec876bf7704f69 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Thu, 13 Nov 2014 20:31:48 +0100
Subject: rlp: new package for streaming RLP decoder

---
 rlp/decode.go      | 666 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 rlp/decode_test.go | 469 +++++++++++++++++++++++++++++++++++++
 rlp/doc.go         |  17 ++
 rlp/typecache.go   |  91 ++++++++
 4 files changed, 1243 insertions(+)
 create mode 100644 rlp/decode.go
 create mode 100644 rlp/decode_test.go
 create mode 100644 rlp/doc.go
 create mode 100644 rlp/typecache.go

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
new file mode 100644
index 000000000..1a51e7130
--- /dev/null
+++ b/rlp/decode.go
@@ -0,0 +1,666 @@
+package rlp
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"math/big"
+	"reflect"
+)
+
+var (
+	errNoPointer     = errors.New("rlp: interface given to Decode must be a pointer")
+	errDecodeIntoNil = errors.New("rlp: pointer given to Decode must not be nil")
+)
+
+// Decoder is implemented by types that require custom RLP
+// decoding rules or need to decode into private fields.
+//
+// The DecodeRLP method should read one value from the given
+// Stream. It is not forbidden to read less or more, but it might
+// be confusing.
+type Decoder interface {
+	DecodeRLP(*Stream) error
+}
+
+// Decode parses RLP-encoded data from r and stores the result
+// in the value pointed to by val. Val must be a non-nil pointer.
+//
+// Decode uses the following type-dependent decoding rules:
+//
+// If the type implements the Decoder interface, decode calls
+// DecodeRLP.
+//
+// To decode into a pointer, Decode will set the pointer to nil if the
+// input has size zero or the input is a single byte with value zero.
+// If the input has nonzero size, Decode will allocate a new value of
+// the type being pointed to.
+//
+// To decode into a struct, Decode expects the input to be an RLP
+// list. The decoded elements of the list are assigned to each public
+// field in the order given by the struct's definition. If the input
+// list has too few elements, no error is returned and the remaining
+// fields will have the zero value.
+// Recursive struct types are supported.
+//
+// To decode into a slice, the input must be a list and the resulting
+// slice will contain the input elements in order.
+// As a special case, if the slice has a byte-size element type, the input
+// can also be an RLP string.
+//
+// To decode into a Go string, the input must be an RLP string. The
+// bytes are taken as-is and will not necessarily be valid UTF-8.
+//
+// To decode into an integer type, the input must also be an RLP
+// string. The bytes are interpreted as a big endian representation of
+// the integer. If the RLP string is larger than the bit size of the
+// type, Decode will return an error. Decode also supports *big.Int.
+// There is no size limit for big integers.
+//
+// To decode into an interface value, Decode stores one of these
+// in the value:
+//
+//	[]interface{}, for RLP lists
+//	[]byte, for RLP strings
+//
+// Non-empty interface types are not supported, nor are bool, float32,
+// float64, maps, channel types and functions.
+func Decode(r ByteReader, val interface{}) error {
+	return NewStream(r).Decode(val)
+}
+
+func makeNumDecoder(typ reflect.Type) decoder {
+	kind := typ.Kind()
+	switch {
+	case kind <= reflect.Int64:
+		return decodeInt
+	case kind <= reflect.Uint64:
+		return decodeUint
+	default:
+		panic("fallthrough")
+	}
+}
+
+func decodeInt(s *Stream, val reflect.Value) error {
+	num, err := s.uint(val.Type().Bits())
+	if err != nil {
+		return err
+	}
+	val.SetInt(int64(num))
+	return nil
+}
+
+func decodeUint(s *Stream, val reflect.Value) error {
+	num, err := s.uint(val.Type().Bits())
+	if err != nil {
+		return err
+	}
+	val.SetUint(num)
+	return nil
+}
+
+func decodeString(s *Stream, val reflect.Value) error {
+	b, err := s.Bytes()
+	if err != nil {
+		return err
+	}
+	val.SetString(string(b))
+	return nil
+}
+
+func decodeBigIntNoPtr(s *Stream, val reflect.Value) error {
+	return decodeBigInt(s, val.Addr())
+}
+
+func decodeBigInt(s *Stream, val reflect.Value) error {
+	b, err := s.Bytes()
+	if err != nil {
+		return err
+	}
+	i := val.Interface().(*big.Int)
+	if i == nil {
+		i = new(big.Int)
+		val.Set(reflect.ValueOf(i))
+	}
+	i.SetBytes(b)
+	return nil
+}
+
+const maxInt = int(^uint(0) >> 1)
+
+func makeListDecoder(typ reflect.Type) (decoder, error) {
+	etype := typ.Elem()
+	if etype.Kind() == reflect.Uint8 && !reflect.PtrTo(etype).Implements(decoderInterface) {
+		if typ.Kind() == reflect.Array {
+			return decodeByteArray, nil
+		} else {
+			return decodeByteSlice, nil
+		}
+	}
+	etypeinfo, err := cachedTypeInfo1(etype)
+	if err != nil {
+		return nil, err
+	}
+	var maxLen = maxInt
+	if typ.Kind() == reflect.Array {
+		maxLen = typ.Len()
+	}
+	dec := func(s *Stream, val reflect.Value) error {
+		return decodeList(s, val, etypeinfo.decoder, maxLen)
+	}
+	return dec, nil
+}
+
+// decodeList decodes RLP list elements into slices and arrays.
+//
+// The approach here is stolen from package json, although we differ
+// in the semantics for arrays. package json discards remaining
+// elements that would not fit into the array. We generate an error in
+// this case because we'd be losing information.
+func decodeList(s *Stream, val reflect.Value, elemdec decoder, maxelem int) error {
+	size, err := s.List()
+	if err != nil {
+		return err
+	}
+	if size == 0 {
+		if val.Kind() == reflect.Slice {
+			val.Set(reflect.MakeSlice(val.Type(), 0, 0))
+		} else {
+			zero(val, 0)
+		}
+		return s.ListEnd()
+	}
+
+	i := 0
+	for {
+		if i > maxelem {
+			return fmt.Errorf("rlp: input List has more than %d elements", maxelem)
+		}
+		if val.Kind() == reflect.Slice {
+			// grow slice if necessary
+			if i >= val.Cap() {
+				newcap := val.Cap() + val.Cap()/2
+				if newcap < 4 {
+					newcap = 4
+				}
+				newv := reflect.MakeSlice(val.Type(), val.Len(), newcap)
+				reflect.Copy(newv, val)
+				val.Set(newv)
+			}
+			if i >= val.Len() {
+				val.SetLen(i + 1)
+			}
+		}
+		// decode into element
+		if err := elemdec(s, val.Index(i)); err == EOL {
+			break
+		} else if err != nil {
+			return err
+		}
+		i++
+	}
+	if i < val.Len() {
+		if val.Kind() == reflect.Array {
+			// zero the rest of the array.
+			zero(val, i)
+		} else {
+			val.SetLen(i)
+		}
+	}
+	return s.ListEnd()
+}
+
+func decodeByteSlice(s *Stream, val reflect.Value) error {
+	kind, _, err := s.Kind()
+	if err != nil {
+		return err
+	}
+	if kind == List {
+		return decodeList(s, val, decodeUint, maxInt)
+	}
+	b, err := s.Bytes()
+	if err == nil {
+		val.SetBytes(b)
+	}
+	return err
+}
+
+var errStringDoesntFitArray = errors.New("rlp: string value doesn't fit into target array")
+
+func decodeByteArray(s *Stream, val reflect.Value) error {
+	kind, size, err := s.Kind()
+	if err != nil {
+		return err
+	}
+	switch kind {
+	case Byte:
+		if val.Len() == 0 {
+			return errStringDoesntFitArray
+		}
+		bv, _ := s.Uint()
+		val.Index(0).SetUint(bv)
+		zero(val, 1)
+	case String:
+		if uint64(val.Len()) < size {
+			return errStringDoesntFitArray
+		}
+		slice := val.Slice(0, int(size)).Interface().([]byte)
+		if err := s.readFull(slice); err != nil {
+			return err
+		}
+		zero(val, int(size))
+	case List:
+		return decodeList(s, val, decodeUint, val.Len())
+	}
+	return nil
+}
+
+func zero(val reflect.Value, start int) {
+	z := reflect.Zero(val.Type().Elem())
+	for i := start; i < val.Len(); i++ {
+		val.Index(i).Set(z)
+	}
+}
+
+type field struct {
+	index int
+	info  *typeinfo
+}
+
+func makeStructDecoder(typ reflect.Type) (decoder, error) {
+	var fields []field
+	for i := 0; i < typ.NumField(); i++ {
+		if f := typ.Field(i); f.PkgPath == "" { // exported
+			info, err := cachedTypeInfo1(f.Type)
+			if err != nil {
+				return nil, err
+			}
+			fields = append(fields, field{i, info})
+		}
+	}
+	dec := func(s *Stream, val reflect.Value) (err error) {
+		if _, err = s.List(); err != nil {
+			return err
+		}
+		for _, f := range fields {
+			err = f.info.decoder(s, val.Field(f.index))
+			if err == EOL {
+				// too few elements. leave the rest at their zero value.
+				break
+			} else if err != nil {
+				return err
+			}
+		}
+		if err = s.ListEnd(); err == errNotAtEOL {
+			err = errors.New("rlp: input List has too many elements")
+		}
+		return err
+	}
+	return dec, nil
+}
+
+func makePtrDecoder(typ reflect.Type) (decoder, error) {
+	etype := typ.Elem()
+	etypeinfo, err := cachedTypeInfo1(etype)
+	if err != nil {
+		return nil, err
+	}
+	dec := func(s *Stream, val reflect.Value) (err error) {
+		_, size, err := s.Kind()
+		if err != nil || size == 0 && s.byteval == 0 {
+			return err
+		}
+		newval := val
+		if val.IsNil() {
+			newval = reflect.New(etype)
+		}
+		if err = etypeinfo.decoder(s, newval.Elem()); err == nil {
+			val.Set(newval)
+		}
+		return err
+	}
+	return dec, nil
+}
+
+var ifsliceType = reflect.TypeOf([]interface{}{})
+
+func decodeInterface(s *Stream, val reflect.Value) error {
+	kind, _, err := s.Kind()
+	if err != nil {
+		return err
+	}
+	if kind == List {
+		slice := reflect.New(ifsliceType).Elem()
+		if err := decodeList(s, slice, decodeInterface, maxInt); err != nil {
+			return err
+		}
+		val.Set(slice)
+	} else {
+		b, err := s.Bytes()
+		if err != nil {
+			return err
+		}
+		val.Set(reflect.ValueOf(b))
+	}
+	return nil
+}
+
+// This decoder is used for non-pointer values of types
+// that implement the Decoder interface using a pointer receiver.
+func decodeDecoderNoPtr(s *Stream, val reflect.Value) error {
+	return val.Addr().Interface().(Decoder).DecodeRLP(s)
+}
+
+func decodeDecoder(s *Stream, val reflect.Value) error {
+	// Decoder instances are not handled using the pointer rule if the type
+	// implements Decoder with pointer receiver (i.e. always)
+	// because it might handle empty values specially.
+	// We need to allocate one here in this case, like makePtrDecoder does.
+	if val.Kind() == reflect.Ptr && val.IsNil() {
+		val.Set(reflect.New(val.Type().Elem()))
+	}
+	return val.Interface().(Decoder).DecodeRLP(s)
+}
+
+// Kind represents the kind of value contained in an RLP stream.
+type Kind int
+
+const (
+	Byte Kind = iota
+	String
+	List
+)
+
+func (k Kind) String() string {
+	switch k {
+	case Byte:
+		return "Byte"
+	case String:
+		return "String"
+	case List:
+		return "List"
+	default:
+		return fmt.Sprintf("Unknown(%d)", k)
+	}
+}
+
+var (
+	// EOL is returned when the end of the current list
+	// has been reached during streaming.
+	EOL = errors.New("rlp: end of list")
+
+	// Other errors
+	ErrExpectedString = errors.New("rlp: expected String or Byte")
+	ErrExpectedList   = errors.New("rlp: expected List")
+	ErrElemTooLarge   = errors.New("rlp: element is larger than containing list")
+
+	// internal errors
+	errNotInList = errors.New("rlp: call of ListEnd outside of any list")
+	errNotAtEOL  = errors.New("rlp: call of ListEnd not positioned at EOL")
+)
+
+// ByteReader must be implemented by any input reader for a Stream. It
+// is implemented by e.g. bufio.Reader and bytes.Reader.
+type ByteReader interface {
+	io.Reader
+	io.ByteReader
+}
+
+// Stream can be used for piecemeal decoding of an input stream. This
+// is useful if the input is very large or if the decoding rules for a
+// type depend on the input structure. Stream does not keep an
+// internal buffer. After decoding a value, the input reader will be
+// positioned just before the type information for the next value.
+//
+// When decoding a list and the input position reaches the declared
+// length of the list, all operations will return error EOL.
+// The end of the list must be acknowledged using ListEnd to continue
+// reading the enclosing list.
+//
+// Stream is not safe for concurrent use.
+type Stream struct {
+	r       ByteReader
+	uintbuf []byte
+
+	kind    Kind   // kind of value ahead
+	size    uint64 // size of value ahead
+	byteval byte   // value of single byte in type tag
+	stack   []listpos
+}
+
+type listpos struct{ pos, size uint64 }
+
+func NewStream(r ByteReader) *Stream {
+	return &Stream{r: r, uintbuf: make([]byte, 8), kind: -1}
+}
+
+// Bytes reads an RLP string and returns its contents as a byte slice.
+// If the input does not contain an RLP string, the returned
+// error will be ErrExpectedString.
+func (s *Stream) Bytes() ([]byte, error) {
+	kind, size, err := s.Kind()
+	if err != nil {
+		return nil, err
+	}
+	switch kind {
+	case Byte:
+		s.kind = -1 // rearm Kind
+		return []byte{s.byteval}, nil
+	case String:
+		b := make([]byte, size)
+		if err = s.readFull(b); err != nil {
+			return nil, err
+		}
+		return b, nil
+	default:
+		return nil, ErrExpectedString
+	}
+}
+
+// Uint reads an RLP string of up to 8 bytes and returns its contents
+// as an unsigned integer. If the input does not contain an RLP string, the
+// returned error will be ErrExpectedString.
+func (s *Stream) Uint() (uint64, error) {
+	return s.uint(64)
+}
+
+func (s *Stream) uint(maxbits int) (uint64, error) {
+	kind, size, err := s.Kind()
+	if err != nil {
+		return 0, err
+	}
+	switch kind {
+	case Byte:
+		s.kind = -1 // rearm Kind
+		return uint64(s.byteval), nil
+	case String:
+		if size > uint64(maxbits/8) {
+			return 0, fmt.Errorf("rlp: string is larger than %d bits", maxbits)
+		}
+		return s.readUint(byte(size))
+	default:
+		return 0, ErrExpectedString
+	}
+}
+
+// List starts decoding an RLP list. If the input does not contain a
+// list, the returned error will be ErrExpectedList. When the list's
+// end has been reached, any Stream operation will return EOL.
+func (s *Stream) List() (size uint64, err error) {
+	kind, size, err := s.Kind()
+	if err != nil {
+		return 0, err
+	}
+	if kind != List {
+		return 0, ErrExpectedList
+	}
+	s.stack = append(s.stack, listpos{0, size})
+	s.kind = -1
+	s.size = 0
+	return size, nil
+}
+
+// ListEnd returns to the enclosing list.
+// The input reader must be positioned at the end of a list.
+func (s *Stream) ListEnd() error {
+	if len(s.stack) == 0 {
+		return errNotInList
+	}
+	tos := s.stack[len(s.stack)-1]
+	if tos.pos != tos.size {
+		return errNotAtEOL
+	}
+	s.stack = s.stack[:len(s.stack)-1] // pop
+	if len(s.stack) > 0 {
+		s.stack[len(s.stack)-1].pos += tos.size
+	}
+	s.kind = -1
+	s.size = 0
+	return nil
+}
+
+// Decode decodes a value and stores the result in the value pointed
+// to by val. Please see the documentation for the Decode function
+// to learn about the decoding rules.
+func (s *Stream) Decode(val interface{}) error {
+	if val == nil {
+		return errDecodeIntoNil
+	}
+	rval := reflect.ValueOf(val)
+	rtyp := rval.Type()
+	if rtyp.Kind() != reflect.Ptr {
+		return errNoPointer
+	}
+	if rval.IsNil() {
+		return errDecodeIntoNil
+	}
+	info, err := cachedTypeInfo(rtyp.Elem())
+	if err != nil {
+		return err
+	}
+	return info.decoder(s, rval.Elem())
+}
+
+// Kind returns the kind and size of the next value in the
+// input stream.
+//
+// The returned size is the number of bytes that make up the value.
+// For kind == Byte, the size is zero because the value is
+// contained in the type tag.
+//
+// The first call to Kind will read size information from the input
+// reader and leave it positioned at the start of the actual bytes of
+// the value. Subsequent calls to Kind (until the value is decoded)
+// will not advance the input reader and return cached information.
+func (s *Stream) Kind() (kind Kind, size uint64, err error) {
+	var tos *listpos
+	if len(s.stack) > 0 {
+		tos = &s.stack[len(s.stack)-1]
+	}
+	if s.kind < 0 {
+		if tos != nil && tos.pos == tos.size {
+			return 0, 0, EOL
+		}
+		kind, size, err = s.readKind()
+		if err != nil {
+			return 0, 0, err
+		}
+		s.kind, s.size = kind, size
+	}
+	if tos != nil && tos.pos+s.size > tos.size {
+		return 0, 0, ErrElemTooLarge
+	}
+	return s.kind, s.size, nil
+}
+
+func (s *Stream) readKind() (kind Kind, size uint64, err error) {
+	b, err := s.readByte()
+	if err != nil {
+		return 0, 0, err
+	}
+	s.byteval = 0
+	switch {
+	case b < 0x80:
+		// For a single byte whose value is in the [0x00, 0x7F] range, that byte
+		// is its own RLP encoding.
+		s.byteval = b
+		return Byte, 0, nil
+	case b < 0xB8:
+		// Otherwise, if a string is 0-55 bytes long,
+		// the RLP encoding consists of a single byte with value 0x80 plus the
+		// length of the string followed by the string. The range of the first
+		// byte is thus [0x80, 0xB7].
+		return String, uint64(b - 0x80), nil
+	case b < 0xC0:
+		// If a string is more than 55 bytes long, the
+		// RLP encoding consists of a single byte with value 0xB7 plus the length
+		// of the length of the string in binary form, followed by the length of
+		// the string, followed by the string. For example, a length-1024 string
+		// would be encoded as 0xB90400 followed by the string. The range of
+		// the first byte is thus [0xB8, 0xBF].
+		size, err = s.readUint(b - 0xB7)
+		return String, size, err
+	case b < 0xF8:
+		// If the total payload of a list
+		// (i.e. the combined length of all its items) is 0-55 bytes long, the
+		// RLP encoding consists of a single byte with value 0xC0 plus the length
+		// of the list followed by the concatenation of the RLP encodings of the
+		// items. The range of the first byte is thus [0xC0, 0xF7].
+		return List, uint64(b - 0xC0), nil
+	default:
+		// If the total payload of a list is more than 55 bytes long,
+		// the RLP encoding consists of a single byte with value 0xF7
+		// plus the length of the length of the payload in binary
+		// form, followed by the length of the payload, followed by
+		// the concatenation of the RLP encodings of the items. The
+		// range of the first byte is thus [0xF8, 0xFF].
+		size, err = s.readUint(b - 0xF7)
+		return List, size, err
+	}
+}
+
+func (s *Stream) readUint(size byte) (uint64, error) {
+	if size == 1 {
+		b, err := s.readByte()
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+		return uint64(b), err
+	}
+	start := int(8 - size)
+	for i := 0; i < start; i++ {
+		s.uintbuf[i] = 0
+	}
+	err := s.readFull(s.uintbuf[start:])
+	return binary.BigEndian.Uint64(s.uintbuf), err
+}
+
+func (s *Stream) readFull(buf []byte) (err error) {
+	s.willRead(uint64(len(buf)))
+	var nn, n int
+	for n < len(buf) && err == nil {
+		nn, err = s.r.Read(buf[n:])
+		n += nn
+	}
+	if err == io.EOF {
+		err = io.ErrUnexpectedEOF
+	}
+	return err
+}
+
+func (s *Stream) readByte() (byte, error) {
+	s.willRead(1)
+	b, err := s.r.ReadByte()
+	if len(s.stack) > 0 && err == io.EOF {
+		err = io.ErrUnexpectedEOF
+	}
+	return b, err
+}
+
+func (s *Stream) willRead(n uint64) {
+	s.kind = -1 // rearm Kind
+	if len(s.stack) > 0 {
+		s.stack[len(s.stack)-1].pos += n
+	}
+}
diff --git a/rlp/decode_test.go b/rlp/decode_test.go
new file mode 100644
index 000000000..5cb42b870
--- /dev/null
+++ b/rlp/decode_test.go
@@ -0,0 +1,469 @@
+package rlp
+
+import (
+	"bytes"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"math/big"
+	"reflect"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+)
+
+func TestStreamKind(t *testing.T) {
+	tests := []struct {
+		input    string
+		wantKind Kind
+		wantLen  uint64
+	}{
+		{"00", Byte, 0},
+		{"01", Byte, 0},
+		{"7F", Byte, 0},
+		{"80", String, 0},
+		{"B7", String, 55},
+		{"B800", String, 0},
+		{"B90400", String, 1024},
+		{"BA000400", String, 1024},
+		{"BB00000400", String, 1024},
+		{"BFFFFFFFFFFFFFFFFF", String, ^uint64(0)},
+		{"C0", List, 0},
+		{"C8", List, 8},
+		{"F7", List, 55},
+		{"F800", List, 0},
+		{"F804", List, 4},
+		{"F90400", List, 1024},
+		{"FFFFFFFFFFFFFFFFFF", List, ^uint64(0)},
+	}
+
+	for i, test := range tests {
+		s := NewStream(bytes.NewReader(unhex(test.input)))
+		kind, len, err := s.Kind()
+		if err != nil {
+			t.Errorf("test %d: Type returned error: %v", i, err)
+			continue
+		}
+		if kind != test.wantKind {
+			t.Errorf("test %d: kind mismatch: got %d, want %d", i, kind, test.wantKind)
+		}
+		if len != test.wantLen {
+			t.Errorf("test %d: len mismatch: got %d, want %d", i, len, test.wantLen)
+		}
+	}
+}
+
+func TestStreamErrors(t *testing.T) {
+	type calls []string
+	tests := []struct {
+		string
+		calls
+		error
+	}{
+		{"", calls{"Kind"}, io.EOF},
+		{"", calls{"List"}, io.EOF},
+		{"", calls{"Uint"}, io.EOF},
+		{"C0", calls{"Bytes"}, ErrExpectedString},
+		{"C0", calls{"Uint"}, ErrExpectedString},
+		{"81", calls{"Bytes"}, io.ErrUnexpectedEOF},
+		{"81", calls{"Uint"}, io.ErrUnexpectedEOF},
+		{"BFFFFFFFFFFFFFFF", calls{"Bytes"}, io.ErrUnexpectedEOF},
+		{"89000000000000000001", calls{"Uint"}, errors.New("rlp: string is larger than 64 bits")},
+		{"00", calls{"List"}, ErrExpectedList},
+		{"80", calls{"List"}, ErrExpectedList},
+		{"C0", calls{"List", "Uint"}, EOL},
+		{"C801", calls{"List", "Uint", "Uint"}, io.ErrUnexpectedEOF},
+		{"C8C9", calls{"List", "Kind"}, ErrElemTooLarge},
+		{"C3C2010201", calls{"List", "List", "Uint", "Uint", "ListEnd", "Uint"}, EOL},
+		{"00", calls{"ListEnd"}, errNotInList},
+		{"C40102", calls{"List", "Uint", "ListEnd"}, errNotAtEOL},
+	}
+
+testfor:
+	for i, test := range tests {
+		s := NewStream(bytes.NewReader(unhex(test.string)))
+		rs := reflect.ValueOf(s)
+		for j, call := range test.calls {
+			fval := rs.MethodByName(call)
+			ret := fval.Call(nil)
+			err := "<nil>"
+			if lastret := ret[len(ret)-1].Interface(); lastret != nil {
+				err = lastret.(error).Error()
+			}
+			if j == len(test.calls)-1 {
+				if err != test.error.Error() {
+					t.Errorf("test %d: last call (%s) error mismatch\ngot:  %s\nwant: %v",
+						i, call, err, test.error)
+				}
+			} else if err != "<nil>" {
+				t.Errorf("test %d: call %d (%s) unexpected error: %q", i, j, call, err)
+				continue testfor
+			}
+		}
+	}
+}
+
+func TestStreamList(t *testing.T) {
+	s := NewStream(bytes.NewReader(unhex("C80102030405060708")))
+
+	len, err := s.List()
+	if err != nil {
+		t.Fatalf("List error: %v", err)
+	}
+	if len != 8 {
+		t.Fatalf("List returned invalid length, got %d, want 8", len)
+	}
+
+	for i := uint64(1); i <= 8; i++ {
+		v, err := s.Uint()
+		if err != nil {
+			t.Fatalf("Uint error: %v", err)
+		}
+		if i != v {
+			t.Errorf("Uint returned wrong value, got %d, want %d", v, i)
+		}
+	}
+
+	if _, err := s.Uint(); err != EOL {
+		t.Errorf("Uint error mismatch, got %v, want %v", err, EOL)
+	}
+	if err = s.ListEnd(); err != nil {
+		t.Fatalf("ListEnd error: %v", err)
+	}
+}
+
+func TestDecodeErrors(t *testing.T) {
+	r := bytes.NewReader(nil)
+
+	if err := Decode(r, nil); err != errDecodeIntoNil {
+		t.Errorf("Decode(r, nil) error mismatch, got %q, want %q", err, errDecodeIntoNil)
+	}
+
+	var nilptr *struct{}
+	if err := Decode(r, nilptr); err != errDecodeIntoNil {
+		t.Errorf("Decode(r, nilptr) error mismatch, got %q, want %q", err, errDecodeIntoNil)
+	}
+
+	if err := Decode(r, struct{}{}); err != errNoPointer {
+		t.Errorf("Decode(r, struct{}{}) error mismatch, got %q, want %q", err, errNoPointer)
+	}
+
+	expectErr := "rlp: type chan bool is not RLP-serializable"
+	if err := Decode(r, new(chan bool)); err == nil || err.Error() != expectErr {
+		t.Errorf("Decode(r, new(chan bool)) error mismatch, got %q, want %q", err, expectErr)
+	}
+
+	if err := Decode(r, new(int)); err != io.EOF {
+		t.Errorf("Decode(r, new(int)) error mismatch, got %q, want %q", err, io.EOF)
+	}
+}
+
+type decodeTest struct {
+	input string
+	ptr   interface{}
+	value interface{}
+	error error
+}
+
+type simplestruct struct {
+	A int
+	B string
+}
+
+type recstruct struct {
+	I     int
+	Child *recstruct
+}
+
+var sharedByteArray [5]byte
+
+var (
+	veryBigInt = big.NewInt(0).Add(
+		big.NewInt(0).Lsh(big.NewInt(0xFFFFFFFFFFFFFF), 16),
+		big.NewInt(0xFFFF),
+	)
+)
+
+var decodeTests = []decodeTest{
+	// integers
+	{input: "05", ptr: new(uint32), value: uint32(5)},
+	{input: "80", ptr: new(uint32), value: uint32(0)},
+	{input: "8105", ptr: new(uint32), value: uint32(5)},
+	{input: "820505", ptr: new(uint32), value: uint32(0x0505)},
+	{input: "83050505", ptr: new(uint32), value: uint32(0x050505)},
+	{input: "8405050505", ptr: new(uint32), value: uint32(0x05050505)},
+	{input: "850505050505", ptr: new(uint32), error: errors.New("rlp: string is larger than 32 bits")},
+	{input: "C0", ptr: new(uint32), error: ErrExpectedString},
+
+	// slices
+	{input: "C0", ptr: new([]int), value: []int{}},
+	{input: "C80102030405060708", ptr: new([]int), value: []int{1, 2, 3, 4, 5, 6, 7, 8}},
+
+	// arrays
+	{input: "C0", ptr: new([5]int), value: [5]int{}},
+	{input: "C50102030405", ptr: new([5]int), value: [5]int{1, 2, 3, 4, 5}},
+	{input: "C6010203040506", ptr: new([5]int), error: errors.New("rlp: input List has more than 5 elements")},
+
+	// byte slices
+	{input: "01", ptr: new([]byte), value: []byte{1}},
+	{input: "80", ptr: new([]byte), value: []byte{}},
+	{input: "8D6162636465666768696A6B6C6D", ptr: new([]byte), value: []byte("abcdefghijklm")},
+	{input: "C0", ptr: new([]byte), value: []byte{}},
+	{input: "C3010203", ptr: new([]byte), value: []byte{1, 2, 3}},
+	{input: "C3820102", ptr: new([]byte), error: errors.New("rlp: string is larger than 8 bits")},
+
+	// byte arrays
+	{input: "01", ptr: new([5]byte), value: [5]byte{1}},
+	{input: "80", ptr: new([5]byte), value: [5]byte{}},
+	{input: "850102030405", ptr: new([5]byte), value: [5]byte{1, 2, 3, 4, 5}},
+	{input: "C0", ptr: new([5]byte), value: [5]byte{}},
+	{input: "C3010203", ptr: new([5]byte), value: [5]byte{1, 2, 3, 0, 0}},
+	{input: "C3820102", ptr: new([5]byte), error: errors.New("rlp: string is larger than 8 bits")},
+	{input: "86010203040506", ptr: new([5]byte), error: errStringDoesntFitArray},
+	{input: "850101", ptr: new([5]byte), error: io.ErrUnexpectedEOF},
+
+	// byte array reuse (should be zeroed)
+	{input: "850102030405", ptr: &sharedByteArray, value: [5]byte{1, 2, 3, 4, 5}},
+	{input: "8101", ptr: &sharedByteArray, value: [5]byte{1}}, // kind: String
+	{input: "850102030405", ptr: &sharedByteArray, value: [5]byte{1, 2, 3, 4, 5}},
+	{input: "01", ptr: &sharedByteArray, value: [5]byte{1}}, // kind: Byte
+	{input: "C3010203", ptr: &sharedByteArray, value: [5]byte{1, 2, 3, 0, 0}},
+	{input: "C101", ptr: &sharedByteArray, value: [5]byte{1}}, // kind: List
+
+	// zero sized byte arrays
+	{input: "80", ptr: new([0]byte), value: [0]byte{}},
+	{input: "C0", ptr: new([0]byte), value: [0]byte{}},
+	{input: "01", ptr: new([0]byte), error: errStringDoesntFitArray},
+	{input: "8101", ptr: new([0]byte), error: errStringDoesntFitArray},
+
+	// strings
+	{input: "00", ptr: new(string), value: "\000"},
+	{input: "8D6162636465666768696A6B6C6D", ptr: new(string), value: "abcdefghijklm"},
+	{input: "C0", ptr: new(string), error: ErrExpectedString},
+
+	// big ints
+	{input: "01", ptr: new(*big.Int), value: big.NewInt(1)},
+	{input: "89FFFFFFFFFFFFFFFFFF", ptr: new(*big.Int), value: veryBigInt},
+	{input: "10", ptr: new(big.Int), value: *big.NewInt(16)}, // non-pointer also works
+	{input: "C0", ptr: new(*big.Int), error: ErrExpectedString},
+
+	// structs
+	{input: "C0", ptr: new(simplestruct), value: simplestruct{0, ""}},
+	{input: "C105", ptr: new(simplestruct), value: simplestruct{5, ""}},
+	{input: "C50583343434", ptr: new(simplestruct), value: simplestruct{5, "444"}},
+	{input: "C3010101", ptr: new(simplestruct), error: errors.New("rlp: input List has too many elements")},
+	{
+		input: "C501C302C103",
+		ptr:   new(recstruct),
+		value: recstruct{1, &recstruct{2, &recstruct{3, nil}}},
+	},
+
+	// pointers
+	{input: "00", ptr: new(*int), value: (*int)(nil)},
+	{input: "80", ptr: new(*int), value: (*int)(nil)},
+	{input: "C0", ptr: new(*int), value: (*int)(nil)},
+	{input: "07", ptr: new(*int), value: intp(7)},
+	{input: "8108", ptr: new(*int), value: intp(8)},
+	{input: "C109", ptr: new(*[]int), value: &[]int{9}},
+	{input: "C58403030303", ptr: new(*[][]byte), value: &[][]byte{{3, 3, 3, 3}}},
+
+	// interface{}
+	{input: "00", ptr: new(interface{}), value: []byte{0}},
+	{input: "01", ptr: new(interface{}), value: []byte{1}},
+	{input: "80", ptr: new(interface{}), value: []byte{}},
+	{input: "850505050505", ptr: new(interface{}), value: []byte{5, 5, 5, 5, 5}},
+	{input: "C0", ptr: new(interface{}), value: []interface{}{}},
+	{input: "C50183040404", ptr: new(interface{}), value: []interface{}{[]byte{1}, []byte{4, 4, 4}}},
+}
+
+func intp(i int) *int { return &i }
+
+func TestDecode(t *testing.T) {
+	for i, test := range decodeTests {
+		input, err := hex.DecodeString(test.input)
+		if err != nil {
+			t.Errorf("test %d: invalid hex input %q", i, test.input)
+			continue
+		}
+		err = Decode(bytes.NewReader(input), test.ptr)
+		if err != nil && test.error == nil {
+			t.Errorf("test %d: unexpected Decode error: %v\ndecoding into %T\ninput %q",
+				i, err, test.ptr, test.input)
+			continue
+		}
+		if test.error != nil && fmt.Sprint(err) != fmt.Sprint(test.error) {
+			t.Errorf("test %d: Decode error mismatch\ngot  %v\nwant %v\ndecoding into %T\ninput %q",
+				i, err, test.error, test.ptr, test.input)
+			continue
+		}
+		deref := reflect.ValueOf(test.ptr).Elem().Interface()
+		if err == nil && !reflect.DeepEqual(deref, test.value) {
+			t.Errorf("test %d: value mismatch\ngot  %#v\nwant %#v\ndecoding into %T\ninput %q",
+				i, deref, test.value, test.ptr, test.input)
+		}
+	}
+}
+
+type testDecoder struct{ called bool }
+
+func (t *testDecoder) DecodeRLP(s *Stream) error {
+	if _, err := s.Uint(); err != nil {
+		return err
+	}
+	t.called = true
+	return nil
+}
+
+func TestDecodeDecoder(t *testing.T) {
+	var s struct {
+		T1 testDecoder
+		T2 *testDecoder
+		T3 **testDecoder
+	}
+	if err := Decode(bytes.NewReader(unhex("C3010203")), &s); err != nil {
+		t.Fatalf("Decode error: %v", err)
+	}
+
+	if !s.T1.called {
+		t.Errorf("DecodeRLP was not called for (non-pointer) testDecoder")
+	}
+
+	if s.T2 == nil {
+		t.Errorf("*testDecoder has not been allocated")
+	} else if !s.T2.called {
+		t.Errorf("DecodeRLP was not called for *testDecoder")
+	}
+
+	if s.T3 == nil || *s.T3 == nil {
+		t.Errorf("**testDecoder has not been allocated")
+	} else if !(*s.T3).called {
+		t.Errorf("DecodeRLP was not called for **testDecoder")
+	}
+}
+
+type byteDecoder byte
+
+func (bd *byteDecoder) DecodeRLP(s *Stream) error {
+	_, err := s.Uint()
+	*bd = 255
+	return err
+}
+
+func (bd byteDecoder) called() bool {
+	return bd == 255
+}
+
+// This test verifies that the byte slice/byte array logic
+// does not kick in for element types implementing Decoder.
+func TestDecoderInByteSlice(t *testing.T) {
+	var slice []byteDecoder
+	if err := Decode(bytes.NewReader(unhex("C101")), &slice); err != nil {
+		t.Errorf("unexpected Decode error %v", err)
+	} else if !slice[0].called() {
+		t.Errorf("DecodeRLP not called for slice element")
+	}
+
+	var array [1]byteDecoder
+	if err := Decode(bytes.NewReader(unhex("C101")), &array); err != nil {
+		t.Errorf("unexpected Decode error %v", err)
+	} else if !array[0].called() {
+		t.Errorf("DecodeRLP not called for array element")
+	}
+}
+
+func ExampleDecode() {
+	input, _ := hex.DecodeString("C90A1486666F6F626172")
+
+	type example struct {
+		A, B    int
+		private int // private fields are ignored
+		String  string
+	}
+
+	var s example
+	err := Decode(bytes.NewReader(input), &s)
+	if err != nil {
+		fmt.Printf("Error: %v\n", err)
+	} else {
+		fmt.Printf("Decoded value: %#v\n", s)
+	}
+	// Output:
+	// Decoded value: rlp.example{A:10, B:20, private:0, String:"foobar"}
+}
+
+func ExampleStream() {
+	input, _ := hex.DecodeString("C90A1486666F6F626172")
+	s := NewStream(bytes.NewReader(input))
+
+	// Check what kind of value lies ahead
+	kind, size, _ := s.Kind()
+	fmt.Printf("Kind: %v size:%d\n", kind, size)
+
+	// Enter the list
+	if _, err := s.List(); err != nil {
+		fmt.Printf("List error: %v\n", err)
+		return
+	}
+
+	// Decode elements
+	fmt.Println(s.Uint())
+	fmt.Println(s.Uint())
+	fmt.Println(s.Bytes())
+
+	// Acknowledge end of list
+	if err := s.ListEnd(); err != nil {
+		fmt.Printf("ListEnd error: %v\n", err)
+	}
+	// Output:
+	// Kind: List size:9
+	// 10 <nil>
+	// 20 <nil>
+	// [102 111 111 98 97 114] <nil>
+}
+
+func BenchmarkDecode(b *testing.B) {
+	enc := encTest(90000)
+	b.SetBytes(int64(len(enc)))
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		var s []int
+		r := bytes.NewReader(enc)
+		if err := Decode(r, &s); err != nil {
+			b.Fatalf("Decode error: %v", err)
+		}
+	}
+}
+
+func BenchmarkDecodeIntSliceReuse(b *testing.B) {
+	enc := encTest(100000)
+	b.SetBytes(int64(len(enc)))
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	var s []int
+	for i := 0; i < b.N; i++ {
+		r := bytes.NewReader(enc)
+		if err := Decode(r, &s); err != nil {
+			b.Fatalf("Decode error: %v", err)
+		}
+	}
+}
+
+func encTest(n int) []byte {
+	s := make([]interface{}, n)
+	for i := 0; i < n; i++ {
+		s[i] = i
+	}
+	return ethutil.Encode(s)
+}
+
+func unhex(str string) []byte {
+	b, err := hex.DecodeString(str)
+	if err != nil {
+		panic(fmt.Sprintf("invalid hex string: %q", str))
+	}
+	return b
+}
diff --git a/rlp/doc.go b/rlp/doc.go
new file mode 100644
index 000000000..aab98ea43
--- /dev/null
+++ b/rlp/doc.go
@@ -0,0 +1,17 @@
+/*
+Package rlp implements the RLP serialization format.
+
+The purpose of RLP (Recursive Linear Prefix) qis to encode arbitrarily
+nested arrays of binary data, and RLP is the main encoding method used
+to serialize objects in Ethereum. The only purpose of RLP is to encode
+structure; encoding specific atomic data types (eg. strings, ints,
+floats) is left up to higher-order protocols; in Ethereum integers
+must be represented in big endian binary form with no leading zeroes
+(thus making the integer value zero be equivalent to the empty byte
+array).
+
+RLP values are distinguished by a type tag. The type tag precedes the
+value in the input stream and defines the size and kind of the bytes
+that follow.
+*/
+package rlp
diff --git a/rlp/typecache.go b/rlp/typecache.go
new file mode 100644
index 000000000..75dbb43c2
--- /dev/null
+++ b/rlp/typecache.go
@@ -0,0 +1,91 @@
+package rlp
+
+import (
+	"fmt"
+	"math/big"
+	"reflect"
+	"sync"
+)
+
+type decoder func(*Stream, reflect.Value) error
+
+type typeinfo struct {
+	decoder
+}
+
+var (
+	typeCacheMutex sync.RWMutex
+	typeCache      = make(map[reflect.Type]*typeinfo)
+)
+
+func cachedTypeInfo(typ reflect.Type) (*typeinfo, error) {
+	typeCacheMutex.RLock()
+	info := typeCache[typ]
+	typeCacheMutex.RUnlock()
+	if info != nil {
+		return info, nil
+	}
+	// not in the cache, need to generate info for this type.
+	typeCacheMutex.Lock()
+	defer typeCacheMutex.Unlock()
+	return cachedTypeInfo1(typ)
+}
+
+func cachedTypeInfo1(typ reflect.Type) (*typeinfo, error) {
+	info := typeCache[typ]
+	if info != nil {
+		// another goroutine got the write lock first
+		return info, nil
+	}
+	// put a dummmy value into the cache before generating.
+	// if the generator tries to lookup itself, it will get
+	// the dummy value and won't call itself recursively.
+	typeCache[typ] = new(typeinfo)
+	info, err := genTypeInfo(typ)
+	if err != nil {
+		// remove the dummy value if the generator fails
+		delete(typeCache, typ)
+		return nil, err
+	}
+	*typeCache[typ] = *info
+	return typeCache[typ], err
+}
+
+var (
+	decoderInterface = reflect.TypeOf(new(Decoder)).Elem()
+	bigInt           = reflect.TypeOf(big.Int{})
+)
+
+func genTypeInfo(typ reflect.Type) (info *typeinfo, err error) {
+	info = new(typeinfo)
+	kind := typ.Kind()
+	switch {
+	case typ.Implements(decoderInterface):
+		info.decoder = decodeDecoder
+	case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(decoderInterface):
+		info.decoder = decodeDecoderNoPtr
+	case typ.AssignableTo(reflect.PtrTo(bigInt)):
+		info.decoder = decodeBigInt
+	case typ.AssignableTo(bigInt):
+		info.decoder = decodeBigIntNoPtr
+	case isInteger(kind):
+		info.decoder = makeNumDecoder(typ)
+	case kind == reflect.String:
+		info.decoder = decodeString
+	case kind == reflect.Slice || kind == reflect.Array:
+		info.decoder, err = makeListDecoder(typ)
+	case kind == reflect.Struct:
+		info.decoder, err = makeStructDecoder(typ)
+	case kind == reflect.Ptr:
+		info.decoder, err = makePtrDecoder(typ)
+	case kind == reflect.Interface && typ.NumMethod() == 0:
+		info.decoder = decodeInterface
+	default:
+		err = fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
+	}
+	return info, err
+}
+
+func isInteger(k reflect.Kind) bool {
+	return k >= reflect.Int && k <= reflect.Uintptr
+}
-- 
cgit v1.2.3


From bd0a50fdc3550eba979b132a92960f1e08110033 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Mon, 17 Nov 2014 12:02:08 +0100
Subject: rlp: fix pointer reuse

---
 rlp/decode.go      |  1 +
 rlp/decode_test.go | 11 +++++++++--
 2 files changed, 10 insertions(+), 2 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 1a51e7130..96d912f56 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -309,6 +309,7 @@ func makePtrDecoder(typ reflect.Type) (decoder, error) {
 	dec := func(s *Stream, val reflect.Value) (err error) {
 		_, size, err := s.Kind()
 		if err != nil || size == 0 && s.byteval == 0 {
+			val.Set(reflect.Zero(typ)) // set to nil
 			return err
 		}
 		newval := val
diff --git a/rlp/decode_test.go b/rlp/decode_test.go
index 5cb42b870..eb1618299 100644
--- a/rlp/decode_test.go
+++ b/rlp/decode_test.go
@@ -176,8 +176,6 @@ type recstruct struct {
 	Child *recstruct
 }
 
-var sharedByteArray [5]byte
-
 var (
 	veryBigInt = big.NewInt(0).Add(
 		big.NewInt(0).Lsh(big.NewInt(0xFFFFFFFFFFFFFF), 16),
@@ -185,6 +183,11 @@ var (
 	)
 )
 
+var (
+	sharedByteArray [5]byte
+	sharedPtr       = new(*int)
+)
+
 var decodeTests = []decodeTest{
 	// integers
 	{input: "05", ptr: new(uint32), value: uint32(5)},
@@ -268,6 +271,10 @@ var decodeTests = []decodeTest{
 	{input: "C109", ptr: new(*[]int), value: &[]int{9}},
 	{input: "C58403030303", ptr: new(*[][]byte), value: &[][]byte{{3, 3, 3, 3}}},
 
+	// pointer should be reset to nil
+	{input: "05", ptr: sharedPtr, value: intp(5)},
+	{input: "80", ptr: sharedPtr, value: (*int)(nil)},
+
 	// interface{}
 	{input: "00", ptr: new(interface{}), value: []byte{0}},
 	{input: "01", ptr: new(interface{}), value: []byte{1}},
-- 
cgit v1.2.3


From 5a5560f1051b51fae34e799ee8d2dfd8d1094e09 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Mon, 24 Nov 2014 19:01:25 +0100
Subject: rlp: add Stream.Reset and accept any reader (for p2p)

---
 rlp/decode.go      | 35 ++++++++++++++++++++++++++++++-----
 rlp/decode_test.go | 38 ++++++++++++++++++++++++++++++++++++--
 2 files changed, 66 insertions(+), 7 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 96d912f56..565c84790 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -1,6 +1,7 @@
 package rlp
 
 import (
+	"bufio"
 	"encoding/binary"
 	"errors"
 	"fmt"
@@ -24,8 +25,9 @@ type Decoder interface {
 	DecodeRLP(*Stream) error
 }
 
-// Decode parses RLP-encoded data from r and stores the result
-// in the value pointed to by val. Val must be a non-nil pointer.
+// Decode parses RLP-encoded data from r and stores the result in the
+// value pointed to by val. Val must be a non-nil pointer. If r does
+// not implement ByteReader, Decode will do its own buffering.
 //
 // Decode uses the following type-dependent decoding rules:
 //
@@ -66,7 +68,7 @@ type Decoder interface {
 //
 // Non-empty interface types are not supported, nor are bool, float32,
 // float64, maps, channel types and functions.
-func Decode(r ByteReader, val interface{}) error {
+func Decode(r io.Reader, val interface{}) error {
 	return NewStream(r).Decode(val)
 }
 
@@ -432,8 +434,14 @@ type Stream struct {
 
 type listpos struct{ pos, size uint64 }
 
-func NewStream(r ByteReader) *Stream {
-	return &Stream{r: r, uintbuf: make([]byte, 8), kind: -1}
+// NewStream creates a new stream reading from r.
+// If r does not implement ByteReader, the Stream will
+// introduce its own buffering.
+func NewStream(r io.Reader) *Stream {
+	s := new(Stream)
+	s.Reset(r)
+	return s
+}
 }
 
 // Bytes reads an RLP string and returns its contents as a byte slice.
@@ -543,6 +551,23 @@ func (s *Stream) Decode(val interface{}) error {
 	return info.decoder(s, rval.Elem())
 }
 
+// Reset discards any information about the current decoding context
+// and starts reading from r. If r does not also implement ByteReader,
+// Stream will do its own buffering.
+func (s *Stream) Reset(r io.Reader) {
+	bufr, ok := r.(ByteReader)
+	if !ok {
+		bufr = bufio.NewReader(r)
+	}
+	s.r = bufr
+	s.stack = s.stack[:0]
+	s.size = 0
+	s.kind = -1
+	if s.uintbuf == nil {
+		s.uintbuf = make([]byte, 8)
+	}
+}
+
 // Kind returns the kind and size of the next value in the
 // input stream.
 //
diff --git a/rlp/decode_test.go b/rlp/decode_test.go
index eb1618299..9d320564b 100644
--- a/rlp/decode_test.go
+++ b/rlp/decode_test.go
@@ -286,14 +286,14 @@ var decodeTests = []decodeTest{
 
 func intp(i int) *int { return &i }
 
-func TestDecode(t *testing.T) {
+func runTests(t *testing.T, decode func([]byte, interface{}) error) {
 	for i, test := range decodeTests {
 		input, err := hex.DecodeString(test.input)
 		if err != nil {
 			t.Errorf("test %d: invalid hex input %q", i, test.input)
 			continue
 		}
-		err = Decode(bytes.NewReader(input), test.ptr)
+		err = decode(input, test.ptr)
 		if err != nil && test.error == nil {
 			t.Errorf("test %d: unexpected Decode error: %v\ndecoding into %T\ninput %q",
 				i, err, test.ptr, test.input)
@@ -312,6 +312,40 @@ func TestDecode(t *testing.T) {
 	}
 }
 
+func TestDecodeWithByteReader(t *testing.T) {
+	runTests(t, func(input []byte, into interface{}) error {
+		return Decode(bytes.NewReader(input), into)
+	})
+}
+
+// dumbReader reads from a byte slice but does not
+// implement ReadByte.
+type dumbReader []byte
+
+func (r *dumbReader) Read(buf []byte) (n int, err error) {
+	if len(*r) == 0 {
+		return 0, io.EOF
+	}
+	n = copy(buf, *r)
+	*r = (*r)[n:]
+	return n, nil
+}
+
+func TestDecodeWithNonByteReader(t *testing.T) {
+	runTests(t, func(input []byte, into interface{}) error {
+		r := dumbReader(input)
+		return Decode(&r, into)
+	})
+}
+
+func TestDecodeStreamReset(t *testing.T) {
+	s := NewStream(nil)
+	runTests(t, func(input []byte, into interface{}) error {
+		s.Reset(bytes.NewReader(input))
+		return s.Decode(into)
+	})
+}
+
 type testDecoder struct{ called bool }
 
 func (t *testDecoder) DecodeRLP(s *Stream) error {
-- 
cgit v1.2.3


From 205af02a1f13f6712a8f30538ddf31cf0544c8d9 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Mon, 24 Nov 2014 19:02:04 +0100
Subject: rlp: add NewListStream (for p2p)

---
 rlp/decode.go      |  9 +++++++++
 rlp/decode_test.go | 18 ++++++++++++++++++
 2 files changed, 27 insertions(+)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 565c84790..3546f6106 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -442,6 +442,15 @@ func NewStream(r io.Reader) *Stream {
 	s.Reset(r)
 	return s
 }
+
+// NewListStream creates a new stream that pretends to be positioned
+// at an encoded list of the given length.
+func NewListStream(r io.Reader, len uint64) *Stream {
+	s := new(Stream)
+	s.Reset(r)
+	s.kind = List
+	s.size = len
+	return s
 }
 
 // Bytes reads an RLP string and returns its contents as a byte slice.
diff --git a/rlp/decode_test.go b/rlp/decode_test.go
index 9d320564b..d82ccbd6a 100644
--- a/rlp/decode_test.go
+++ b/rlp/decode_test.go
@@ -54,6 +54,24 @@ func TestStreamKind(t *testing.T) {
 	}
 }
 
+func TestNewListStream(t *testing.T) {
+	ls := NewListStream(bytes.NewReader(unhex("0101010101")), 3)
+	if k, size, err := ls.Kind(); k != List || size != 3 || err != nil {
+		t.Errorf("Kind() returned (%v, %d, %v), expected (List, 3, nil)", k, size, err)
+	}
+	if size, err := ls.List(); size != 3 || err != nil {
+		t.Errorf("List() returned (%d, %v), expected (3, nil)", size, err)
+	}
+	for i := 0; i < 3; i++ {
+		if val, err := ls.Uint(); val != 1 || err != nil {
+			t.Errorf("Uint() returned (%d, %v), expected (1, nil)", val, err)
+		}
+	}
+	if err := ls.ListEnd(); err != nil {
+		t.Errorf("ListEnd() returned %v, expected (3, nil)", err)
+	}
+}
+
 func TestStreamErrors(t *testing.T) {
 	type calls []string
 	tests := []struct {
-- 
cgit v1.2.3


From f816fdcb692d64cd5196b08c678550060e7e7df7 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Tue, 25 Nov 2014 16:00:48 +0100
Subject: rlp: include target type in decoder error messages

---
 rlp/decode.go      | 37 ++++++++++++++++++++++++++-----------
 rlp/decode_test.go | 33 ++++++++++++++++-----------------
 2 files changed, 42 insertions(+), 28 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 3546f6106..7d95af02b 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -72,6 +72,15 @@ func Decode(r io.Reader, val interface{}) error {
 	return NewStream(r).Decode(val)
 }
 
+type decodeError struct {
+	msg string
+	typ reflect.Type
+}
+
+func (err decodeError) Error() string {
+	return fmt.Sprintf("rlp: %s for %v", err.msg, err.typ)
+}
+
 func makeNumDecoder(typ reflect.Type) decoder {
 	kind := typ.Kind()
 	switch {
@@ -85,8 +94,11 @@ func makeNumDecoder(typ reflect.Type) decoder {
 }
 
 func decodeInt(s *Stream, val reflect.Value) error {
-	num, err := s.uint(val.Type().Bits())
-	if err != nil {
+	typ := val.Type()
+	num, err := s.uint(typ.Bits())
+	if err == errUintOverflow {
+		return decodeError{"input string too long", typ}
+	} else if err != nil {
 		return err
 	}
 	val.SetInt(int64(num))
@@ -94,8 +106,11 @@ func decodeInt(s *Stream, val reflect.Value) error {
 }
 
 func decodeUint(s *Stream, val reflect.Value) error {
-	num, err := s.uint(val.Type().Bits())
-	if err != nil {
+	typ := val.Type()
+	num, err := s.uint(typ.Bits())
+	if err == errUintOverflow {
+		return decodeError{"input string too big", typ}
+	} else if err != nil {
 		return err
 	}
 	val.SetUint(num)
@@ -177,7 +192,7 @@ func decodeList(s *Stream, val reflect.Value, elemdec decoder, maxelem int) erro
 	i := 0
 	for {
 		if i > maxelem {
-			return fmt.Errorf("rlp: input List has more than %d elements", maxelem)
+			return decodeError{"input list has too many elements", val.Type()}
 		}
 		if val.Kind() == reflect.Slice {
 			// grow slice if necessary
@@ -228,8 +243,6 @@ func decodeByteSlice(s *Stream, val reflect.Value) error {
 	return err
 }
 
-var errStringDoesntFitArray = errors.New("rlp: string value doesn't fit into target array")
-
 func decodeByteArray(s *Stream, val reflect.Value) error {
 	kind, size, err := s.Kind()
 	if err != nil {
@@ -238,14 +251,14 @@ func decodeByteArray(s *Stream, val reflect.Value) error {
 	switch kind {
 	case Byte:
 		if val.Len() == 0 {
-			return errStringDoesntFitArray
+			return decodeError{"input string too big", val.Type()}
 		}
 		bv, _ := s.Uint()
 		val.Index(0).SetUint(bv)
 		zero(val, 1)
 	case String:
 		if uint64(val.Len()) < size {
-			return errStringDoesntFitArray
+			return decodeError{"input string too big", val.Type()}
 		}
 		slice := val.Slice(0, int(size)).Interface().([]byte)
 		if err := s.readFull(slice); err != nil {
@@ -295,7 +308,7 @@ func makeStructDecoder(typ reflect.Type) (decoder, error) {
 			}
 		}
 		if err = s.ListEnd(); err == errNotAtEOL {
-			err = errors.New("rlp: input List has too many elements")
+			err = decodeError{"input list has too many elements", typ}
 		}
 		return err
 	}
@@ -476,6 +489,8 @@ func (s *Stream) Bytes() ([]byte, error) {
 	}
 }
 
+var errUintOverflow = errors.New("rlp: uint overflow")
+
 // Uint reads an RLP string of up to 8 bytes and returns its contents
 // as an unsigned integer. If the input does not contain an RLP string, the
 // returned error will be ErrExpectedString.
@@ -494,7 +509,7 @@ func (s *Stream) uint(maxbits int) (uint64, error) {
 		return uint64(s.byteval), nil
 	case String:
 		if size > uint64(maxbits/8) {
-			return 0, fmt.Errorf("rlp: string is larger than %d bits", maxbits)
+			return 0, errUintOverflow
 		}
 		return s.readUint(byte(size))
 	default:
diff --git a/rlp/decode_test.go b/rlp/decode_test.go
index d82ccbd6a..3b60234dd 100644
--- a/rlp/decode_test.go
+++ b/rlp/decode_test.go
@@ -3,7 +3,6 @@ package rlp
 import (
 	"bytes"
 	"encoding/hex"
-	"errors"
 	"fmt"
 	"io"
 	"math/big"
@@ -87,7 +86,7 @@ func TestStreamErrors(t *testing.T) {
 		{"81", calls{"Bytes"}, io.ErrUnexpectedEOF},
 		{"81", calls{"Uint"}, io.ErrUnexpectedEOF},
 		{"BFFFFFFFFFFFFFFF", calls{"Bytes"}, io.ErrUnexpectedEOF},
-		{"89000000000000000001", calls{"Uint"}, errors.New("rlp: string is larger than 64 bits")},
+		{"89000000000000000001", calls{"Uint"}, errUintOverflow},
 		{"00", calls{"List"}, ErrExpectedList},
 		{"80", calls{"List"}, ErrExpectedList},
 		{"C0", calls{"List", "Uint"}, EOL},
@@ -181,7 +180,7 @@ type decodeTest struct {
 	input string
 	ptr   interface{}
 	value interface{}
-	error error
+	error string
 }
 
 type simplestruct struct {
@@ -214,8 +213,8 @@ var decodeTests = []decodeTest{
 	{input: "820505", ptr: new(uint32), value: uint32(0x0505)},
 	{input: "83050505", ptr: new(uint32), value: uint32(0x050505)},
 	{input: "8405050505", ptr: new(uint32), value: uint32(0x05050505)},
-	{input: "850505050505", ptr: new(uint32), error: errors.New("rlp: string is larger than 32 bits")},
-	{input: "C0", ptr: new(uint32), error: ErrExpectedString},
+	{input: "850505050505", ptr: new(uint32), error: "rlp: input string too big for uint32"},
+	{input: "C0", ptr: new(uint32), error: ErrExpectedString.Error()},
 
 	// slices
 	{input: "C0", ptr: new([]int), value: []int{}},
@@ -224,7 +223,7 @@ var decodeTests = []decodeTest{
 	// arrays
 	{input: "C0", ptr: new([5]int), value: [5]int{}},
 	{input: "C50102030405", ptr: new([5]int), value: [5]int{1, 2, 3, 4, 5}},
-	{input: "C6010203040506", ptr: new([5]int), error: errors.New("rlp: input List has more than 5 elements")},
+	{input: "C6010203040506", ptr: new([5]int), error: "rlp: input list has too many elements for [5]int"},
 
 	// byte slices
 	{input: "01", ptr: new([]byte), value: []byte{1}},
@@ -232,7 +231,7 @@ var decodeTests = []decodeTest{
 	{input: "8D6162636465666768696A6B6C6D", ptr: new([]byte), value: []byte("abcdefghijklm")},
 	{input: "C0", ptr: new([]byte), value: []byte{}},
 	{input: "C3010203", ptr: new([]byte), value: []byte{1, 2, 3}},
-	{input: "C3820102", ptr: new([]byte), error: errors.New("rlp: string is larger than 8 bits")},
+	{input: "C3820102", ptr: new([]byte), error: "rlp: input string too big for uint8"},
 
 	// byte arrays
 	{input: "01", ptr: new([5]byte), value: [5]byte{1}},
@@ -240,9 +239,9 @@ var decodeTests = []decodeTest{
 	{input: "850102030405", ptr: new([5]byte), value: [5]byte{1, 2, 3, 4, 5}},
 	{input: "C0", ptr: new([5]byte), value: [5]byte{}},
 	{input: "C3010203", ptr: new([5]byte), value: [5]byte{1, 2, 3, 0, 0}},
-	{input: "C3820102", ptr: new([5]byte), error: errors.New("rlp: string is larger than 8 bits")},
-	{input: "86010203040506", ptr: new([5]byte), error: errStringDoesntFitArray},
-	{input: "850101", ptr: new([5]byte), error: io.ErrUnexpectedEOF},
+	{input: "C3820102", ptr: new([5]byte), error: "rlp: input string too big for uint8"},
+	{input: "86010203040506", ptr: new([5]byte), error: "rlp: input string too big for [5]uint8"},
+	{input: "850101", ptr: new([5]byte), error: io.ErrUnexpectedEOF.Error()},
 
 	// byte array reuse (should be zeroed)
 	{input: "850102030405", ptr: &sharedByteArray, value: [5]byte{1, 2, 3, 4, 5}},
@@ -255,25 +254,25 @@ var decodeTests = []decodeTest{
 	// zero sized byte arrays
 	{input: "80", ptr: new([0]byte), value: [0]byte{}},
 	{input: "C0", ptr: new([0]byte), value: [0]byte{}},
-	{input: "01", ptr: new([0]byte), error: errStringDoesntFitArray},
-	{input: "8101", ptr: new([0]byte), error: errStringDoesntFitArray},
+	{input: "01", ptr: new([0]byte), error: "rlp: input string too big for [0]uint8"},
+	{input: "8101", ptr: new([0]byte), error: "rlp: input string too big for [0]uint8"},
 
 	// strings
 	{input: "00", ptr: new(string), value: "\000"},
 	{input: "8D6162636465666768696A6B6C6D", ptr: new(string), value: "abcdefghijklm"},
-	{input: "C0", ptr: new(string), error: ErrExpectedString},
+	{input: "C0", ptr: new(string), error: ErrExpectedString.Error()},
 
 	// big ints
 	{input: "01", ptr: new(*big.Int), value: big.NewInt(1)},
 	{input: "89FFFFFFFFFFFFFFFFFF", ptr: new(*big.Int), value: veryBigInt},
 	{input: "10", ptr: new(big.Int), value: *big.NewInt(16)}, // non-pointer also works
-	{input: "C0", ptr: new(*big.Int), error: ErrExpectedString},
+	{input: "C0", ptr: new(*big.Int), error: ErrExpectedString.Error()},
 
 	// structs
 	{input: "C0", ptr: new(simplestruct), value: simplestruct{0, ""}},
 	{input: "C105", ptr: new(simplestruct), value: simplestruct{5, ""}},
 	{input: "C50583343434", ptr: new(simplestruct), value: simplestruct{5, "444"}},
-	{input: "C3010101", ptr: new(simplestruct), error: errors.New("rlp: input List has too many elements")},
+	{input: "C3010101", ptr: new(simplestruct), error: "rlp: input list has too many elements for rlp.simplestruct"},
 	{
 		input: "C501C302C103",
 		ptr:   new(recstruct),
@@ -312,12 +311,12 @@ func runTests(t *testing.T, decode func([]byte, interface{}) error) {
 			continue
 		}
 		err = decode(input, test.ptr)
-		if err != nil && test.error == nil {
+		if err != nil && test.error == "" {
 			t.Errorf("test %d: unexpected Decode error: %v\ndecoding into %T\ninput %q",
 				i, err, test.ptr, test.input)
 			continue
 		}
-		if test.error != nil && fmt.Sprint(err) != fmt.Sprint(test.error) {
+		if test.error != "" && fmt.Sprint(err) != test.error {
 			t.Errorf("test %d: Decode error mismatch\ngot  %v\nwant %v\ndecoding into %T\ninput %q",
 				i, err, test.error, test.ptr, test.input)
 			continue
-- 
cgit v1.2.3


From 4f12f0697e645a567fac9f13ed8cdb25e1218b84 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Tue, 9 Dec 2014 10:39:39 +0100
Subject: rlp: move decoder type switch to decode.go

---
 rlp/decode.go    | 33 +++++++++++++++++++++++++++++++++
 rlp/typecache.go | 35 +++--------------------------------
 2 files changed, 36 insertions(+), 32 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 7d95af02b..7acbbfa0d 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -81,6 +81,39 @@ func (err decodeError) Error() string {
 	return fmt.Sprintf("rlp: %s for %v", err.msg, err.typ)
 }
 
+var (
+	decoderInterface = reflect.TypeOf(new(Decoder)).Elem()
+	bigInt           = reflect.TypeOf(big.Int{})
+)
+
+func makeDecoder(typ reflect.Type) (dec decoder, err error) {
+	kind := typ.Kind()
+	switch {
+	case typ.Implements(decoderInterface):
+		return decodeDecoder, nil
+	case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(decoderInterface):
+		return decodeDecoderNoPtr, nil
+	case typ.AssignableTo(reflect.PtrTo(bigInt)):
+		return decodeBigInt, nil
+	case typ.AssignableTo(bigInt):
+		return decodeBigIntNoPtr, nil
+	case isInteger(kind):
+		return makeNumDecoder(typ), nil
+	case kind == reflect.String:
+		return decodeString, nil
+	case kind == reflect.Slice || kind == reflect.Array:
+		return makeListDecoder(typ)
+	case kind == reflect.Struct:
+		return makeStructDecoder(typ)
+	case kind == reflect.Ptr:
+		return makePtrDecoder(typ)
+	case kind == reflect.Interface && typ.NumMethod() == 0:
+		return decodeInterface, nil
+	default:
+		return nil, fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
+	}
+}
+
 func makeNumDecoder(typ reflect.Type) decoder {
 	kind := typ.Kind()
 	switch {
diff --git a/rlp/typecache.go b/rlp/typecache.go
index 75dbb43c2..f2595dac8 100644
--- a/rlp/typecache.go
+++ b/rlp/typecache.go
@@ -1,8 +1,6 @@
 package rlp
 
 import (
-	"fmt"
-	"math/big"
 	"reflect"
 	"sync"
 )
@@ -51,39 +49,12 @@ func cachedTypeInfo1(typ reflect.Type) (*typeinfo, error) {
 	return typeCache[typ], err
 }
 
-var (
-	decoderInterface = reflect.TypeOf(new(Decoder)).Elem()
-	bigInt           = reflect.TypeOf(big.Int{})
-)
-
 func genTypeInfo(typ reflect.Type) (info *typeinfo, err error) {
 	info = new(typeinfo)
-	kind := typ.Kind()
-	switch {
-	case typ.Implements(decoderInterface):
-		info.decoder = decodeDecoder
-	case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(decoderInterface):
-		info.decoder = decodeDecoderNoPtr
-	case typ.AssignableTo(reflect.PtrTo(bigInt)):
-		info.decoder = decodeBigInt
-	case typ.AssignableTo(bigInt):
-		info.decoder = decodeBigIntNoPtr
-	case isInteger(kind):
-		info.decoder = makeNumDecoder(typ)
-	case kind == reflect.String:
-		info.decoder = decodeString
-	case kind == reflect.Slice || kind == reflect.Array:
-		info.decoder, err = makeListDecoder(typ)
-	case kind == reflect.Struct:
-		info.decoder, err = makeStructDecoder(typ)
-	case kind == reflect.Ptr:
-		info.decoder, err = makePtrDecoder(typ)
-	case kind == reflect.Interface && typ.NumMethod() == 0:
-		info.decoder = decodeInterface
-	default:
-		err = fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
+	if info.decoder, err = makeDecoder(typ); err != nil {
+		return nil, err
 	}
-	return info, err
+	return info, nil
 }
 
 func isInteger(k reflect.Kind) bool {
-- 
cgit v1.2.3


From 93e858f88ef9a9a572c2dabd4aef8bbbd678dd97 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Tue, 9 Dec 2014 10:41:47 +0100
Subject: rlp: remove support for signed integer types

There is no agreement on how to encode negative integers
across implementations. cpp-ethereum doesn't support them either.
---
 rlp/decode.go      | 35 ++++++-----------------------------
 rlp/decode_test.go | 42 +++++++++++++++++++++---------------------
 rlp/typecache.go   |  4 ++--
 3 files changed, 29 insertions(+), 52 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 7acbbfa0d..31485ee70 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -54,7 +54,7 @@ type Decoder interface {
 // To decode into a Go string, the input must be an RLP string. The
 // bytes are taken as-is and will not necessarily be valid UTF-8.
 //
-// To decode into an integer type, the input must also be an RLP
+// To decode into an unsigned integer type, the input must also be an RLP
 // string. The bytes are interpreted as a big endian representation of
 // the integer. If the RLP string is larger than the bit size of the
 // type, Decode will return an error. Decode also supports *big.Int.
@@ -66,8 +66,9 @@ type Decoder interface {
 //	[]interface{}, for RLP lists
 //	[]byte, for RLP strings
 //
-// Non-empty interface types are not supported, nor are bool, float32,
-// float64, maps, channel types and functions.
+// Non-empty interface types are not supported, nor are booleans,
+// signed integers, floating point numbers, maps, channels and
+// functions.
 func Decode(r io.Reader, val interface{}) error {
 	return NewStream(r).Decode(val)
 }
@@ -97,8 +98,8 @@ func makeDecoder(typ reflect.Type) (dec decoder, err error) {
 		return decodeBigInt, nil
 	case typ.AssignableTo(bigInt):
 		return decodeBigIntNoPtr, nil
-	case isInteger(kind):
-		return makeNumDecoder(typ), nil
+	case isUint(kind):
+		return decodeUint, nil
 	case kind == reflect.String:
 		return decodeString, nil
 	case kind == reflect.Slice || kind == reflect.Array:
@@ -114,30 +115,6 @@ func makeDecoder(typ reflect.Type) (dec decoder, err error) {
 	}
 }
 
-func makeNumDecoder(typ reflect.Type) decoder {
-	kind := typ.Kind()
-	switch {
-	case kind <= reflect.Int64:
-		return decodeInt
-	case kind <= reflect.Uint64:
-		return decodeUint
-	default:
-		panic("fallthrough")
-	}
-}
-
-func decodeInt(s *Stream, val reflect.Value) error {
-	typ := val.Type()
-	num, err := s.uint(typ.Bits())
-	if err == errUintOverflow {
-		return decodeError{"input string too long", typ}
-	} else if err != nil {
-		return err
-	}
-	val.SetInt(int64(num))
-	return nil
-}
-
 func decodeUint(s *Stream, val reflect.Value) error {
 	typ := val.Type()
 	num, err := s.uint(typ.Bits())
diff --git a/rlp/decode_test.go b/rlp/decode_test.go
index 3b60234dd..4c030e24d 100644
--- a/rlp/decode_test.go
+++ b/rlp/decode_test.go
@@ -171,7 +171,7 @@ func TestDecodeErrors(t *testing.T) {
 		t.Errorf("Decode(r, new(chan bool)) error mismatch, got %q, want %q", err, expectErr)
 	}
 
-	if err := Decode(r, new(int)); err != io.EOF {
+	if err := Decode(r, new(uint)); err != io.EOF {
 		t.Errorf("Decode(r, new(int)) error mismatch, got %q, want %q", err, io.EOF)
 	}
 }
@@ -184,12 +184,12 @@ type decodeTest struct {
 }
 
 type simplestruct struct {
-	A int
+	A uint
 	B string
 }
 
 type recstruct struct {
-	I     int
+	I     uint
 	Child *recstruct
 }
 
@@ -202,7 +202,7 @@ var (
 
 var (
 	sharedByteArray [5]byte
-	sharedPtr       = new(*int)
+	sharedPtr       = new(*uint)
 )
 
 var decodeTests = []decodeTest{
@@ -217,13 +217,13 @@ var decodeTests = []decodeTest{
 	{input: "C0", ptr: new(uint32), error: ErrExpectedString.Error()},
 
 	// slices
-	{input: "C0", ptr: new([]int), value: []int{}},
-	{input: "C80102030405060708", ptr: new([]int), value: []int{1, 2, 3, 4, 5, 6, 7, 8}},
+	{input: "C0", ptr: new([]uint), value: []uint{}},
+	{input: "C80102030405060708", ptr: new([]uint), value: []uint{1, 2, 3, 4, 5, 6, 7, 8}},
 
 	// arrays
-	{input: "C0", ptr: new([5]int), value: [5]int{}},
-	{input: "C50102030405", ptr: new([5]int), value: [5]int{1, 2, 3, 4, 5}},
-	{input: "C6010203040506", ptr: new([5]int), error: "rlp: input list has too many elements for [5]int"},
+	{input: "C0", ptr: new([5]uint), value: [5]uint{}},
+	{input: "C50102030405", ptr: new([5]uint), value: [5]uint{1, 2, 3, 4, 5}},
+	{input: "C6010203040506", ptr: new([5]uint), error: "rlp: input list has too many elements for [5]uint"},
 
 	// byte slices
 	{input: "01", ptr: new([]byte), value: []byte{1}},
@@ -280,17 +280,17 @@ var decodeTests = []decodeTest{
 	},
 
 	// pointers
-	{input: "00", ptr: new(*int), value: (*int)(nil)},
-	{input: "80", ptr: new(*int), value: (*int)(nil)},
-	{input: "C0", ptr: new(*int), value: (*int)(nil)},
-	{input: "07", ptr: new(*int), value: intp(7)},
-	{input: "8108", ptr: new(*int), value: intp(8)},
-	{input: "C109", ptr: new(*[]int), value: &[]int{9}},
+	{input: "00", ptr: new(*uint), value: (*uint)(nil)},
+	{input: "80", ptr: new(*uint), value: (*uint)(nil)},
+	{input: "C0", ptr: new(*uint), value: (*uint)(nil)},
+	{input: "07", ptr: new(*uint), value: uintp(7)},
+	{input: "8108", ptr: new(*uint), value: uintp(8)},
+	{input: "C109", ptr: new(*[]uint), value: &[]uint{9}},
 	{input: "C58403030303", ptr: new(*[][]byte), value: &[][]byte{{3, 3, 3, 3}}},
 
 	// pointer should be reset to nil
-	{input: "05", ptr: sharedPtr, value: intp(5)},
-	{input: "80", ptr: sharedPtr, value: (*int)(nil)},
+	{input: "05", ptr: sharedPtr, value: uintp(5)},
+	{input: "80", ptr: sharedPtr, value: (*uint)(nil)},
 
 	// interface{}
 	{input: "00", ptr: new(interface{}), value: []byte{0}},
@@ -301,7 +301,7 @@ var decodeTests = []decodeTest{
 	{input: "C50183040404", ptr: new(interface{}), value: []interface{}{[]byte{1}, []byte{4, 4, 4}}},
 }
 
-func intp(i int) *int { return &i }
+func uintp(i uint) *uint { return &i }
 
 func runTests(t *testing.T, decode func([]byte, interface{}) error) {
 	for i, test := range decodeTests {
@@ -434,8 +434,8 @@ func ExampleDecode() {
 	input, _ := hex.DecodeString("C90A1486666F6F626172")
 
 	type example struct {
-		A, B    int
-		private int // private fields are ignored
+		A, B    uint
+		private uint // private fields are ignored
 		String  string
 	}
 
@@ -447,7 +447,7 @@ func ExampleDecode() {
 		fmt.Printf("Decoded value: %#v\n", s)
 	}
 	// Output:
-	// Decoded value: rlp.example{A:10, B:20, private:0, String:"foobar"}
+	// Decoded value: rlp.example{A:0xa, B:0x14, private:0x0, String:"foobar"}
 }
 
 func ExampleStream() {
diff --git a/rlp/typecache.go b/rlp/typecache.go
index f2595dac8..52e68a3c5 100644
--- a/rlp/typecache.go
+++ b/rlp/typecache.go
@@ -57,6 +57,6 @@ func genTypeInfo(typ reflect.Type) (info *typeinfo, err error) {
 	return info, nil
 }
 
-func isInteger(k reflect.Kind) bool {
-	return k >= reflect.Int && k <= reflect.Uintptr
+func isUint(k reflect.Kind) bool {
+	return k >= reflect.Uint && k <= reflect.Uintptr
 }
-- 
cgit v1.2.3


From c084a7daa58117f1864eac5130ccf3290372fd4c Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Tue, 9 Dec 2014 10:44:48 +0100
Subject: rlp: fix panic in decodeList on go 1.4+

The documentation for reflect.Value.Index states that it will
panic for out-of-bounds indices. Since go 1.4, it actually panics.
---
 rlp/decode.go | 109 ++++++++++++++++++++++++++++++++--------------------------
 1 file changed, 61 insertions(+), 48 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 31485ee70..66830b89c 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -154,8 +154,6 @@ func decodeBigInt(s *Stream, val reflect.Value) error {
 	return nil
 }
 
-const maxInt = int(^uint(0) >> 1)
-
 func makeListDecoder(typ reflect.Type) (decoder, error) {
 	etype := typ.Elem()
 	if etype.Kind() == reflect.Uint8 && !reflect.PtrTo(etype).Implements(decoderInterface) {
@@ -169,55 +167,41 @@ func makeListDecoder(typ reflect.Type) (decoder, error) {
 	if err != nil {
 		return nil, err
 	}
-	var maxLen = maxInt
+
 	if typ.Kind() == reflect.Array {
-		maxLen = typ.Len()
-	}
-	dec := func(s *Stream, val reflect.Value) error {
-		return decodeList(s, val, etypeinfo.decoder, maxLen)
+		return func(s *Stream, val reflect.Value) error {
+			return decodeListArray(s, val, etypeinfo.decoder)
+		}, nil
 	}
-	return dec, nil
+	return func(s *Stream, val reflect.Value) error {
+		return decodeListSlice(s, val, etypeinfo.decoder)
+	}, nil
 }
 
-// decodeList decodes RLP list elements into slices and arrays.
-//
-// The approach here is stolen from package json, although we differ
-// in the semantics for arrays. package json discards remaining
-// elements that would not fit into the array. We generate an error in
-// this case because we'd be losing information.
-func decodeList(s *Stream, val reflect.Value, elemdec decoder, maxelem int) error {
+func decodeListSlice(s *Stream, val reflect.Value, elemdec decoder) error {
 	size, err := s.List()
 	if err != nil {
 		return err
 	}
 	if size == 0 {
-		if val.Kind() == reflect.Slice {
-			val.Set(reflect.MakeSlice(val.Type(), 0, 0))
-		} else {
-			zero(val, 0)
-		}
+		val.Set(reflect.MakeSlice(val.Type(), 0, 0))
 		return s.ListEnd()
 	}
 
 	i := 0
-	for {
-		if i > maxelem {
-			return decodeError{"input list has too many elements", val.Type()}
-		}
-		if val.Kind() == reflect.Slice {
-			// grow slice if necessary
-			if i >= val.Cap() {
-				newcap := val.Cap() + val.Cap()/2
-				if newcap < 4 {
-					newcap = 4
-				}
-				newv := reflect.MakeSlice(val.Type(), val.Len(), newcap)
-				reflect.Copy(newv, val)
-				val.Set(newv)
-			}
-			if i >= val.Len() {
-				val.SetLen(i + 1)
+	for ; ; i++ {
+		// grow slice if necessary
+		if i >= val.Cap() {
+			newcap := val.Cap() + val.Cap()/2
+			if newcap < 4 {
+				newcap = 4
 			}
+			newv := reflect.MakeSlice(val.Type(), val.Len(), newcap)
+			reflect.Copy(newv, val)
+			val.Set(newv)
+		}
+		if i >= val.Len() {
+			val.SetLen(i + 1)
 		}
 		// decode into element
 		if err := elemdec(s, val.Index(i)); err == EOL {
@@ -225,26 +209,54 @@ func decodeList(s *Stream, val reflect.Value, elemdec decoder, maxelem int) erro
 		} else if err != nil {
 			return err
 		}
-		i++
 	}
 	if i < val.Len() {
-		if val.Kind() == reflect.Array {
-			// zero the rest of the array.
-			zero(val, i)
-		} else {
-			val.SetLen(i)
-		}
+		val.SetLen(i)
 	}
 	return s.ListEnd()
 }
 
+func decodeListArray(s *Stream, val reflect.Value, elemdec decoder) error {
+	size, err := s.List()
+	if err != nil {
+		return err
+	}
+	if size == 0 {
+		zero(val, 0)
+		return s.ListEnd()
+	}
+
+	// The approach here is stolen from package json, although we differ
+	// in the semantics for arrays. package json discards remaining
+	// elements that would not fit into the array. We generate an error in
+	// this case because we'd be losing information.
+	vlen := val.Len()
+	i := 0
+	for ; i < vlen; i++ {
+		if err := elemdec(s, val.Index(i)); err == EOL {
+			break
+		} else if err != nil {
+			return err
+		}
+		if i == vlen {
+		}
+	}
+	if i < vlen {
+		zero(val, i)
+	}
+	if err = s.ListEnd(); err == errNotAtEOL {
+		return decodeError{"input list has too many elements", val.Type()}
+	}
+	return err
+}
+
 func decodeByteSlice(s *Stream, val reflect.Value) error {
 	kind, _, err := s.Kind()
 	if err != nil {
 		return err
 	}
 	if kind == List {
-		return decodeList(s, val, decodeUint, maxInt)
+		return decodeListSlice(s, val, decodeUint)
 	}
 	b, err := s.Bytes()
 	if err == nil {
@@ -276,14 +288,15 @@ func decodeByteArray(s *Stream, val reflect.Value) error {
 		}
 		zero(val, int(size))
 	case List:
-		return decodeList(s, val, decodeUint, val.Len())
+		return decodeListArray(s, val, decodeUint)
 	}
 	return nil
 }
 
 func zero(val reflect.Value, start int) {
 	z := reflect.Zero(val.Type().Elem())
-	for i := start; i < val.Len(); i++ {
+	end := val.Len()
+	for i := start; i < end; i++ {
 		val.Index(i).Set(z)
 	}
 }
@@ -358,7 +371,7 @@ func decodeInterface(s *Stream, val reflect.Value) error {
 	}
 	if kind == List {
 		slice := reflect.New(ifsliceType).Elem()
-		if err := decodeList(s, slice, decodeInterface, maxInt); err != nil {
+		if err := decodeListSlice(s, slice, decodeInterface); err != nil {
 			return err
 		}
 		val.Set(slice)
-- 
cgit v1.2.3


From 829730dec419112a8e870e1bf0ea20736ab0d02a Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Tue, 9 Dec 2014 12:49:20 +0100
Subject: rlp: remove dead code

---
 rlp/decode.go | 2 --
 1 file changed, 2 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 66830b89c..06786eae7 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -238,8 +238,6 @@ func decodeListArray(s *Stream, val reflect.Value, elemdec decoder) error {
 		} else if err != nil {
 			return err
 		}
-		if i == vlen {
-		}
 	}
 	if i < vlen {
 		zero(val, i)
-- 
cgit v1.2.3


From 6cf4e0329c05174da7450f38dcba457c9ffea417 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Tue, 9 Dec 2014 13:55:47 +0100
Subject: rlp: display decoder target type in more error messages

Decode error messages now say "expected input list for foo.MyStruct"
instead of just "expected List".
---
 rlp/decode.go      | 42 ++++++++++++++++++++++++------------------
 rlp/decode_test.go | 18 +++++++++---------
 2 files changed, 33 insertions(+), 27 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 06786eae7..712d9fcf1 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -82,6 +82,20 @@ func (err decodeError) Error() string {
 	return fmt.Sprintf("rlp: %s for %v", err.msg, err.typ)
 }
 
+func wrapStreamError(err error, typ reflect.Type) error {
+	switch err {
+	case ErrExpectedList:
+		return decodeError{"expected input list", typ}
+	case ErrExpectedString:
+		return decodeError{"expected input string or byte", typ}
+	case errUintOverflow:
+		return decodeError{"input string too long", typ}
+	case errNotAtEOL:
+		return decodeError{"input list has too many elements", typ}
+	}
+	return err
+}
+
 var (
 	decoderInterface = reflect.TypeOf(new(Decoder)).Elem()
 	bigInt           = reflect.TypeOf(big.Int{})
@@ -118,10 +132,8 @@ func makeDecoder(typ reflect.Type) (dec decoder, err error) {
 func decodeUint(s *Stream, val reflect.Value) error {
 	typ := val.Type()
 	num, err := s.uint(typ.Bits())
-	if err == errUintOverflow {
-		return decodeError{"input string too big", typ}
-	} else if err != nil {
-		return err
+	if err != nil {
+		return wrapStreamError(err, val.Type())
 	}
 	val.SetUint(num)
 	return nil
@@ -130,7 +142,7 @@ func decodeUint(s *Stream, val reflect.Value) error {
 func decodeString(s *Stream, val reflect.Value) error {
 	b, err := s.Bytes()
 	if err != nil {
-		return err
+		return wrapStreamError(err, val.Type())
 	}
 	val.SetString(string(b))
 	return nil
@@ -143,7 +155,7 @@ func decodeBigIntNoPtr(s *Stream, val reflect.Value) error {
 func decodeBigInt(s *Stream, val reflect.Value) error {
 	b, err := s.Bytes()
 	if err != nil {
-		return err
+		return wrapStreamError(err, val.Type())
 	}
 	i := val.Interface().(*big.Int)
 	if i == nil {
@@ -181,7 +193,7 @@ func makeListDecoder(typ reflect.Type) (decoder, error) {
 func decodeListSlice(s *Stream, val reflect.Value, elemdec decoder) error {
 	size, err := s.List()
 	if err != nil {
-		return err
+		return wrapStreamError(err, val.Type())
 	}
 	if size == 0 {
 		val.Set(reflect.MakeSlice(val.Type(), 0, 0))
@@ -242,10 +254,7 @@ func decodeListArray(s *Stream, val reflect.Value, elemdec decoder) error {
 	if i < vlen {
 		zero(val, i)
 	}
-	if err = s.ListEnd(); err == errNotAtEOL {
-		return decodeError{"input list has too many elements", val.Type()}
-	}
-	return err
+	return wrapStreamError(s.ListEnd(), val.Type())
 }
 
 func decodeByteSlice(s *Stream, val reflect.Value) error {
@@ -271,14 +280,14 @@ func decodeByteArray(s *Stream, val reflect.Value) error {
 	switch kind {
 	case Byte:
 		if val.Len() == 0 {
-			return decodeError{"input string too big", val.Type()}
+			return decodeError{"input string too long", val.Type()}
 		}
 		bv, _ := s.Uint()
 		val.Index(0).SetUint(bv)
 		zero(val, 1)
 	case String:
 		if uint64(val.Len()) < size {
-			return decodeError{"input string too big", val.Type()}
+			return decodeError{"input string too long", val.Type()}
 		}
 		slice := val.Slice(0, int(size)).Interface().([]byte)
 		if err := s.readFull(slice); err != nil {
@@ -317,7 +326,7 @@ func makeStructDecoder(typ reflect.Type) (decoder, error) {
 	}
 	dec := func(s *Stream, val reflect.Value) (err error) {
 		if _, err = s.List(); err != nil {
-			return err
+			return wrapStreamError(err, typ)
 		}
 		for _, f := range fields {
 			err = f.info.decoder(s, val.Field(f.index))
@@ -328,10 +337,7 @@ func makeStructDecoder(typ reflect.Type) (decoder, error) {
 				return err
 			}
 		}
-		if err = s.ListEnd(); err == errNotAtEOL {
-			err = decodeError{"input list has too many elements", typ}
-		}
-		return err
+		return wrapStreamError(s.ListEnd(), typ)
 	}
 	return dec, nil
 }
diff --git a/rlp/decode_test.go b/rlp/decode_test.go
index 4c030e24d..7a1743937 100644
--- a/rlp/decode_test.go
+++ b/rlp/decode_test.go
@@ -213,8 +213,8 @@ var decodeTests = []decodeTest{
 	{input: "820505", ptr: new(uint32), value: uint32(0x0505)},
 	{input: "83050505", ptr: new(uint32), value: uint32(0x050505)},
 	{input: "8405050505", ptr: new(uint32), value: uint32(0x05050505)},
-	{input: "850505050505", ptr: new(uint32), error: "rlp: input string too big for uint32"},
-	{input: "C0", ptr: new(uint32), error: ErrExpectedString.Error()},
+	{input: "850505050505", ptr: new(uint32), error: "rlp: input string too long for uint32"},
+	{input: "C0", ptr: new(uint32), error: "rlp: expected input string or byte for uint32"},
 
 	// slices
 	{input: "C0", ptr: new([]uint), value: []uint{}},
@@ -231,7 +231,7 @@ var decodeTests = []decodeTest{
 	{input: "8D6162636465666768696A6B6C6D", ptr: new([]byte), value: []byte("abcdefghijklm")},
 	{input: "C0", ptr: new([]byte), value: []byte{}},
 	{input: "C3010203", ptr: new([]byte), value: []byte{1, 2, 3}},
-	{input: "C3820102", ptr: new([]byte), error: "rlp: input string too big for uint8"},
+	{input: "C3820102", ptr: new([]byte), error: "rlp: input string too long for uint8"},
 
 	// byte arrays
 	{input: "01", ptr: new([5]byte), value: [5]byte{1}},
@@ -239,8 +239,8 @@ var decodeTests = []decodeTest{
 	{input: "850102030405", ptr: new([5]byte), value: [5]byte{1, 2, 3, 4, 5}},
 	{input: "C0", ptr: new([5]byte), value: [5]byte{}},
 	{input: "C3010203", ptr: new([5]byte), value: [5]byte{1, 2, 3, 0, 0}},
-	{input: "C3820102", ptr: new([5]byte), error: "rlp: input string too big for uint8"},
-	{input: "86010203040506", ptr: new([5]byte), error: "rlp: input string too big for [5]uint8"},
+	{input: "C3820102", ptr: new([5]byte), error: "rlp: input string too long for uint8"},
+	{input: "86010203040506", ptr: new([5]byte), error: "rlp: input string too long for [5]uint8"},
 	{input: "850101", ptr: new([5]byte), error: io.ErrUnexpectedEOF.Error()},
 
 	// byte array reuse (should be zeroed)
@@ -254,19 +254,19 @@ var decodeTests = []decodeTest{
 	// zero sized byte arrays
 	{input: "80", ptr: new([0]byte), value: [0]byte{}},
 	{input: "C0", ptr: new([0]byte), value: [0]byte{}},
-	{input: "01", ptr: new([0]byte), error: "rlp: input string too big for [0]uint8"},
-	{input: "8101", ptr: new([0]byte), error: "rlp: input string too big for [0]uint8"},
+	{input: "01", ptr: new([0]byte), error: "rlp: input string too long for [0]uint8"},
+	{input: "8101", ptr: new([0]byte), error: "rlp: input string too long for [0]uint8"},
 
 	// strings
 	{input: "00", ptr: new(string), value: "\000"},
 	{input: "8D6162636465666768696A6B6C6D", ptr: new(string), value: "abcdefghijklm"},
-	{input: "C0", ptr: new(string), error: ErrExpectedString.Error()},
+	{input: "C0", ptr: new(string), error: "rlp: expected input string or byte for string"},
 
 	// big ints
 	{input: "01", ptr: new(*big.Int), value: big.NewInt(1)},
 	{input: "89FFFFFFFFFFFFFFFFFF", ptr: new(*big.Int), value: veryBigInt},
 	{input: "10", ptr: new(big.Int), value: *big.NewInt(16)}, // non-pointer also works
-	{input: "C0", ptr: new(*big.Int), error: ErrExpectedString.Error()},
+	{input: "C0", ptr: new(*big.Int), error: "rlp: expected input string or byte for *big.Int"},
 
 	// structs
 	{input: "C0", ptr: new(simplestruct), value: simplestruct{0, ""}},
-- 
cgit v1.2.3


From 6abf8ef78f1474fdeb7a6a6ce084bf994cc055f2 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Mon, 5 Jan 2015 17:10:42 +0100
Subject: Merge

---
 rlp/decode.go      | 57 +++++++++++++++++++++++++++++++++++++-----------------
 rlp/decode_test.go | 38 +++++++++++++++++++++++++++++++-----
 2 files changed, 72 insertions(+), 23 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 712d9fcf1..a2bd04285 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -76,22 +76,37 @@ func Decode(r io.Reader, val interface{}) error {
 type decodeError struct {
 	msg string
 	typ reflect.Type
+	ctx []string
 }
 
-func (err decodeError) Error() string {
-	return fmt.Sprintf("rlp: %s for %v", err.msg, err.typ)
+func (err *decodeError) Error() string {
+	ctx := ""
+	if len(err.ctx) > 0 {
+		ctx = ", decoding into "
+		for i := len(err.ctx) - 1; i >= 0; i-- {
+			ctx += err.ctx[i]
+		}
+	}
+	return fmt.Sprintf("rlp: %s for %v%s", err.msg, err.typ, ctx)
 }
 
 func wrapStreamError(err error, typ reflect.Type) error {
 	switch err {
 	case ErrExpectedList:
-		return decodeError{"expected input list", typ}
+		return &decodeError{msg: "expected input list", typ: typ}
 	case ErrExpectedString:
-		return decodeError{"expected input string or byte", typ}
+		return &decodeError{msg: "expected input string or byte", typ: typ}
 	case errUintOverflow:
-		return decodeError{"input string too long", typ}
+		return &decodeError{msg: "input string too long", typ: typ}
 	case errNotAtEOL:
-		return decodeError{"input list has too many elements", typ}
+		return &decodeError{msg: "input list has too many elements", typ: typ}
+	}
+	return err
+}
+
+func addErrorContext(err error, ctx string) error {
+	if decErr, ok := err.(*decodeError); ok {
+		decErr.ctx = append(decErr.ctx, ctx)
 	}
 	return err
 }
@@ -180,13 +195,13 @@ func makeListDecoder(typ reflect.Type) (decoder, error) {
 		return nil, err
 	}
 
-	if typ.Kind() == reflect.Array {
-		return func(s *Stream, val reflect.Value) error {
-			return decodeListArray(s, val, etypeinfo.decoder)
-		}, nil
-	}
+	isArray := typ.Kind() == reflect.Array
 	return func(s *Stream, val reflect.Value) error {
-		return decodeListSlice(s, val, etypeinfo.decoder)
+		if isArray {
+			return decodeListArray(s, val, etypeinfo.decoder)
+		} else {
+			return decodeListSlice(s, val, etypeinfo.decoder)
+		}
 	}, nil
 }
 
@@ -219,7 +234,7 @@ func decodeListSlice(s *Stream, val reflect.Value, elemdec decoder) error {
 		if err := elemdec(s, val.Index(i)); err == EOL {
 			break
 		} else if err != nil {
-			return err
+			return addErrorContext(err, fmt.Sprint("[", i, "]"))
 		}
 	}
 	if i < val.Len() {
@@ -248,7 +263,7 @@ func decodeListArray(s *Stream, val reflect.Value, elemdec decoder) error {
 		if err := elemdec(s, val.Index(i)); err == EOL {
 			break
 		} else if err != nil {
-			return err
+			return addErrorContext(err, fmt.Sprint("[", i, "]"))
 		}
 	}
 	if i < vlen {
@@ -280,14 +295,14 @@ func decodeByteArray(s *Stream, val reflect.Value) error {
 	switch kind {
 	case Byte:
 		if val.Len() == 0 {
-			return decodeError{"input string too long", val.Type()}
+			return &decodeError{msg: "input string too long", typ: val.Type()}
 		}
 		bv, _ := s.Uint()
 		val.Index(0).SetUint(bv)
 		zero(val, 1)
 	case String:
 		if uint64(val.Len()) < size {
-			return decodeError{"input string too long", val.Type()}
+			return &decodeError{msg: "input string too long", typ: val.Type()}
 		}
 		slice := val.Slice(0, int(size)).Interface().([]byte)
 		if err := s.readFull(slice); err != nil {
@@ -334,7 +349,7 @@ func makeStructDecoder(typ reflect.Type) (decoder, error) {
 				// too few elements. leave the rest at their zero value.
 				break
 			} else if err != nil {
-				return err
+				return addErrorContext(err, "."+typ.Field(f.index).Name)
 			}
 		}
 		return wrapStreamError(s.ListEnd(), typ)
@@ -599,7 +614,13 @@ func (s *Stream) Decode(val interface{}) error {
 	if err != nil {
 		return err
 	}
-	return info.decoder(s, rval.Elem())
+
+	err = info.decoder(s, rval.Elem())
+	if decErr, ok := err.(*decodeError); ok && len(decErr.ctx) > 0 {
+		// add decode target type to error so context has more meaning
+		decErr.ctx = append(decErr.ctx, fmt.Sprint("(", rtyp.Elem(), ")"))
+	}
+	return err
 }
 
 // Reset discards any information about the current decoding context
diff --git a/rlp/decode_test.go b/rlp/decode_test.go
index 7a1743937..18ea63a09 100644
--- a/rlp/decode_test.go
+++ b/rlp/decode_test.go
@@ -231,7 +231,12 @@ var decodeTests = []decodeTest{
 	{input: "8D6162636465666768696A6B6C6D", ptr: new([]byte), value: []byte("abcdefghijklm")},
 	{input: "C0", ptr: new([]byte), value: []byte{}},
 	{input: "C3010203", ptr: new([]byte), value: []byte{1, 2, 3}},
-	{input: "C3820102", ptr: new([]byte), error: "rlp: input string too long for uint8"},
+
+	{
+		input: "C3820102",
+		ptr:   new([]byte),
+		error: "rlp: input string too long for uint8, decoding into ([]uint8)[0]",
+	},
 
 	// byte arrays
 	{input: "01", ptr: new([5]byte), value: [5]byte{1}},
@@ -239,9 +244,22 @@ var decodeTests = []decodeTest{
 	{input: "850102030405", ptr: new([5]byte), value: [5]byte{1, 2, 3, 4, 5}},
 	{input: "C0", ptr: new([5]byte), value: [5]byte{}},
 	{input: "C3010203", ptr: new([5]byte), value: [5]byte{1, 2, 3, 0, 0}},
-	{input: "C3820102", ptr: new([5]byte), error: "rlp: input string too long for uint8"},
-	{input: "86010203040506", ptr: new([5]byte), error: "rlp: input string too long for [5]uint8"},
-	{input: "850101", ptr: new([5]byte), error: io.ErrUnexpectedEOF.Error()},
+
+	{
+		input: "C3820102",
+		ptr:   new([5]byte),
+		error: "rlp: input string too long for uint8, decoding into ([5]uint8)[0]",
+	},
+	{
+		input: "86010203040506",
+		ptr:   new([5]byte),
+		error: "rlp: input string too long for [5]uint8",
+	},
+	{
+		input: "850101",
+		ptr:   new([5]byte),
+		error: io.ErrUnexpectedEOF.Error(),
+	},
 
 	// byte array reuse (should be zeroed)
 	{input: "850102030405", ptr: &sharedByteArray, value: [5]byte{1, 2, 3, 4, 5}},
@@ -272,13 +290,23 @@ var decodeTests = []decodeTest{
 	{input: "C0", ptr: new(simplestruct), value: simplestruct{0, ""}},
 	{input: "C105", ptr: new(simplestruct), value: simplestruct{5, ""}},
 	{input: "C50583343434", ptr: new(simplestruct), value: simplestruct{5, "444"}},
-	{input: "C3010101", ptr: new(simplestruct), error: "rlp: input list has too many elements for rlp.simplestruct"},
 	{
 		input: "C501C302C103",
 		ptr:   new(recstruct),
 		value: recstruct{1, &recstruct{2, &recstruct{3, nil}}},
 	},
 
+	{
+		input: "C3010101",
+		ptr:   new(simplestruct),
+		error: "rlp: input list has too many elements for rlp.simplestruct",
+	},
+	{
+		input: "C501C3C00000",
+		ptr:   new(recstruct),
+		error: "rlp: expected input string or byte for uint, decoding into (rlp.recstruct).Child.I",
+	},
+
 	// pointers
 	{input: "00", ptr: new(*uint), value: (*uint)(nil)},
 	{input: "80", ptr: new(*uint), value: (*uint)(nil)},
-- 
cgit v1.2.3


From 552f5b2693a5d19c126a8116d36ba1f4f6cb76a1 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Tue, 30 Dec 2014 11:40:32 +0100
Subject: rlp: add functions for encoding

I'm reasonably confident that the encoding matches the output of
ethutil.Encode for values that it supports. Some of the tests have been
adpated from the Ethereum testing repository.

There are still TODOs in the code.
---
 rlp/decode.go               |  12 +-
 rlp/decode_test.go          |   6 +-
 rlp/encode.go               | 532 ++++++++++++++++++++++++++++++++++++++++++++
 rlp/encode_test.go          | 260 ++++++++++++++++++++++
 rlp/encoder_example_test.go |  38 ++++
 rlp/typecache.go            |  29 ++-
 6 files changed, 860 insertions(+), 17 deletions(-)
 create mode 100644 rlp/encode.go
 create mode 100644 rlp/encode_test.go
 create mode 100644 rlp/encoder_example_test.go

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index a2bd04285..972e662c2 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -329,15 +329,9 @@ type field struct {
 }
 
 func makeStructDecoder(typ reflect.Type) (decoder, error) {
-	var fields []field
-	for i := 0; i < typ.NumField(); i++ {
-		if f := typ.Field(i); f.PkgPath == "" { // exported
-			info, err := cachedTypeInfo1(f.Type)
-			if err != nil {
-				return nil, err
-			}
-			fields = append(fields, field{i, info})
-		}
+	fields, err := structFields(typ)
+	if err != nil {
+		return nil, err
 	}
 	dec := func(s *Stream, val reflect.Value) (err error) {
 		if _, err = s.List(); err != nil {
diff --git a/rlp/decode_test.go b/rlp/decode_test.go
index 18ea63a09..35d8dc1fc 100644
--- a/rlp/decode_test.go
+++ b/rlp/decode_test.go
@@ -509,7 +509,7 @@ func ExampleStream() {
 }
 
 func BenchmarkDecode(b *testing.B) {
-	enc := encTest(90000)
+	enc := encodeTestSlice(90000)
 	b.SetBytes(int64(len(enc)))
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -524,7 +524,7 @@ func BenchmarkDecode(b *testing.B) {
 }
 
 func BenchmarkDecodeIntSliceReuse(b *testing.B) {
-	enc := encTest(100000)
+	enc := encodeTestSlice(100000)
 	b.SetBytes(int64(len(enc)))
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -538,7 +538,7 @@ func BenchmarkDecodeIntSliceReuse(b *testing.B) {
 	}
 }
 
-func encTest(n int) []byte {
+func encodeTestSlice(n int) []byte {
 	s := make([]interface{}, n)
 	for i := 0; i < n; i++ {
 		s[i] = i
diff --git a/rlp/encode.go b/rlp/encode.go
new file mode 100644
index 000000000..689d25dd8
--- /dev/null
+++ b/rlp/encode.go
@@ -0,0 +1,532 @@
+package rlp
+
+import (
+	"fmt"
+	"io"
+	"math/big"
+	"reflect"
+)
+
+// TODO: put encbufs in a sync.Pool.
+//     Doing that requires zeroing the buffers after use.
+//     encReader will need to drop it's buffer when done.
+
+var (
+	// Common encoded values.
+	// These are useful when implementing EncodeRLP.
+	EmptyString = []byte{0x80}
+	EmptyList   = []byte{0xC0}
+)
+
+// Encoder is implemented by types that require custom
+// encoding rules or want to encode private fields.
+type Encoder interface {
+	// EncodeRLP should write the RLP encoding of its receiver to w.
+	// If the implementation is a pointer method, it may also be
+	// called for nil pointers.
+	//
+	// Implementations should generate valid RLP. The data written is
+	// not verified at the moment, but a future version might. It is
+	// recommended to write only a single value but writing multiple
+	// values or no value at all is also permitted.
+	EncodeRLP(io.Writer) error
+}
+
+// Encode writes the RLP encoding of val to w. Note that Encode may
+// perform many small writes in some cases. Consider making w
+// buffered.
+//
+// Encode uses the following type-dependent encoding rules:
+//
+// If the type implements the Encoder interface, Encode calls
+// EncodeRLP. This is true even for nil pointers, please see the
+// documentation for Encoder.
+//
+// To encode a pointer, the value being pointed to is encoded. For nil
+// pointers, Encode will encode the zero value of the type. A nil
+// pointer to a struct type always encodes as an empty RLP list.
+//
+// Struct values are encoded as an RLP list of all their encoded
+// public fields. Recursive struct types are supported.
+//
+// To encode slices and arrays, the elements are encoded as an RLP
+// list of the value's elements. Note that arrays and slices with
+// element type uint8 or byte are always encoded as an RLP string.
+//
+// A Go string is encoded as an RLP string.
+//
+// An unsigned integer value is encoded as an RLP string. Zero always
+// encodes as an empty RLP string. Encode also supports *big.Int.
+//
+// An interface value encodes as the value contained in the interface.
+//
+// Boolean values are not supported, nor are signed integers, floating
+// point numbers, maps, channels and functions.
+func Encode(w io.Writer, val interface{}) error {
+	if outer, ok := w.(*encbuf); ok {
+		// Encode was called by some type's EncodeRLP.
+		// Avoid copying by writing to the outer encbuf directly.
+		return outer.encode(val)
+	}
+	eb := newencbuf()
+	if err := eb.encode(val); err != nil {
+		return err
+	}
+	return eb.toWriter(w)
+}
+
+// EncodeBytes returns the RLP encoding of val.
+// Please see the documentation of Encode for the encoding rules.
+func EncodeToBytes(val interface{}) ([]byte, error) {
+	eb := newencbuf()
+	if err := eb.encode(val); err != nil {
+		return nil, err
+	}
+	return eb.toBytes(), nil
+}
+
+// EncodeReader returns a reader from which the RLP encoding of val
+// can be read. The returned size is the total size of the encoded
+// data.
+//
+// Please see the documentation of Encode for the encoding rules.
+func EncodeToReader(val interface{}) (size int, r io.Reader, err error) {
+	eb := newencbuf()
+	if err := eb.encode(val); err != nil {
+		return 0, nil, err
+	}
+	return eb.size(), &encReader{buf: eb}, nil
+}
+
+type encbuf struct {
+	str     []byte      // string data, contains everything except list headers
+	lheads  []*listhead // all list headers
+	lhsize  int         // sum of sizes of all encoded list headers
+	sizebuf []byte      // 9-byte auxiliary buffer for uint encoding
+}
+
+type listhead struct {
+	offset int // index of this header in string data
+	size   int // total size of encoded data (including list headers)
+}
+
+// encode writes head to the given buffer, which must be at least
+// 9 bytes long. It returns the encoded bytes.
+func (head *listhead) encode(buf []byte) []byte {
+	if head.size < 56 {
+		buf[0] = 0xC0 + byte(head.size)
+		return buf[:1]
+	} else {
+		sizesize := putint(buf[1:], uint64(head.size))
+		buf[0] = 0xF7 + byte(sizesize)
+		return buf[:sizesize+1]
+	}
+}
+
+func newencbuf() *encbuf {
+	return &encbuf{sizebuf: make([]byte, 9)}
+}
+
+// encbuf implements io.Writer so it can be passed it into EncodeRLP.
+func (w *encbuf) Write(b []byte) (int, error) {
+	w.str = append(w.str, b...)
+	return len(b), nil
+}
+
+func (w *encbuf) encode(val interface{}) error {
+	rval := reflect.ValueOf(val)
+	ti, err := cachedTypeInfo(rval.Type())
+	if err != nil {
+		return err
+	}
+	return ti.writer(rval, w)
+}
+
+func (w *encbuf) encodeStringHeader(size int) {
+	if size < 56 {
+		w.str = append(w.str, 0x80+byte(size))
+	} else {
+		// TODO: encode to w.str directly
+		sizesize := putint(w.sizebuf[1:], uint64(size))
+		w.sizebuf[0] = 0xB7 + byte(sizesize)
+		w.str = append(w.str, w.sizebuf[:sizesize+1]...)
+	}
+}
+
+func (w *encbuf) encodeString(b []byte) {
+	w.encodeStringHeader(len(b))
+	w.str = append(w.str, b...)
+}
+
+func (w *encbuf) list() *listhead {
+	lh := &listhead{offset: len(w.str), size: w.lhsize}
+	w.lheads = append(w.lheads, lh)
+	return lh
+}
+
+func (w *encbuf) listEnd(lh *listhead) {
+	lh.size = w.size() - lh.offset - lh.size
+	if lh.size < 56 {
+		w.lhsize += 1 // length encoded into kind tag
+	} else {
+		w.lhsize += 1 + intsize(uint64(lh.size))
+	}
+}
+
+func (w *encbuf) size() int {
+	return len(w.str) + w.lhsize
+}
+
+func (w *encbuf) toBytes() []byte {
+	out := make([]byte, w.size())
+	strpos := 0
+	pos := 0
+	for _, head := range w.lheads {
+		// write string data before header
+		n := copy(out[pos:], w.str[strpos:head.offset])
+		pos += n
+		strpos += n
+		// write the header
+		enc := head.encode(out[pos:])
+		pos += len(enc)
+	}
+	// copy string data after the last list header
+	copy(out[pos:], w.str[strpos:])
+	return out
+}
+
+func (w *encbuf) toWriter(out io.Writer) (err error) {
+	strpos := 0
+	for _, head := range w.lheads {
+		// write string data before header
+		if head.offset-strpos > 0 {
+			n, err := out.Write(w.str[strpos:head.offset])
+			strpos += n
+			if err != nil {
+				return err
+			}
+		}
+		// write the header
+		enc := head.encode(w.sizebuf)
+		if _, err = out.Write(enc); err != nil {
+			return err
+		}
+	}
+	if strpos < len(w.str) {
+		// write string data after the last list header
+		_, err = out.Write(w.str[strpos:])
+	}
+	return err
+}
+
+// encReader is the io.Reader returned by EncodeToReader.
+// It releases its encbuf at EOF.
+type encReader struct {
+	buf    *encbuf // the buffer we're reading from. this is nil when we're at EOF.
+	lhpos  int     // index of list header that we're reading
+	strpos int     // current position in string buffer
+	piece  []byte  // next piece to be read
+}
+
+func (r *encReader) Read(b []byte) (n int, err error) {
+	for {
+		if r.piece = r.next(); r.piece == nil {
+			return n, io.EOF
+		}
+		nn := copy(b[n:], r.piece)
+		n += nn
+		if nn < len(r.piece) {
+			// piece didn't fit, see you next time.
+			r.piece = r.piece[nn:]
+			return n, nil
+		}
+		r.piece = nil
+	}
+	panic("not reached")
+}
+
+// next returns the next piece of data to be read.
+// it returns nil at EOF.
+func (r *encReader) next() []byte {
+	switch {
+	case r.piece != nil:
+		// There is still data available for reading.
+		return r.piece
+
+	case r.lhpos < len(r.buf.lheads):
+		// We're before the last list header.
+		head := r.buf.lheads[r.lhpos]
+		sizebefore := head.offset - r.strpos
+		if sizebefore > 0 {
+			// String data before header.
+			p := r.buf.str[r.strpos:head.offset]
+			r.strpos += sizebefore
+			return p
+		} else {
+			r.lhpos++
+			return head.encode(r.buf.sizebuf)
+		}
+
+	case r.strpos < len(r.buf.str):
+		// String data at the end, after all list headers.
+		p := r.buf.str[r.strpos:]
+		r.strpos = len(r.buf.str)
+		return p
+
+	default:
+		return nil
+	}
+}
+
+var (
+	encoderInterface = reflect.TypeOf(new(Encoder)).Elem()
+	emptyInterface   = reflect.TypeOf(new(interface{})).Elem()
+	big0             = big.NewInt(0)
+)
+
+// makeWriter creates a writer function for the given type.
+func makeWriter(typ reflect.Type) (writer, error) {
+	kind := typ.Kind()
+	switch {
+	case typ.Implements(encoderInterface):
+		return writeEncoder, nil
+	case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(encoderInterface):
+		return writeEncoderNoPtr, nil
+	case typ == emptyInterface:
+		return writeInterface, nil
+	case typ.AssignableTo(reflect.PtrTo(bigInt)):
+		return writeBigIntPtr, nil
+	case typ.AssignableTo(bigInt):
+		return writeBigIntNoPtr, nil
+	case isUint(kind):
+		return writeUint, nil
+	case kind == reflect.String:
+		return writeString, nil
+	case kind == reflect.Slice && typ.Elem().Kind() == reflect.Uint8 && !typ.Elem().Implements(encoderInterface):
+		return writeBytes, nil
+	case kind == reflect.Slice || kind == reflect.Array:
+		return makeSliceWriter(typ)
+	case kind == reflect.Struct:
+		return makeStructWriter(typ)
+	case kind == reflect.Ptr:
+		return makePtrWriter(typ)
+	default:
+		return nil, fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
+	}
+}
+
+func writeUint(val reflect.Value, w *encbuf) error {
+	i := val.Uint()
+	if i == 0 {
+		w.str = append(w.str, 0x80)
+	} else if i < 128 {
+		// fits single byte
+		w.str = append(w.str, byte(i))
+	} else {
+		// TODO: encode int to w.str directly
+		s := putint(w.sizebuf[1:], i)
+		w.sizebuf[0] = 0x80 + byte(s)
+		w.str = append(w.str, w.sizebuf[:s+1]...)
+	}
+	return nil
+}
+
+func writeBigIntPtr(val reflect.Value, w *encbuf) error {
+	return writeBigInt(val.Interface().(*big.Int), w)
+}
+
+func writeBigIntNoPtr(val reflect.Value, w *encbuf) error {
+	i := val.Interface().(big.Int)
+	return writeBigInt(&i, w)
+}
+
+func writeBigInt(i *big.Int, w *encbuf) error {
+	if cmp := i.Cmp(big0); cmp == -1 {
+		return fmt.Errorf("rlp: cannot encode negative *big.Int")
+	} else if cmp == 0 {
+		w.str = append(w.str, 0x80)
+	} else if bits := i.BitLen(); bits < 8 {
+		// fits single byte
+		w.str = append(w.str, byte(i.Uint64()))
+	} else {
+		w.encodeString(i.Bytes())
+	}
+	return nil
+}
+
+func writeBytes(val reflect.Value, w *encbuf) error {
+	w.encodeString(val.Bytes())
+	return nil
+}
+
+func writeString(val reflect.Value, w *encbuf) error {
+	s := val.String()
+	w.encodeStringHeader(len(s))
+	w.str = append(w.str, s...)
+	return nil
+}
+
+func writeEncoder(val reflect.Value, w *encbuf) error {
+	return val.Interface().(Encoder).EncodeRLP(w)
+}
+
+// writeEncoderNoPtr handles non-pointer values that implement Encoder
+// with a pointer receiver.
+func writeEncoderNoPtr(val reflect.Value, w *encbuf) error {
+	if !val.CanAddr() {
+		// We can't get the address. It would be possible make the
+		// value addressable by creating a shallow copy, but this
+		// creates other problems so we're not doing it (yet).
+		//
+		// package json simply doesn't call MarshalJSON for cases like
+		// this, but encodes the value as if it didn't implement the
+		// interface. We don't want to handle it that way.
+		return fmt.Errorf("rlp: game over: unadressable value of type %v, EncodeRLP is pointer method", val.Type())
+	}
+	return val.Addr().Interface().(Encoder).EncodeRLP(w)
+}
+
+func writeInterface(val reflect.Value, w *encbuf) error {
+	if val.IsNil() {
+		// Write empty list. This is consistent with the previous RLP
+		// encoder that we had and should therefore avoid any
+		// problems.
+		w.str = append(w.str, 0xC0)
+		return nil
+	}
+	eval := val.Elem()
+	ti, err := cachedTypeInfo(eval.Type())
+	if err != nil {
+		return err
+	}
+	return ti.writer(eval, w)
+}
+
+func makeSliceWriter(typ reflect.Type) (writer, error) {
+	etypeinfo, err := cachedTypeInfo1(typ.Elem())
+	if err != nil {
+		return nil, err
+	}
+	writer := func(val reflect.Value, w *encbuf) error {
+		lh := w.list()
+		vlen := val.Len()
+		for i := 0; i < vlen; i++ {
+			if err := etypeinfo.writer(val.Index(i), w); err != nil {
+				return err
+			}
+		}
+		w.listEnd(lh)
+		return nil
+	}
+	return writer, nil
+}
+
+func makeStructWriter(typ reflect.Type) (writer, error) {
+	fields, err := structFields(typ)
+	if err != nil {
+		return nil, err
+	}
+	writer := func(val reflect.Value, w *encbuf) error {
+		lh := w.list()
+		for _, f := range fields {
+			if err := f.info.writer(val.Field(f.index), w); err != nil {
+				return err
+			}
+		}
+		w.listEnd(lh)
+		return nil
+	}
+	return writer, nil
+}
+
+func makePtrWriter(typ reflect.Type) (writer, error) {
+	etypeinfo, err := cachedTypeInfo1(typ.Elem())
+	if err != nil {
+		return nil, err
+	}
+	zero := reflect.Zero(typ.Elem())
+	kind := typ.Elem().Kind()
+	writer := func(val reflect.Value, w *encbuf) error {
+		switch {
+		case !val.IsNil():
+			return etypeinfo.writer(val.Elem(), w)
+		case kind == reflect.Struct:
+			// encoding the zero value of a struct could trigger
+			// infinite recursion, avoid that.
+			w.listEnd(w.list())
+			return nil
+		default:
+			return etypeinfo.writer(zero, w)
+		}
+	}
+	return writer, err
+}
+
+// putint writes i to the beginning of b in with big endian byte
+// order, using the least number of bytes needed to represent i.
+func putint(b []byte, i uint64) (size int) {
+	switch {
+	case i < (1 << 8):
+		b[0] = byte(i)
+		return 1
+	case i < (1 << 16):
+		b[0] = byte(i >> 8)
+		b[1] = byte(i)
+		return 2
+	case i < (1 << 24):
+		b[0] = byte(i >> 16)
+		b[1] = byte(i >> 8)
+		b[2] = byte(i)
+		return 3
+	case i < (1 << 32):
+		b[0] = byte(i >> 24)
+		b[1] = byte(i >> 16)
+		b[2] = byte(i >> 8)
+		b[3] = byte(i)
+		return 4
+	case i < (1 << 40):
+		b[0] = byte(i >> 32)
+		b[1] = byte(i >> 24)
+		b[2] = byte(i >> 16)
+		b[3] = byte(i >> 8)
+		b[4] = byte(i)
+		return 5
+	case i < (1 << 48):
+		b[0] = byte(i >> 40)
+		b[1] = byte(i >> 32)
+		b[2] = byte(i >> 24)
+		b[3] = byte(i >> 16)
+		b[4] = byte(i >> 8)
+		b[5] = byte(i)
+		return 6
+	case i < (1 << 56):
+		b[0] = byte(i >> 48)
+		b[1] = byte(i >> 40)
+		b[2] = byte(i >> 32)
+		b[3] = byte(i >> 24)
+		b[4] = byte(i >> 16)
+		b[5] = byte(i >> 8)
+		b[6] = byte(i)
+		return 7
+	default:
+		b[0] = byte(i >> 56)
+		b[1] = byte(i >> 48)
+		b[2] = byte(i >> 40)
+		b[3] = byte(i >> 32)
+		b[4] = byte(i >> 24)
+		b[5] = byte(i >> 16)
+		b[6] = byte(i >> 8)
+		b[7] = byte(i)
+		return 8
+	}
+}
+
+// intsize computes the minimum number of bytes required to store i.
+func intsize(i uint64) (size int) {
+	for size = 1; ; size++ {
+		if i >>= 8; i == 0 {
+			return size
+		}
+	}
+	panic("not reached")
+}
diff --git a/rlp/encode_test.go b/rlp/encode_test.go
new file mode 100644
index 000000000..8dba3671b
--- /dev/null
+++ b/rlp/encode_test.go
@@ -0,0 +1,260 @@
+package rlp
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math/big"
+	"testing"
+)
+
+type testEncoder struct {
+	err error
+}
+
+func (e *testEncoder) EncodeRLP(w io.Writer) error {
+	if e == nil {
+		w.Write([]byte{0, 0, 0, 0})
+	} else if e.err != nil {
+		return e.err
+	} else {
+		w.Write([]byte{0, 1, 0, 1, 0, 1, 0, 1, 0, 1})
+	}
+	return nil
+}
+
+type byteEncoder byte
+
+func (e byteEncoder) EncodeRLP(w io.Writer) error {
+	w.Write(EmptyList)
+	return nil
+}
+
+var (
+	_ = Encoder(&testEncoder{})
+	_ = Encoder(byteEncoder(0))
+)
+
+type encTest struct {
+	val           interface{}
+	output, error string
+}
+
+var encTests = []encTest{
+	// integers
+	{val: uint32(0), output: "80"},
+	{val: uint32(127), output: "7F"},
+	{val: uint32(128), output: "8180"},
+	{val: uint32(256), output: "820100"},
+	{val: uint32(1024), output: "820400"},
+	{val: uint32(0xFFFFFF), output: "83FFFFFF"},
+	{val: uint32(0xFFFFFFFF), output: "84FFFFFFFF"},
+	{val: uint64(0xFFFFFFFF), output: "84FFFFFFFF"},
+	{val: uint64(0xFFFFFFFFFF), output: "85FFFFFFFFFF"},
+	{val: uint64(0xFFFFFFFFFFFF), output: "86FFFFFFFFFFFF"},
+	{val: uint64(0xFFFFFFFFFFFFFF), output: "87FFFFFFFFFFFFFF"},
+	{val: uint64(0xFFFFFFFFFFFFFFFF), output: "88FFFFFFFFFFFFFFFF"},
+
+	// big integers (should match uint for small values)
+	{val: big.NewInt(0), output: "80"},
+	{val: big.NewInt(1), output: "01"},
+	{val: big.NewInt(127), output: "7F"},
+	{val: big.NewInt(128), output: "8180"},
+	{val: big.NewInt(256), output: "820100"},
+	{val: big.NewInt(1024), output: "820400"},
+	{val: big.NewInt(0xFFFFFF), output: "83FFFFFF"},
+	{val: big.NewInt(0xFFFFFFFF), output: "84FFFFFFFF"},
+	{val: big.NewInt(0xFFFFFFFFFF), output: "85FFFFFFFFFF"},
+	{val: big.NewInt(0xFFFFFFFFFFFF), output: "86FFFFFFFFFFFF"},
+	{val: big.NewInt(0xFFFFFFFFFFFFFF), output: "87FFFFFFFFFFFFFF"},
+	{
+		val:    big.NewInt(0).SetBytes(unhex("102030405060708090A0B0C0D0E0F2")),
+		output: "8F102030405060708090A0B0C0D0E0F2",
+	},
+	{
+		val:    big.NewInt(0).SetBytes(unhex("0100020003000400050006000700080009000A000B000C000D000E01")),
+		output: "9C0100020003000400050006000700080009000A000B000C000D000E01",
+	},
+	{
+		val:    big.NewInt(0).SetBytes(unhex("010000000000000000000000000000000000000000000000000000000000000000")),
+		output: "A1010000000000000000000000000000000000000000000000000000000000000000",
+	},
+
+	// non-pointer big.Int
+	{val: *big.NewInt(0), output: "80"},
+	{val: *big.NewInt(0xFFFFFF), output: "83FFFFFF"},
+
+	// negative ints are not supported
+	{val: big.NewInt(-1), error: "rlp: cannot encode negative *big.Int"},
+
+	// byte slices, strings
+	{val: []byte{}, output: "80"},
+	{val: []byte{1, 2, 3}, output: "83010203"},
+	{val: "", output: "80"},
+	{val: "dog", output: "83646F67"},
+	{
+		val:    "Lorem ipsum dolor sit amet, consectetur adipisicing eli",
+		output: "B74C6F72656D20697073756D20646F6C6F722073697420616D65742C20636F6E7365637465747572206164697069736963696E6720656C69",
+	},
+	{
+		val:    "Lorem ipsum dolor sit amet, consectetur adipisicing elit",
+		output: "B8384C6F72656D20697073756D20646F6C6F722073697420616D65742C20636F6E7365637465747572206164697069736963696E6720656C6974",
+	},
+	{
+		val:    "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur mauris magna, suscipit sed vehicula non, iaculis faucibus tortor. Proin suscipit ultricies malesuada. Duis tortor elit, dictum quis tristique eu, ultrices at risus. Morbi a est imperdiet mi ullamcorper aliquet suscipit nec lorem. Aenean quis leo mollis, vulputate elit varius, consequat enim. Nulla ultrices turpis justo, et posuere urna consectetur nec. Proin non convallis metus. Donec tempor ipsum in mauris congue sollicitudin. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Suspendisse convallis sem vel massa faucibus, eget lacinia lacus tempor. Nulla quis ultricies purus. Proin auctor rhoncus nibh condimentum mollis. Aliquam consequat enim at metus luctus, a eleifend purus egestas. Curabitur at nibh metus. Nam bibendum, neque at auctor tristique, lorem libero aliquet arcu, non interdum tellus lectus sit amet eros. Cras rhoncus, metus ac ornare cursus, dolor justo ultrices metus, at ullamcorper volutpat",
+		output: "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",
+	},
+
+	// slices
+	{val: []uint{}, output: "C0"},
+	{val: []uint{1, 2, 3}, output: "C3010203"},
+	{
+		// [ [], [[]], [ [], [[]] ] ]
+		val:    []interface{}{[]interface{}{}, [][]interface{}{{}}, []interface{}{[]interface{}{}, [][]interface{}{{}}}},
+		output: "C7C0C1C0C3C0C1C0",
+	},
+	{
+		val:    []string{"aaa", "bbb", "ccc", "ddd", "eee", "fff", "ggg", "hhh", "iii", "jjj", "kkk", "lll", "mmm", "nnn", "ooo"},
+		output: "F83C836161618362626283636363836464648365656583666666836767678368686883696969836A6A6A836B6B6B836C6C6C836D6D6D836E6E6E836F6F6F",
+	},
+	{
+		val:    []interface{}{uint(1), uint(0xFFFFFF), []interface{}{[]uint{4, 5, 5}}, "abc"},
+		output: "CE0183FFFFFFC4C304050583616263",
+	},
+	{
+		val: [][]string{
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+			{"asdf", "qwer", "zxcv"},
+		},
+		output: "F90200CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376CF84617364668471776572847A786376",
+	},
+
+	// structs
+	{val: simplestruct{}, output: "C28080"},
+	{val: simplestruct{A: 3, B: "foo"}, output: "C50383666F6F"},
+	{val: &recstruct{5, nil}, output: "C205C0"},
+	{val: &recstruct{5, &recstruct{4, &recstruct{3, nil}}}, output: "C605C404C203C0"},
+
+	// nil
+	{val: (*uint)(nil), output: "80"},
+	{val: (*string)(nil), output: "80"},
+	{val: (*[]byte)(nil), output: "80"},
+	{val: (*[]string)(nil), output: "C0"},
+	{val: (*[]interface{})(nil), output: "C0"},
+	{val: (*[]struct{ uint })(nil), output: "C0"},
+	{val: (*interface{})(nil), output: "C0"},
+
+	// Encoder
+	{val: (*testEncoder)(nil), output: "00000000"},
+	{val: &testEncoder{}, output: "00010001000100010001"},
+	{val: &testEncoder{errors.New("test error")}, error: "test error"},
+	// verify that pointer method testEncoder.EncodeRLP is called for
+	// addressable non-pointer values.
+	{val: &struct{ TE testEncoder }{testEncoder{}}, output: "CA00010001000100010001"},
+	{val: &struct{ TE testEncoder }{testEncoder{errors.New("test error")}}, error: "test error"},
+	// verify the error for non-addressable non-pointer Encoder
+	{val: testEncoder{}, error: "rlp: game over: unadressable value of type rlp.testEncoder, EncodeRLP is pointer method"},
+	// verify the special case for []byte
+	{val: []byteEncoder{0, 1, 2, 3, 4}, output: "C5C0C0C0C0C0"},
+}
+
+func runEncTests(t *testing.T, f func(val interface{}) ([]byte, error)) {
+	for i, test := range encTests {
+		output, err := f(test.val)
+		if err != nil && test.error == "" {
+			t.Errorf("test %d: unexpected error: %v\nvalue %#v\ntype %T",
+				i, err, test.val, test.val)
+			continue
+		}
+		if test.error != "" && fmt.Sprint(err) != test.error {
+			t.Errorf("test %d: error mismatch\ngot   %v\nwant  %v\nvalue %#v\ntype  %T",
+				i, err, test.error, test.val, test.val)
+			continue
+		}
+		if err == nil && !bytes.Equal(output, unhex(test.output)) {
+			t.Errorf("test %d: output mismatch:\ngot   %X\nwant  %s\nvalue %#v\ntype  %T",
+				i, output, test.output, test.val, test.val)
+		}
+	}
+}
+
+func TestEncode(t *testing.T) {
+	runEncTests(t, func(val interface{}) ([]byte, error) {
+		b := new(bytes.Buffer)
+		err := Encode(b, val)
+		return b.Bytes(), err
+	})
+}
+
+func TestEncodeToBytes(t *testing.T) {
+	runEncTests(t, EncodeToBytes)
+}
+
+func TestEncodeToReader(t *testing.T) {
+	runEncTests(t, func(val interface{}) ([]byte, error) {
+		_, r, err := EncodeToReader(val)
+		if err != nil {
+			return nil, err
+		}
+		return ioutil.ReadAll(r)
+	})
+}
+
+func TestEncodeToReaderPiecewise(t *testing.T) {
+	runEncTests(t, func(val interface{}) ([]byte, error) {
+		size, r, err := EncodeToReader(val)
+		if err != nil {
+			return nil, err
+		}
+
+		// read output piecewise
+		output := make([]byte, size)
+		for start, end := 0, 0; start < size; start = end {
+			if remaining := size - start; remaining < 3 {
+				end += remaining
+			} else {
+				end = start + 3
+			}
+			n, err := r.Read(output[start:end])
+			end = start + n
+			if err == io.EOF {
+				break
+			} else if err != nil {
+				return nil, err
+			}
+		}
+		return output, nil
+	})
+}
diff --git a/rlp/encoder_example_test.go b/rlp/encoder_example_test.go
new file mode 100644
index 000000000..57bad604d
--- /dev/null
+++ b/rlp/encoder_example_test.go
@@ -0,0 +1,38 @@
+package rlp
+
+import (
+	"fmt"
+	"io"
+)
+
+type MyCoolType struct {
+	Name string
+	a, b uint
+}
+
+// EncodeRLP writes x as RLP list [a, b] that omits the Name field.
+func (x *MyCoolType) EncodeRLP(w io.Writer) (err error) {
+	// Note: the receiver can be a nil pointer. This allows you to
+	// control the encoding of nil, but it also means that you have to
+	// check for a nil receiver.
+	if x == nil {
+		err = Encode(w, []uint{0, 0})
+	} else {
+		err = Encode(w, []uint{x.a, x.b})
+	}
+	return err
+}
+
+func ExampleEncoder() {
+	var t *MyCoolType // t is nil pointer to MyCoolType
+	bytes, _ := EncodeToBytes(t)
+	fmt.Printf("%v → %X\n", t, bytes)
+
+	t = &MyCoolType{Name: "foobar", a: 5, b: 6}
+	bytes, _ = EncodeToBytes(t)
+	fmt.Printf("%v → %X\n", t, bytes)
+
+	// Output:
+	// <nil> → C28080
+	// &{foobar 5 6} → C20506
+}
diff --git a/rlp/typecache.go b/rlp/typecache.go
index 52e68a3c5..398f25d90 100644
--- a/rlp/typecache.go
+++ b/rlp/typecache.go
@@ -5,16 +5,19 @@ import (
 	"sync"
 )
 
-type decoder func(*Stream, reflect.Value) error
+var (
+	typeCacheMutex sync.RWMutex
+	typeCache      = make(map[reflect.Type]*typeinfo)
+)
 
 type typeinfo struct {
 	decoder
+	writer
 }
 
-var (
-	typeCacheMutex sync.RWMutex
-	typeCache      = make(map[reflect.Type]*typeinfo)
-)
+type decoder func(*Stream, reflect.Value) error
+
+type writer func(reflect.Value, *encbuf) error
 
 func cachedTypeInfo(typ reflect.Type) (*typeinfo, error) {
 	typeCacheMutex.RLock()
@@ -49,11 +52,27 @@ func cachedTypeInfo1(typ reflect.Type) (*typeinfo, error) {
 	return typeCache[typ], err
 }
 
+func structFields(typ reflect.Type) (fields []field, err error) {
+	for i := 0; i < typ.NumField(); i++ {
+		if f := typ.Field(i); f.PkgPath == "" { // exported
+			info, err := cachedTypeInfo1(f.Type)
+			if err != nil {
+				return nil, err
+			}
+			fields = append(fields, field{i, info})
+		}
+	}
+	return fields, nil
+}
+
 func genTypeInfo(typ reflect.Type) (info *typeinfo, err error) {
 	info = new(typeinfo)
 	if info.decoder, err = makeDecoder(typ); err != nil {
 		return nil, err
 	}
+	if info.writer, err = makeWriter(typ); err != nil {
+		return nil, err
+	}
 	return info, nil
 }
 
-- 
cgit v1.2.3


From 29c46cdf3405d6462deb2cb5cef87b1b4fb2bdc7 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Thu, 15 Jan 2015 11:12:39 +0100
Subject: rlp: fix Decode benchmarks

---
 rlp/decode_test.go | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode_test.go b/rlp/decode_test.go
index 35d8dc1fc..9142ef56d 100644
--- a/rlp/decode_test.go
+++ b/rlp/decode_test.go
@@ -8,8 +8,6 @@ import (
 	"math/big"
 	"reflect"
 	"testing"
-
-	"github.com/ethereum/go-ethereum/ethutil"
 )
 
 func TestStreamKind(t *testing.T) {
@@ -515,7 +513,7 @@ func BenchmarkDecode(b *testing.B) {
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		var s []int
+		var s []uint
 		r := bytes.NewReader(enc)
 		if err := Decode(r, &s); err != nil {
 			b.Fatalf("Decode error: %v", err)
@@ -529,7 +527,7 @@ func BenchmarkDecodeIntSliceReuse(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 
-	var s []int
+	var s []uint
 	for i := 0; i < b.N; i++ {
 		r := bytes.NewReader(enc)
 		if err := Decode(r, &s); err != nil {
@@ -538,12 +536,16 @@ func BenchmarkDecodeIntSliceReuse(b *testing.B) {
 	}
 }
 
-func encodeTestSlice(n int) []byte {
-	s := make([]interface{}, n)
-	for i := 0; i < n; i++ {
+func encodeTestSlice(n uint) []byte {
+	s := make([]uint, n)
+	for i := uint(0); i < n; i++ {
 		s[i] = i
 	}
-	return ethutil.Encode(s)
+	b, err := EncodeToBytes(s)
+	if err != nil {
+		panic(fmt.Sprintf("encode error: %v", err))
+	}
+	return b
 }
 
 func unhex(str string) []byte {
-- 
cgit v1.2.3


From fc92abec2cc6e27e7e56a6a05850ad4ebbf63d7e Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Thu, 15 Jan 2015 23:21:41 +0100
Subject: rlp: allow encoding non-empty interface values

This needs to be supported because []someInterface does occur sometimes.

Funny enough, the fix involves changes to the decoder. makeDecoder
cannot return an error for non-empty interfaces anymore because the type
cache builds both decoder and writer. Do the check at 'runtime' instead.
---
 rlp/decode.go      |  5 ++++-
 rlp/decode_test.go |  5 +++++
 rlp/encode.go      |  3 +--
 rlp/encode_test.go | 13 +++++++++++++
 4 files changed, 23 insertions(+), 3 deletions(-)

(limited to 'rlp')

diff --git a/rlp/decode.go b/rlp/decode.go
index 972e662c2..55f7187a3 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -137,7 +137,7 @@ func makeDecoder(typ reflect.Type) (dec decoder, err error) {
 		return makeStructDecoder(typ)
 	case kind == reflect.Ptr:
 		return makePtrDecoder(typ)
-	case kind == reflect.Interface && typ.NumMethod() == 0:
+	case kind == reflect.Interface:
 		return decodeInterface, nil
 	default:
 		return nil, fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
@@ -378,6 +378,9 @@ func makePtrDecoder(typ reflect.Type) (decoder, error) {
 var ifsliceType = reflect.TypeOf([]interface{}{})
 
 func decodeInterface(s *Stream, val reflect.Value) error {
+	if val.Type().NumMethod() != 0 {
+		return fmt.Errorf("rlp: type %v is not RLP-serializable", val.Type())
+	}
 	kind, _, err := s.Kind()
 	if err != nil {
 		return err
diff --git a/rlp/decode_test.go b/rlp/decode_test.go
index 9142ef56d..9f66840b1 100644
--- a/rlp/decode_test.go
+++ b/rlp/decode_test.go
@@ -325,6 +325,11 @@ var decodeTests = []decodeTest{
 	{input: "850505050505", ptr: new(interface{}), value: []byte{5, 5, 5, 5, 5}},
 	{input: "C0", ptr: new(interface{}), value: []interface{}{}},
 	{input: "C50183040404", ptr: new(interface{}), value: []interface{}{[]byte{1}, []byte{4, 4, 4}}},
+	{
+		input: "C3010203",
+		ptr:   new([]io.Reader),
+		error: "rlp: type io.Reader is not RLP-serializable",
+	},
 }
 
 func uintp(i uint) *uint { return &i }
diff --git a/rlp/encode.go b/rlp/encode.go
index 689d25dd8..d80b66315 100644
--- a/rlp/encode.go
+++ b/rlp/encode.go
@@ -280,7 +280,6 @@ func (r *encReader) next() []byte {
 
 var (
 	encoderInterface = reflect.TypeOf(new(Encoder)).Elem()
-	emptyInterface   = reflect.TypeOf(new(interface{})).Elem()
 	big0             = big.NewInt(0)
 )
 
@@ -292,7 +291,7 @@ func makeWriter(typ reflect.Type) (writer, error) {
 		return writeEncoder, nil
 	case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(encoderInterface):
 		return writeEncoderNoPtr, nil
-	case typ == emptyInterface:
+	case kind == reflect.Interface:
 		return writeInterface, nil
 	case typ.AssignableTo(reflect.PtrTo(bigInt)):
 		return writeBigIntPtr, nil
diff --git a/rlp/encode_test.go b/rlp/encode_test.go
index 8dba3671b..18b843737 100644
--- a/rlp/encode_test.go
+++ b/rlp/encode_test.go
@@ -32,9 +32,19 @@ func (e byteEncoder) EncodeRLP(w io.Writer) error {
 	return nil
 }
 
+type encodableReader struct {
+	A, B uint
+}
+
+func (e *encodableReader) Read(b []byte) (int, error) {
+	panic("called")
+}
+
 var (
 	_ = Encoder(&testEncoder{})
 	_ = Encoder(byteEncoder(0))
+
+	reader io.Reader = &encodableReader{1, 2}
 )
 
 type encTest struct {
@@ -176,6 +186,9 @@ var encTests = []encTest{
 	{val: (*[]struct{ uint })(nil), output: "C0"},
 	{val: (*interface{})(nil), output: "C0"},
 
+	// interfaces
+	{val: []io.Reader{reader}, output: "C3C20102"}, // the contained value is a struct
+
 	// Encoder
 	{val: (*testEncoder)(nil), output: "00000000"},
 	{val: &testEncoder{}, output: "00010001000100010001"},
-- 
cgit v1.2.3