aboutsummaryrefslogtreecommitdiffstats
path: root/rlp
diff options
context:
space:
mode:
Diffstat (limited to 'rlp')
-rw-r--r--rlp/decode.go761
-rw-r--r--rlp/decode_test.go562
-rw-r--r--rlp/doc.go17
-rw-r--r--rlp/encode.go600
-rw-r--r--rlp/encode_test.go288
-rw-r--r--rlp/encoder_example_test.go38
-rw-r--r--rlp/typecache.go81
7 files changed, 2347 insertions, 0 deletions
diff --git a/rlp/decode.go b/rlp/decode.go
new file mode 100644
index 000000000..55f7187a3
--- /dev/null
+++ b/rlp/decode.go
@@ -0,0 +1,761 @@
+package rlp
+
+import (
+ "bufio"
+ "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. If r does
+// not implement ByteReader, Decode will do its own buffering.
+//
+// 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 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.
+// 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 booleans,
+// signed integers, floating point numbers, maps, channels and
+// functions.
+func Decode(r io.Reader, val interface{}) error {
+ return NewStream(r).Decode(val)
+}
+
+type decodeError struct {
+ msg string
+ typ reflect.Type
+ ctx []string
+}
+
+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{msg: "expected input list", typ: typ}
+ case ErrExpectedString:
+ return &decodeError{msg: "expected input string or byte", typ: typ}
+ case errUintOverflow:
+ return &decodeError{msg: "input string too long", typ: typ}
+ case errNotAtEOL:
+ 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
+}
+
+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 isUint(kind):
+ return decodeUint, 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:
+ return decodeInterface, nil
+ default:
+ return nil, fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
+ }
+}
+
+func decodeUint(s *Stream, val reflect.Value) error {
+ typ := val.Type()
+ num, err := s.uint(typ.Bits())
+ if err != nil {
+ return wrapStreamError(err, val.Type())
+ }
+ val.SetUint(num)
+ return nil
+}
+
+func decodeString(s *Stream, val reflect.Value) error {
+ b, err := s.Bytes()
+ if err != nil {
+ return wrapStreamError(err, val.Type())
+ }
+ 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 wrapStreamError(err, val.Type())
+ }
+ i := val.Interface().(*big.Int)
+ if i == nil {
+ i = new(big.Int)
+ val.Set(reflect.ValueOf(i))
+ }
+ i.SetBytes(b)
+ return nil
+}
+
+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
+ }
+
+ isArray := typ.Kind() == reflect.Array
+ return func(s *Stream, val reflect.Value) error {
+ if isArray {
+ return decodeListArray(s, val, etypeinfo.decoder)
+ } else {
+ return decodeListSlice(s, val, etypeinfo.decoder)
+ }
+ }, nil
+}
+
+func decodeListSlice(s *Stream, val reflect.Value, elemdec decoder) error {
+ size, err := s.List()
+ if err != nil {
+ return wrapStreamError(err, val.Type())
+ }
+ if size == 0 {
+ val.Set(reflect.MakeSlice(val.Type(), 0, 0))
+ return s.ListEnd()
+ }
+
+ i := 0
+ 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 {
+ break
+ } else if err != nil {
+ return addErrorContext(err, fmt.Sprint("[", i, "]"))
+ }
+ }
+ if i < val.Len() {
+ 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 addErrorContext(err, fmt.Sprint("[", i, "]"))
+ }
+ }
+ if i < vlen {
+ zero(val, i)
+ }
+ return wrapStreamError(s.ListEnd(), val.Type())
+}
+
+func decodeByteSlice(s *Stream, val reflect.Value) error {
+ kind, _, err := s.Kind()
+ if err != nil {
+ return err
+ }
+ if kind == List {
+ return decodeListSlice(s, val, decodeUint)
+ }
+ b, err := s.Bytes()
+ if err == nil {
+ val.SetBytes(b)
+ }
+ return err
+}
+
+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 &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{msg: "input string too long", typ: val.Type()}
+ }
+ slice := val.Slice(0, int(size)).Interface().([]byte)
+ if err := s.readFull(slice); err != nil {
+ return err
+ }
+ zero(val, int(size))
+ case List:
+ return decodeListArray(s, val, decodeUint)
+ }
+ return nil
+}
+
+func zero(val reflect.Value, start int) {
+ z := reflect.Zero(val.Type().Elem())
+ end := val.Len()
+ for i := start; i < end; i++ {
+ val.Index(i).Set(z)
+ }
+}
+
+type field struct {
+ index int
+ info *typeinfo
+}
+
+func makeStructDecoder(typ reflect.Type) (decoder, error) {
+ 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 {
+ return wrapStreamError(err, typ)
+ }
+ 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 addErrorContext(err, "."+typ.Field(f.index).Name)
+ }
+ }
+ return wrapStreamError(s.ListEnd(), typ)
+ }
+ 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 {
+ val.Set(reflect.Zero(typ)) // set to nil
+ 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 {
+ 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
+ }
+ if kind == List {
+ slice := reflect.New(ifsliceType).Elem()
+ if err := decodeListSlice(s, slice, decodeInterface); 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 }
+
+// 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
+}
+
+// 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.
+// 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
+ }
+}
+
+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.
+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, errUintOverflow
+ }
+ 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
+ }
+
+ 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
+// 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.
+//
+// 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..9f66840b1
--- /dev/null
+++ b/rlp/decode_test.go
@@ -0,0 +1,562 @@
+package rlp
+
+import (
+ "bytes"
+ "encoding/hex"
+ "fmt"
+ "io"
+ "math/big"
+ "reflect"
+ "testing"
+)
+
+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 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 {
+ 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"}, errUintOverflow},
+ {"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(uint)); 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 string
+}
+
+type simplestruct struct {
+ A uint
+ B string
+}
+
+type recstruct struct {
+ I uint
+ Child *recstruct
+}
+
+var (
+ veryBigInt = big.NewInt(0).Add(
+ big.NewInt(0).Lsh(big.NewInt(0xFFFFFFFFFFFFFF), 16),
+ big.NewInt(0xFFFF),
+ )
+)
+
+var (
+ sharedByteArray [5]byte
+ sharedPtr = new(*uint)
+)
+
+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: "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{}},
+ {input: "C80102030405060708", ptr: new([]uint), value: []uint{1, 2, 3, 4, 5, 6, 7, 8}},
+
+ // arrays
+ {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}},
+ {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: "rlp: input string too long for uint8, decoding into ([]uint8)[0]",
+ },
+
+ // 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: "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}},
+ {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: "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: "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: "rlp: expected input string or byte for *big.Int"},
+
+ // 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: "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)},
+ {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: uintp(5)},
+ {input: "80", ptr: sharedPtr, value: (*uint)(nil)},
+
+ // 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}}},
+ {
+ input: "C3010203",
+ ptr: new([]io.Reader),
+ error: "rlp: type io.Reader is not RLP-serializable",
+ },
+}
+
+func uintp(i uint) *uint { return &i }
+
+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(input, test.ptr)
+ 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 != "" && 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
+ }
+ 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)
+ }
+ }
+}
+
+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 {
+ 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 uint
+ private uint // 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:0xa, B:0x14, private:0x0, 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 := encodeTestSlice(90000)
+ b.SetBytes(int64(len(enc)))
+ b.ReportAllocs()
+ b.ResetTimer()
+
+ for i := 0; i < b.N; i++ {
+ var s []uint
+ r := bytes.NewReader(enc)
+ if err := Decode(r, &s); err != nil {
+ b.Fatalf("Decode error: %v", err)
+ }
+ }
+}
+
+func BenchmarkDecodeIntSliceReuse(b *testing.B) {
+ enc := encodeTestSlice(100000)
+ b.SetBytes(int64(len(enc)))
+ b.ReportAllocs()
+ b.ResetTimer()
+
+ var s []uint
+ 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 encodeTestSlice(n uint) []byte {
+ s := make([]uint, n)
+ for i := uint(0); i < n; i++ {
+ s[i] = i
+ }
+ b, err := EncodeToBytes(s)
+ if err != nil {
+ panic(fmt.Sprintf("encode error: %v", err))
+ }
+ return b
+}
+
+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/encode.go b/rlp/encode.go
new file mode 100644
index 000000000..9d11d66bf
--- /dev/null
+++ b/rlp/encode.go
@@ -0,0 +1,600 @@
+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
+}
+
+// Flat wraps a value (which must encode as a list) so
+// it encodes as the list's elements.
+//
+// Example: suppose you have defined a type
+//
+// type foo struct { A, B uint }
+//
+// Under normal encoding rules,
+//
+// rlp.Encode(foo{1, 2}) --> 0xC20102
+//
+// This function can help you achieve the following encoding:
+//
+// rlp.Encode(rlp.Flat(foo{1, 2})) --> 0x0102
+func Flat(val interface{}) Encoder {
+ return flatenc{val}
+}
+
+type flatenc struct{ val interface{} }
+
+func (e flatenc) EncodeRLP(out io.Writer) error {
+ // record current output position
+ var (
+ eb = out.(*encbuf)
+ prevstrsize = len(eb.str)
+ prevnheads = len(eb.lheads)
+ )
+ if err := eb.encode(e.val); err != nil {
+ return err
+ }
+ // check that a new list header has appeared
+ if len(eb.lheads) == prevnheads || eb.lheads[prevnheads].offset == prevstrsize-1 {
+ return fmt.Errorf("rlp.Flat: %T did not encode as list", e.val)
+ }
+ // remove the new list header
+ newhead := eb.lheads[prevnheads]
+ copy(eb.lheads[prevnheads:], eb.lheads[prevnheads+1:])
+ eb.lheads = eb.lheads[:len(eb.lheads)-1]
+ eb.lhsize -= newhead.tagsize()
+ return nil
+}
+
+// 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 (head *listhead) tagsize() int {
+ if head.size < 56 {
+ return 1
+ }
+ return 1 + intsize(uint64(head.size))
+}
+
+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()
+ 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 kind == reflect.Interface:
+ 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 && isByte(typ.Elem()):
+ return writeBytes, nil
+ case kind == reflect.Array && isByte(typ.Elem()):
+ return writeByteArray, 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 isByte(typ reflect.Type) bool {
+ return typ.Kind() == reflect.Uint8 && !typ.Implements(encoderInterface)
+}
+
+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 writeByteArray(val reflect.Value, w *encbuf) error {
+ if !val.CanAddr() {
+ // Slice requires the value to be addressable.
+ // Make it addressable by copying.
+ copy := reflect.New(val.Type()).Elem()
+ copy.Set(val)
+ val = copy
+ }
+ size := val.Len()
+ slice := val.Slice(0, size).Bytes()
+ w.encodeString(slice)
+ 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..c283fbd57
--- /dev/null
+++ b/rlp/encode_test.go
@@ -0,0 +1,288 @@
+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
+}
+
+type encodableReader struct {
+ A, B uint
+}
+
+func (e *encodableReader) Read(b []byte) (int, error) {
+ panic("called")
+}
+
+type namedByteType byte
+
+var (
+ _ = Encoder(&testEncoder{})
+ _ = Encoder(byteEncoder(0))
+
+ reader io.Reader = &encodableReader{1, 2}
+)
+
+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: []namedByteType{1, 2, 3}, output: "83010203"},
+ {val: [...]namedByteType{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"},
+
+ // flat
+ {val: Flat(uint(1)), error: "rlp.Flat: uint did not encode as list"},
+ {val: Flat(simplestruct{A: 3, B: "foo"}), output: "0383666F6F"},
+ {
+ // value generates more list headers after the Flat
+ val: []interface{}{"foo", []uint{1, 2}, Flat([]uint{3, 4}), []uint{5, 6}, "bar"},
+ output: "D083666F6FC201020304C2050683626172",
+ },
+
+ // 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"},
+
+ // interfaces
+ {val: []io.Reader{reader}, output: "C3C20102"}, // the contained value is a struct
+
+ // 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
new file mode 100644
index 000000000..398f25d90
--- /dev/null
+++ b/rlp/typecache.go
@@ -0,0 +1,81 @@
+package rlp
+
+import (
+ "reflect"
+ "sync"
+)
+
+var (
+ typeCacheMutex sync.RWMutex
+ typeCache = make(map[reflect.Type]*typeinfo)
+)
+
+type typeinfo struct {
+ decoder
+ writer
+}
+
+type decoder func(*Stream, reflect.Value) error
+
+type writer func(reflect.Value, *encbuf) error
+
+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
+}
+
+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
+}
+
+func isUint(k reflect.Kind) bool {
+ return k >= reflect.Uint && k <= reflect.Uintptr
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-01 14:01:07 +0800