aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/github.com/ethereum/go-ethereum/rlp
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/ethereum/go-ethereum/rlp')
-rw-r--r--vendor/github.com/ethereum/go-ethereum/rlp/decode.go1049
-rw-r--r--vendor/github.com/ethereum/go-ethereum/rlp/doc.go33
-rw-r--r--vendor/github.com/ethereum/go-ethereum/rlp/encode.go651
-rw-r--r--vendor/github.com/ethereum/go-ethereum/rlp/raw.go156
-rw-r--r--vendor/github.com/ethereum/go-ethereum/rlp/typecache.go165
5 files changed, 2054 insertions, 0 deletions
diff --git a/vendor/github.com/ethereum/go-ethereum/rlp/decode.go b/vendor/github.com/ethereum/go-ethereum/rlp/decode.go
new file mode 100644
index 000000000..4f29f2fb0
--- /dev/null
+++ b/vendor/github.com/ethereum/go-ethereum/rlp/decode.go
@@ -0,0 +1,1049 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package rlp
+
+import (
+ "bufio"
+ "bytes"
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "io"
+ "math/big"
+ "reflect"
+ "strings"
+ "sync"
+)
+
+var (
+ // EOL is returned when the end of the current list
+ // has been reached during streaming.
+ EOL = errors.New("rlp: end of list")
+
+ // Actual Errors
+ ErrExpectedString = errors.New("rlp: expected String or Byte")
+ ErrExpectedList = errors.New("rlp: expected List")
+ ErrCanonInt = errors.New("rlp: non-canonical integer format")
+ ErrCanonSize = errors.New("rlp: non-canonical size information")
+ ErrElemTooLarge = errors.New("rlp: element is larger than containing list")
+ ErrValueTooLarge = errors.New("rlp: value size exceeds available input length")
+ ErrMoreThanOneValue = errors.New("rlp: input contains more than one value")
+
+ // internal errors
+ errNotInList = errors.New("rlp: call of ListEnd outside of any list")
+ errNotAtEOL = errors.New("rlp: call of ListEnd not positioned at EOL")
+ errUintOverflow = errors.New("rlp: uint overflow")
+ errNoPointer = errors.New("rlp: interface given to Decode must be a pointer")
+ errDecodeIntoNil = errors.New("rlp: pointer given to Decode must not be nil")
+
+ streamPool = sync.Pool{
+ New: func() interface{} { return new(Stream) },
+ }
+)
+
+// 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 decode into the value pointed
+// to. If the pointer is nil, a new value of the pointer's element
+// type is allocated. If the pointer is non-nil, the existing value
+// will be reused.
+//
+// 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. The input list
+// must contain an element for each decoded field. Decode returns an
+// error if there are too few or too many elements.
+//
+// The decoding of struct fields honours certain struct tags, "tail",
+// "nil" and "-".
+//
+// The "-" tag ignores fields.
+//
+// For an explanation of "tail", see the example.
+//
+// The "nil" tag applies to pointer-typed fields and changes the decoding
+// rules for the field such that input values of size zero decode as a nil
+// pointer. This tag can be useful when decoding recursive types.
+//
+// type StructWithEmptyOK struct {
+// Foo *[20]byte `rlp:"nil"`
+// }
+//
+// To decode into a slice, the input must be a list and the resulting
+// slice will contain the input elements in order. For byte slices,
+// the input must be an RLP string. Array types decode similarly, with
+// the additional restriction that the number of input elements (or
+// bytes) must match the array's length.
+//
+// To decode into a Go string, the input must be an RLP string. The
+// input 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 a boolean, the input must contain an unsigned integer
+// of value zero (false) or one (true).
+//
+// 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 signed integers,
+// floating point numbers, maps, channels and functions.
+//
+// Note that Decode does not set an input limit for all readers
+// and may be vulnerable to panics cause by huge value sizes. If
+// you need an input limit, use
+//
+// NewStream(r, limit).Decode(val)
+func Decode(r io.Reader, val interface{}) error {
+ stream := streamPool.Get().(*Stream)
+ defer streamPool.Put(stream)
+
+ stream.Reset(r, 0)
+ return stream.Decode(val)
+}
+
+// DecodeBytes parses RLP data from b into val.
+// Please see the documentation of Decode for the decoding rules.
+// The input must contain exactly one value and no trailing data.
+func DecodeBytes(b []byte, val interface{}) error {
+ r := bytes.NewReader(b)
+
+ stream := streamPool.Get().(*Stream)
+ defer streamPool.Put(stream)
+
+ stream.Reset(r, uint64(len(b)))
+ if err := stream.Decode(val); err != nil {
+ return err
+ }
+ if r.Len() > 0 {
+ return ErrMoreThanOneValue
+ }
+ return nil
+}
+
+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 ErrCanonInt:
+ return &decodeError{msg: "non-canonical integer (leading zero bytes)", typ: typ}
+ case ErrCanonSize:
+ return &decodeError{msg: "non-canonical size information", typ: typ}
+ 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, tags tags) (dec decoder, err error) {
+ kind := typ.Kind()
+ switch {
+ case typ == rawValueType:
+ return decodeRawValue, nil
+ 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.Bool:
+ return decodeBool, nil
+ case kind == reflect.String:
+ return decodeString, nil
+ case kind == reflect.Slice || kind == reflect.Array:
+ return makeListDecoder(typ, tags)
+ case kind == reflect.Struct:
+ return makeStructDecoder(typ)
+ case kind == reflect.Ptr:
+ if tags.nilOK {
+ return makeOptionalPtrDecoder(typ)
+ }
+ return makePtrDecoder(typ)
+ case kind == reflect.Interface:
+ return decodeInterface, nil
+ default:
+ return nil, fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
+ }
+}
+
+func decodeRawValue(s *Stream, val reflect.Value) error {
+ r, err := s.Raw()
+ if err != nil {
+ return err
+ }
+ val.SetBytes(r)
+ return nil
+}
+
+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 decodeBool(s *Stream, val reflect.Value) error {
+ b, err := s.Bool()
+ if err != nil {
+ return wrapStreamError(err, val.Type())
+ }
+ val.SetBool(b)
+ 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))
+ }
+ // Reject leading zero bytes
+ if len(b) > 0 && b[0] == 0 {
+ return wrapStreamError(ErrCanonInt, val.Type())
+ }
+ i.SetBytes(b)
+ return nil
+}
+
+func makeListDecoder(typ reflect.Type, tag tags) (decoder, error) {
+ etype := typ.Elem()
+ if etype.Kind() == reflect.Uint8 && !reflect.PtrTo(etype).Implements(decoderInterface) {
+ if typ.Kind() == reflect.Array {
+ return decodeByteArray, nil
+ }
+ return decodeByteSlice, nil
+ }
+ etypeinfo := cachedTypeInfo1(etype, tags{})
+ if etypeinfo.decoderErr != nil {
+ return nil, etypeinfo.decoderErr
+ }
+ var dec decoder
+ switch {
+ case typ.Kind() == reflect.Array:
+ dec = func(s *Stream, val reflect.Value) error {
+ return decodeListArray(s, val, etypeinfo.decoder)
+ }
+ case tag.tail:
+ // A slice with "tail" tag can occur as the last field
+ // of a struct and is supposed to swallow all remaining
+ // list elements. The struct decoder already called s.List,
+ // proceed directly to decoding the elements.
+ dec = func(s *Stream, val reflect.Value) error {
+ return decodeSliceElems(s, val, etypeinfo.decoder)
+ }
+ default:
+ dec = func(s *Stream, val reflect.Value) error {
+ return decodeListSlice(s, val, etypeinfo.decoder)
+ }
+ }
+ return dec, 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()
+ }
+ if err := decodeSliceElems(s, val, elemdec); err != nil {
+ return err
+ }
+ return s.ListEnd()
+}
+
+func decodeSliceElems(s *Stream, val reflect.Value, elemdec decoder) error {
+ 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 nil
+}
+
+func decodeListArray(s *Stream, val reflect.Value, elemdec decoder) error {
+ if _, err := s.List(); err != nil {
+ return wrapStreamError(err, val.Type())
+ }
+ 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 {
+ return &decodeError{msg: "input list has too few elements", typ: val.Type()}
+ }
+ return wrapStreamError(s.ListEnd(), val.Type())
+}
+
+func decodeByteSlice(s *Stream, val reflect.Value) error {
+ b, err := s.Bytes()
+ if err != nil {
+ return wrapStreamError(err, val.Type())
+ }
+ val.SetBytes(b)
+ return nil
+}
+
+func decodeByteArray(s *Stream, val reflect.Value) error {
+ kind, size, err := s.Kind()
+ if err != nil {
+ return err
+ }
+ vlen := val.Len()
+ switch kind {
+ case Byte:
+ if vlen == 0 {
+ return &decodeError{msg: "input string too long", typ: val.Type()}
+ }
+ if vlen > 1 {
+ return &decodeError{msg: "input string too short", typ: val.Type()}
+ }
+ bv, _ := s.Uint()
+ val.Index(0).SetUint(bv)
+ case String:
+ if uint64(vlen) < size {
+ return &decodeError{msg: "input string too long", typ: val.Type()}
+ }
+ if uint64(vlen) > size {
+ return &decodeError{msg: "input string too short", typ: val.Type()}
+ }
+ slice := val.Slice(0, vlen).Interface().([]byte)
+ if err := s.readFull(slice); err != nil {
+ return err
+ }
+ // Reject cases where single byte encoding should have been used.
+ if size == 1 && slice[0] < 128 {
+ return wrapStreamError(ErrCanonSize, val.Type())
+ }
+ case List:
+ return wrapStreamError(ErrExpectedString, val.Type())
+ }
+ return nil
+}
+
+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 {
+ return &decodeError{msg: "too few elements", typ: typ}
+ } else if err != nil {
+ return addErrorContext(err, "."+typ.Field(f.index).Name)
+ }
+ }
+ return wrapStreamError(s.ListEnd(), typ)
+ }
+ return dec, nil
+}
+
+// makePtrDecoder creates a decoder that decodes into
+// the pointer's element type.
+func makePtrDecoder(typ reflect.Type) (decoder, error) {
+ etype := typ.Elem()
+ etypeinfo := cachedTypeInfo1(etype, tags{})
+ if etypeinfo.decoderErr != nil {
+ return nil, etypeinfo.decoderErr
+ }
+ dec := func(s *Stream, val reflect.Value) (err error) {
+ 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
+}
+
+// makeOptionalPtrDecoder creates a decoder that decodes empty values
+// as nil. Non-empty values are decoded into a value of the element type,
+// just like makePtrDecoder does.
+//
+// This decoder is used for pointer-typed struct fields with struct tag "nil".
+func makeOptionalPtrDecoder(typ reflect.Type) (decoder, error) {
+ etype := typ.Elem()
+ etypeinfo := cachedTypeInfo1(etype, tags{})
+ if etypeinfo.decoderErr != nil {
+ return nil, etypeinfo.decoderErr
+ }
+ dec := func(s *Stream, val reflect.Value) (err error) {
+ kind, size, err := s.Kind()
+ if err != nil || size == 0 && kind != Byte {
+ // rearm s.Kind. This is important because the input
+ // position must advance to the next value even though
+ // we don't read anything.
+ s.kind = -1
+ // set the pointer to nil.
+ val.Set(reflect.Zero(typ))
+ 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)
+ }
+}
+
+// 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
+
+ // number of bytes remaining to be read from r.
+ remaining uint64
+ limited bool
+
+ // auxiliary buffer for integer decoding
+ uintbuf []byte
+
+ kind Kind // kind of value ahead
+ size uint64 // size of value ahead
+ byteval byte // value of single byte in type tag
+ kinderr error // error from last readKind
+ stack []listpos
+}
+
+type listpos struct{ pos, size uint64 }
+
+// NewStream creates a new decoding stream reading from r.
+//
+// If r implements the ByteReader interface, Stream will
+// not introduce any buffering.
+//
+// For non-toplevel values, Stream returns ErrElemTooLarge
+// for values that do not fit into the enclosing list.
+//
+// Stream supports an optional input limit. If a limit is set, the
+// size of any toplevel value will be checked against the remaining
+// input length. Stream operations that encounter a value exceeding
+// the remaining input length will return ErrValueTooLarge. The limit
+// can be set by passing a non-zero value for inputLimit.
+//
+// If r is a bytes.Reader or strings.Reader, the input limit is set to
+// the length of r's underlying data unless an explicit limit is
+// provided.
+func NewStream(r io.Reader, inputLimit uint64) *Stream {
+ s := new(Stream)
+ s.Reset(r, inputLimit)
+ 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, len)
+ 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
+ }
+ if size == 1 && b[0] < 128 {
+ return nil, ErrCanonSize
+ }
+ return b, nil
+ default:
+ return nil, ErrExpectedString
+ }
+}
+
+// Raw reads a raw encoded value including RLP type information.
+func (s *Stream) Raw() ([]byte, error) {
+ kind, size, err := s.Kind()
+ if err != nil {
+ return nil, err
+ }
+ if kind == Byte {
+ s.kind = -1 // rearm Kind
+ return []byte{s.byteval}, nil
+ }
+ // the original header has already been read and is no longer
+ // available. read content and put a new header in front of it.
+ start := headsize(size)
+ buf := make([]byte, uint64(start)+size)
+ if err := s.readFull(buf[start:]); err != nil {
+ return nil, err
+ }
+ if kind == String {
+ puthead(buf, 0x80, 0xB7, size)
+ } else {
+ puthead(buf, 0xC0, 0xF7, size)
+ }
+ return buf, nil
+}
+
+// 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:
+ if s.byteval == 0 {
+ return 0, ErrCanonInt
+ }
+ s.kind = -1 // rearm Kind
+ return uint64(s.byteval), nil
+ case String:
+ if size > uint64(maxbits/8) {
+ return 0, errUintOverflow
+ }
+ v, err := s.readUint(byte(size))
+ switch {
+ case err == ErrCanonSize:
+ // Adjust error because we're not reading a size right now.
+ return 0, ErrCanonInt
+ case err != nil:
+ return 0, err
+ case size > 0 && v < 128:
+ return 0, ErrCanonSize
+ default:
+ return v, nil
+ }
+ default:
+ return 0, ErrExpectedString
+ }
+}
+
+// Bool reads an RLP string of up to 1 byte and returns its contents
+// as a boolean. If the input does not contain an RLP string, the
+// returned error will be ErrExpectedString.
+func (s *Stream) Bool() (bool, error) {
+ num, err := s.uint(8)
+ if err != nil {
+ return false, err
+ }
+ switch num {
+ case 0:
+ return false, nil
+ case 1:
+ return true, nil
+ default:
+ return false, fmt.Errorf("rlp: invalid boolean value: %d", num)
+ }
+}
+
+// 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
+ }
+ decoder, err := cachedDecoder(rtyp.Elem())
+ if err != nil {
+ return err
+ }
+
+ err = 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. This method is meant to facilitate reuse
+// of a preallocated Stream across many decoding operations.
+//
+// If r does not also implement ByteReader, Stream will do its own
+// buffering.
+func (s *Stream) Reset(r io.Reader, inputLimit uint64) {
+ if inputLimit > 0 {
+ s.remaining = inputLimit
+ s.limited = true
+ } else {
+ // Attempt to automatically discover
+ // the limit when reading from a byte slice.
+ switch br := r.(type) {
+ case *bytes.Reader:
+ s.remaining = uint64(br.Len())
+ s.limited = true
+ case *strings.Reader:
+ s.remaining = uint64(br.Len())
+ s.limited = true
+ default:
+ s.limited = false
+ }
+ }
+ // Wrap r with a buffer if it doesn't have one.
+ bufr, ok := r.(ByteReader)
+ if !ok {
+ bufr = bufio.NewReader(r)
+ }
+ s.r = bufr
+ // Reset the decoding context.
+ s.stack = s.stack[:0]
+ s.size = 0
+ s.kind = -1
+ s.kinderr = nil
+ if s.uintbuf == nil {
+ s.uintbuf = make([]byte, 8)
+ }
+ s.byteval = 0
+}
+
+// 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 {
+ s.kinderr = nil
+ // Don't read further if we're at the end of the
+ // innermost list.
+ if tos != nil && tos.pos == tos.size {
+ return 0, 0, EOL
+ }
+ s.kind, s.size, s.kinderr = s.readKind()
+ if s.kinderr == nil {
+ if tos == nil {
+ // At toplevel, check that the value is smaller
+ // than the remaining input length.
+ if s.limited && s.size > s.remaining {
+ s.kinderr = ErrValueTooLarge
+ }
+ } else {
+ // Inside a list, check that the value doesn't overflow the list.
+ if s.size > tos.size-tos.pos {
+ s.kinderr = ErrElemTooLarge
+ }
+ }
+ }
+ }
+ // Note: this might return a sticky error generated
+ // by an earlier call to readKind.
+ return s.kind, s.size, s.kinderr
+}
+
+func (s *Stream) readKind() (kind Kind, size uint64, err error) {
+ b, err := s.readByte()
+ if err != nil {
+ if len(s.stack) == 0 {
+ // At toplevel, Adjust the error to actual EOF. io.EOF is
+ // used by callers to determine when to stop decoding.
+ switch err {
+ case io.ErrUnexpectedEOF:
+ err = io.EOF
+ case ErrValueTooLarge:
+ err = io.EOF
+ }
+ }
+ 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)
+ if err == nil && size < 56 {
+ err = ErrCanonSize
+ }
+ 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)
+ if err == nil && size < 56 {
+ err = ErrCanonSize
+ }
+ return List, size, err
+ }
+}
+
+func (s *Stream) readUint(size byte) (uint64, error) {
+ switch size {
+ case 0:
+ s.kind = -1 // rearm Kind
+ return 0, nil
+ case 1:
+ b, err := s.readByte()
+ return uint64(b), err
+ default:
+ start := int(8 - size)
+ for i := 0; i < start; i++ {
+ s.uintbuf[i] = 0
+ }
+ if err := s.readFull(s.uintbuf[start:]); err != nil {
+ return 0, err
+ }
+ if s.uintbuf[start] == 0 {
+ // Note: readUint is also used to decode integer
+ // values. The error needs to be adjusted to become
+ // ErrCanonInt in this case.
+ return 0, ErrCanonSize
+ }
+ return binary.BigEndian.Uint64(s.uintbuf), nil
+ }
+}
+
+func (s *Stream) readFull(buf []byte) (err error) {
+ if err := s.willRead(uint64(len(buf))); err != nil {
+ return err
+ }
+ 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) {
+ if err := s.willRead(1); err != nil {
+ return 0, err
+ }
+ b, err := s.r.ReadByte()
+ if err == io.EOF {
+ err = io.ErrUnexpectedEOF
+ }
+ return b, err
+}
+
+func (s *Stream) willRead(n uint64) error {
+ s.kind = -1 // rearm Kind
+
+ if len(s.stack) > 0 {
+ // check list overflow
+ tos := s.stack[len(s.stack)-1]
+ if n > tos.size-tos.pos {
+ return ErrElemTooLarge
+ }
+ s.stack[len(s.stack)-1].pos += n
+ }
+ if s.limited {
+ if n > s.remaining {
+ return ErrValueTooLarge
+ }
+ s.remaining -= n
+ }
+ return nil
+}
diff --git a/vendor/github.com/ethereum/go-ethereum/rlp/doc.go b/vendor/github.com/ethereum/go-ethereum/rlp/doc.go
new file mode 100644
index 000000000..b3a81fe23
--- /dev/null
+++ b/vendor/github.com/ethereum/go-ethereum/rlp/doc.go
@@ -0,0 +1,33 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+/*
+Package rlp implements the RLP serialization format.
+
+The purpose of RLP (Recursive Linear Prefix) is 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 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/vendor/github.com/ethereum/go-ethereum/rlp/encode.go b/vendor/github.com/ethereum/go-ethereum/rlp/encode.go
new file mode 100644
index 000000000..f255c38a9
--- /dev/null
+++ b/vendor/github.com/ethereum/go-ethereum/rlp/encode.go
@@ -0,0 +1,651 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package rlp
+
+import (
+ "fmt"
+ "io"
+ "math/big"
+ "reflect"
+ "sync"
+)
+
+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.
+// A nil pointer to an array encodes as an empty list (or empty string
+// if the array has element type byte).
+//
+// 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.
+//
+// Boolean values are encoded as unsigned integers zero (false) and one (true).
+//
+// An interface value encodes as the value contained in the interface.
+//
+// Signed integers are not supported, nor are 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 := encbufPool.Get().(*encbuf)
+ defer encbufPool.Put(eb)
+ eb.reset()
+ if err := eb.encode(val); err != nil {
+ return err
+ }
+ return eb.toWriter(w)
+}
+
+// EncodeToBytes returns the RLP encoding of val.
+// Please see the documentation of Encode for the encoding rules.
+func EncodeToBytes(val interface{}) ([]byte, error) {
+ eb := encbufPool.Get().(*encbuf)
+ defer encbufPool.Put(eb)
+ eb.reset()
+ if err := eb.encode(val); err != nil {
+ return nil, err
+ }
+ return eb.toBytes(), nil
+}
+
+// EncodeToReader 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 := encbufPool.Get().(*encbuf)
+ eb.reset()
+ 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 {
+ return buf[:puthead(buf, 0xC0, 0xF7, uint64(head.size))]
+}
+
+// headsize returns the size of a list or string header
+// for a value of the given size.
+func headsize(size uint64) int {
+ if size < 56 {
+ return 1
+ }
+ return 1 + intsize(size)
+}
+
+// puthead writes a list or string header to buf.
+// buf must be at least 9 bytes long.
+func puthead(buf []byte, smalltag, largetag byte, size uint64) int {
+ if size < 56 {
+ buf[0] = smalltag + byte(size)
+ return 1
+ }
+ sizesize := putint(buf[1:], size)
+ buf[0] = largetag + byte(sizesize)
+ return sizesize + 1
+}
+
+// encbufs are pooled.
+var encbufPool = sync.Pool{
+ New: func() interface{} { return &encbuf{sizebuf: make([]byte, 9)} },
+}
+
+func (w *encbuf) reset() {
+ w.lhsize = 0
+ if w.str != nil {
+ w.str = w.str[:0]
+ }
+ if w.lheads != nil {
+ w.lheads = w.lheads[:0]
+ }
+}
+
+// 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)
+ writer, err := cachedWriter(rval.Type())
+ if err != nil {
+ return err
+ }
+ return 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) {
+ if len(b) == 1 && b[0] <= 0x7F {
+ // fits single byte, no string header
+ w.str = append(w.str, b[0])
+ } else {
+ 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++ // 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 {
+ // Put the encode buffer back into the pool at EOF when it
+ // is first encountered. Subsequent calls still return EOF
+ // as the error but the buffer is no longer valid.
+ if r.buf != nil {
+ encbufPool.Put(r.buf)
+ r.buf = 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
+ }
+}
+
+// next returns the next piece of data to be read.
+// it returns nil at EOF.
+func (r *encReader) next() []byte {
+ switch {
+ case r.buf == nil:
+ return nil
+
+ 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
+ }
+ 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, ts tags) (writer, error) {
+ kind := typ.Kind()
+ switch {
+ case typ == rawValueType:
+ return writeRawValue, nil
+ 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.Bool:
+ return writeBool, 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, ts)
+ 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 writeRawValue(val reflect.Value, w *encbuf) error {
+ w.str = append(w.str, val.Bytes()...)
+ return nil
+}
+
+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 writeBool(val reflect.Value, w *encbuf) error {
+ if val.Bool() {
+ w.str = append(w.str, 0x01)
+ } else {
+ w.str = append(w.str, 0x80)
+ }
+ return nil
+}
+
+func writeBigIntPtr(val reflect.Value, w *encbuf) error {
+ ptr := val.Interface().(*big.Int)
+ if ptr == nil {
+ w.str = append(w.str, 0x80)
+ return nil
+ }
+ return writeBigInt(ptr, 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 {
+ 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()
+ if len(s) == 1 && s[0] <= 0x7f {
+ // fits single byte, no string header
+ w.str = append(w.str, s[0])
+ } else {
+ 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 to 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()
+ writer, err := cachedWriter(eval.Type())
+ if err != nil {
+ return err
+ }
+ return writer(eval, w)
+}
+
+func makeSliceWriter(typ reflect.Type, ts tags) (writer, error) {
+ etypeinfo := cachedTypeInfo1(typ.Elem(), tags{})
+ if etypeinfo.writerErr != nil {
+ return nil, etypeinfo.writerErr
+ }
+ writer := func(val reflect.Value, w *encbuf) error {
+ if !ts.tail {
+ defer w.listEnd(w.list())
+ }
+ vlen := val.Len()
+ for i := 0; i < vlen; i++ {
+ if err := etypeinfo.writer(val.Index(i), w); err != nil {
+ return err
+ }
+ }
+ 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 := cachedTypeInfo1(typ.Elem(), tags{})
+ if etypeinfo.writerErr != nil {
+ return nil, etypeinfo.writerErr
+ }
+
+ // determine nil pointer handler
+ var nilfunc func(*encbuf) error
+ kind := typ.Elem().Kind()
+ switch {
+ case kind == reflect.Array && isByte(typ.Elem().Elem()):
+ nilfunc = func(w *encbuf) error {
+ w.str = append(w.str, 0x80)
+ return nil
+ }
+ case kind == reflect.Struct || kind == reflect.Array:
+ nilfunc = func(w *encbuf) error {
+ // encoding the zero value of a struct/array could trigger
+ // infinite recursion, avoid that.
+ w.listEnd(w.list())
+ return nil
+ }
+ default:
+ zero := reflect.Zero(typ.Elem())
+ nilfunc = func(w *encbuf) error {
+ return etypeinfo.writer(zero, w)
+ }
+ }
+
+ writer := func(val reflect.Value, w *encbuf) error {
+ if val.IsNil() {
+ return nilfunc(w)
+ }
+ return etypeinfo.writer(val.Elem(), w)
+ }
+ return writer, nil
+}
+
+// putint writes i to the beginning of b in 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
+ }
+ }
+}
diff --git a/vendor/github.com/ethereum/go-ethereum/rlp/raw.go b/vendor/github.com/ethereum/go-ethereum/rlp/raw.go
new file mode 100644
index 000000000..2b3f328f6
--- /dev/null
+++ b/vendor/github.com/ethereum/go-ethereum/rlp/raw.go
@@ -0,0 +1,156 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package rlp
+
+import (
+ "io"
+ "reflect"
+)
+
+// RawValue represents an encoded RLP value and can be used to delay
+// RLP decoding or to precompute an encoding. Note that the decoder does
+// not verify whether the content of RawValues is valid RLP.
+type RawValue []byte
+
+var rawValueType = reflect.TypeOf(RawValue{})
+
+// ListSize returns the encoded size of an RLP list with the given
+// content size.
+func ListSize(contentSize uint64) uint64 {
+ return uint64(headsize(contentSize)) + contentSize
+}
+
+// Split returns the content of first RLP value and any
+// bytes after the value as subslices of b.
+func Split(b []byte) (k Kind, content, rest []byte, err error) {
+ k, ts, cs, err := readKind(b)
+ if err != nil {
+ return 0, nil, b, err
+ }
+ return k, b[ts : ts+cs], b[ts+cs:], nil
+}
+
+// SplitString splits b into the content of an RLP string
+// and any remaining bytes after the string.
+func SplitString(b []byte) (content, rest []byte, err error) {
+ k, content, rest, err := Split(b)
+ if err != nil {
+ return nil, b, err
+ }
+ if k == List {
+ return nil, b, ErrExpectedString
+ }
+ return content, rest, nil
+}
+
+// SplitList splits b into the content of a list and any remaining
+// bytes after the list.
+func SplitList(b []byte) (content, rest []byte, err error) {
+ k, content, rest, err := Split(b)
+ if err != nil {
+ return nil, b, err
+ }
+ if k != List {
+ return nil, b, ErrExpectedList
+ }
+ return content, rest, nil
+}
+
+// CountValues counts the number of encoded values in b.
+func CountValues(b []byte) (int, error) {
+ i := 0
+ for ; len(b) > 0; i++ {
+ _, tagsize, size, err := readKind(b)
+ if err != nil {
+ return 0, err
+ }
+ b = b[tagsize+size:]
+ }
+ return i, nil
+}
+
+func readKind(buf []byte) (k Kind, tagsize, contentsize uint64, err error) {
+ if len(buf) == 0 {
+ return 0, 0, 0, io.ErrUnexpectedEOF
+ }
+ b := buf[0]
+ switch {
+ case b < 0x80:
+ k = Byte
+ tagsize = 0
+ contentsize = 1
+ case b < 0xB8:
+ k = String
+ tagsize = 1
+ contentsize = uint64(b - 0x80)
+ // Reject strings that should've been single bytes.
+ if contentsize == 1 && len(buf) > 1 && buf[1] < 128 {
+ return 0, 0, 0, ErrCanonSize
+ }
+ case b < 0xC0:
+ k = String
+ tagsize = uint64(b-0xB7) + 1
+ contentsize, err = readSize(buf[1:], b-0xB7)
+ case b < 0xF8:
+ k = List
+ tagsize = 1
+ contentsize = uint64(b - 0xC0)
+ default:
+ k = List
+ tagsize = uint64(b-0xF7) + 1
+ contentsize, err = readSize(buf[1:], b-0xF7)
+ }
+ if err != nil {
+ return 0, 0, 0, err
+ }
+ // Reject values larger than the input slice.
+ if contentsize > uint64(len(buf))-tagsize {
+ return 0, 0, 0, ErrValueTooLarge
+ }
+ return k, tagsize, contentsize, err
+}
+
+func readSize(b []byte, slen byte) (uint64, error) {
+ if int(slen) > len(b) {
+ return 0, io.ErrUnexpectedEOF
+ }
+ var s uint64
+ switch slen {
+ case 1:
+ s = uint64(b[0])
+ case 2:
+ s = uint64(b[0])<<8 | uint64(b[1])
+ case 3:
+ s = uint64(b[0])<<16 | uint64(b[1])<<8 | uint64(b[2])
+ case 4:
+ s = uint64(b[0])<<24 | uint64(b[1])<<16 | uint64(b[2])<<8 | uint64(b[3])
+ case 5:
+ s = uint64(b[0])<<32 | uint64(b[1])<<24 | uint64(b[2])<<16 | uint64(b[3])<<8 | uint64(b[4])
+ case 6:
+ s = uint64(b[0])<<40 | uint64(b[1])<<32 | uint64(b[2])<<24 | uint64(b[3])<<16 | uint64(b[4])<<8 | uint64(b[5])
+ case 7:
+ s = uint64(b[0])<<48 | uint64(b[1])<<40 | uint64(b[2])<<32 | uint64(b[3])<<24 | uint64(b[4])<<16 | uint64(b[5])<<8 | uint64(b[6])
+ case 8:
+ s = uint64(b[0])<<56 | uint64(b[1])<<48 | uint64(b[2])<<40 | uint64(b[3])<<32 | uint64(b[4])<<24 | uint64(b[5])<<16 | uint64(b[6])<<8 | uint64(b[7])
+ }
+ // Reject sizes < 56 (shouldn't have separate size) and sizes with
+ // leading zero bytes.
+ if s < 56 || b[0] == 0 {
+ return 0, ErrCanonSize
+ }
+ return s, nil
+}
diff --git a/vendor/github.com/ethereum/go-ethereum/rlp/typecache.go b/vendor/github.com/ethereum/go-ethereum/rlp/typecache.go
new file mode 100644
index 000000000..ab5ee3da7
--- /dev/null
+++ b/vendor/github.com/ethereum/go-ethereum/rlp/typecache.go
@@ -0,0 +1,165 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package rlp
+
+import (
+ "fmt"
+ "reflect"
+ "strings"
+ "sync"
+)
+
+var (
+ typeCacheMutex sync.RWMutex
+ typeCache = make(map[typekey]*typeinfo)
+)
+
+type typeinfo struct {
+ decoder decoder
+ decoderErr error // error from makeDecoder
+ writer writer
+ writerErr error // error from makeWriter
+}
+
+// represents struct tags
+type tags struct {
+ // rlp:"nil" controls whether empty input results in a nil pointer.
+ nilOK bool
+ // rlp:"tail" controls whether this field swallows additional list
+ // elements. It can only be set for the last field, which must be
+ // of slice type.
+ tail bool
+ // rlp:"-" ignores fields.
+ ignored bool
+}
+
+type typekey struct {
+ reflect.Type
+ // the key must include the struct tags because they
+ // might generate a different decoder.
+ tags
+}
+
+type decoder func(*Stream, reflect.Value) error
+
+type writer func(reflect.Value, *encbuf) error
+
+func cachedDecoder(typ reflect.Type) (decoder, error) {
+ info := cachedTypeInfo(typ, tags{})
+ return info.decoder, info.decoderErr
+}
+
+func cachedWriter(typ reflect.Type) (writer, error) {
+ info := cachedTypeInfo(typ, tags{})
+ return info.writer, info.writerErr
+}
+
+func cachedTypeInfo(typ reflect.Type, tags tags) *typeinfo {
+ typeCacheMutex.RLock()
+ info := typeCache[typekey{typ, tags}]
+ typeCacheMutex.RUnlock()
+ if info != nil {
+ return info
+ }
+ // not in the cache, need to generate info for this type.
+ typeCacheMutex.Lock()
+ defer typeCacheMutex.Unlock()
+ return cachedTypeInfo1(typ, tags)
+}
+
+func cachedTypeInfo1(typ reflect.Type, tags tags) *typeinfo {
+ key := typekey{typ, tags}
+ info := typeCache[key]
+ if info != nil {
+ // another goroutine got the write lock first
+ return info
+ }
+ // put a dummy 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.
+ info = new(typeinfo)
+ typeCache[key] = info
+ info.generate(typ, tags)
+ return info
+}
+
+type field struct {
+ index int
+ info *typeinfo
+}
+
+func structFields(typ reflect.Type) (fields []field, err error) {
+ lastPublic := lastPublicField(typ)
+ for i := 0; i < typ.NumField(); i++ {
+ if f := typ.Field(i); f.PkgPath == "" { // exported
+ tags, err := parseStructTag(typ, i, lastPublic)
+ if err != nil {
+ return nil, err
+ }
+ if tags.ignored {
+ continue
+ }
+ info := cachedTypeInfo1(f.Type, tags)
+ fields = append(fields, field{i, info})
+ }
+ }
+ return fields, nil
+}
+
+func parseStructTag(typ reflect.Type, fi, lastPublic int) (tags, error) {
+ f := typ.Field(fi)
+ var ts tags
+ for _, t := range strings.Split(f.Tag.Get("rlp"), ",") {
+ switch t = strings.TrimSpace(t); t {
+ case "":
+ case "-":
+ ts.ignored = true
+ case "nil":
+ ts.nilOK = true
+ case "tail":
+ ts.tail = true
+ if fi != lastPublic {
+ return ts, fmt.Errorf(`rlp: invalid struct tag "tail" for %v.%s (must be on last field)`, typ, f.Name)
+ }
+ if f.Type.Kind() != reflect.Slice {
+ return ts, fmt.Errorf(`rlp: invalid struct tag "tail" for %v.%s (field type is not slice)`, typ, f.Name)
+ }
+ default:
+ return ts, fmt.Errorf("rlp: unknown struct tag %q on %v.%s", t, typ, f.Name)
+ }
+ }
+ return ts, nil
+}
+
+func lastPublicField(typ reflect.Type) int {
+ last := 0
+ for i := 0; i < typ.NumField(); i++ {
+ if typ.Field(i).PkgPath == "" {
+ last = i
+ }
+ }
+ return last
+}
+
+func (i *typeinfo) generate(typ reflect.Type, tags tags) {
+ i.decoder, i.decoderErr = makeDecoder(typ, tags)
+ i.writer, i.writerErr = makeWriter(typ, tags)
+}
+
+func isUint(k reflect.Kind) bool {
+ return k >= reflect.Uint && k <= reflect.Uintptr
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-22 21:21:43 +0800