github.com/haliliceylan/bsc@v1.1.10-0.20220501224556-eb78d644ebcb/rlp/doc.go (about)

     1  // Copyright 2014 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  /*
    18  Package rlp implements the RLP serialization format.
    19  
    20  The purpose of RLP (Recursive Linear Prefix) is to encode arbitrarily nested arrays of
    21  binary data, and RLP is the main encoding method used to serialize objects in Ethereum.
    22  The only purpose of RLP is to encode structure; encoding specific atomic data types (eg.
    23  strings, ints, floats) is left up to higher-order protocols. In Ethereum integers must be
    24  represented in big endian binary form with no leading zeroes (thus making the integer
    25  value zero equivalent to the empty string).
    26  
    27  RLP values are distinguished by a type tag. The type tag precedes the value in the input
    28  stream and defines the size and kind of the bytes that follow.
    29  
    30  
    31  Encoding Rules
    32  
    33  Package rlp uses reflection and encodes RLP based on the Go type of the value.
    34  
    35  If the type implements the Encoder interface, Encode calls EncodeRLP. It does not
    36  call EncodeRLP on nil pointer values.
    37  
    38  To encode a pointer, the value being pointed to is encoded. A nil pointer to a struct
    39  type, slice or array always encodes as an empty RLP list unless the slice or array has
    40  elememt type byte. A nil pointer to any other value encodes as the empty string.
    41  
    42  Struct values are encoded as an RLP list of all their encoded public fields. Recursive
    43  struct types are supported.
    44  
    45  To encode slices and arrays, the elements are encoded as an RLP list of the value's
    46  elements. Note that arrays and slices with element type uint8 or byte are always encoded
    47  as an RLP string.
    48  
    49  A Go string is encoded as an RLP string.
    50  
    51  An unsigned integer value is encoded as an RLP string. Zero always encodes as an empty RLP
    52  string. big.Int values are treated as integers. Signed integers (int, int8, int16, ...)
    53  are not supported and will return an error when encoding.
    54  
    55  Boolean values are encoded as the unsigned integers zero (false) and one (true).
    56  
    57  An interface value encodes as the value contained in the interface.
    58  
    59  Floating point numbers, maps, channels and functions are not supported.
    60  
    61  
    62  Decoding Rules
    63  
    64  Decoding uses the following type-dependent rules:
    65  
    66  If the type implements the Decoder interface, DecodeRLP is called.
    67  
    68  To decode into a pointer, the value will be decoded as the element type of the pointer. If
    69  the pointer is nil, a new value of the pointer's element type is allocated. If the pointer
    70  is non-nil, the existing value will be reused. Note that package rlp never leaves a
    71  pointer-type struct field as nil unless one of the "nil" struct tags is present.
    72  
    73  To decode into a struct, decoding expects the input to be an RLP list. The decoded
    74  elements of the list are assigned to each public field in the order given by the struct's
    75  definition. The input list must contain an element for each decoded field. Decoding
    76  returns an error if there are too few or too many elements for the struct.
    77  
    78  To decode into a slice, the input must be a list and the resulting slice will contain the
    79  input elements in order. For byte slices, the input must be an RLP string. Array types
    80  decode similarly, with the additional restriction that the number of input elements (or
    81  bytes) must match the array's defined length.
    82  
    83  To decode into a Go string, the input must be an RLP string. The input bytes are taken
    84  as-is and will not necessarily be valid UTF-8.
    85  
    86  To decode into an unsigned integer type, the input must also be an RLP string. The bytes
    87  are interpreted as a big endian representation of the integer. If the RLP string is larger
    88  than the bit size of the type, decoding will return an error. Decode also supports
    89  *big.Int. There is no size limit for big integers.
    90  
    91  To decode into a boolean, the input must contain an unsigned integer of value zero (false)
    92  or one (true).
    93  
    94  To decode into an interface value, one of these types is stored in the value:
    95  
    96  	  []interface{}, for RLP lists
    97  	  []byte, for RLP strings
    98  
    99  Non-empty interface types are not supported when decoding.
   100  Signed integers, floating point numbers, maps, channels and functions cannot be decoded into.
   101  
   102  
   103  Struct Tags
   104  
   105  Package rlp honours certain struct tags: "-", "tail", "nil", "nilList" and "nilString".
   106  
   107  The "-" tag ignores fields.
   108  
   109  The "tail" tag, which may only be used on the last exported struct field, allows slurping
   110  up any excess list elements into a slice. See examples for more details.
   111  
   112  The "nil" tag applies to pointer-typed fields and changes the decoding rules for the field
   113  such that input values of size zero decode as a nil pointer. This tag can be useful when
   114  decoding recursive types.
   115  
   116      type StructWithOptionalFoo struct {
   117          Foo *[20]byte `rlp:"nil"`
   118      }
   119  
   120  RLP supports two kinds of empty values: empty lists and empty strings. When using the
   121  "nil" tag, the kind of empty value allowed for a type is chosen automatically. A struct
   122  field whose Go type is a pointer to an unsigned integer, string, boolean or byte
   123  array/slice expects an empty RLP string. Any other pointer field type encodes/decodes as
   124  an empty RLP list.
   125  
   126  The choice of null value can be made explicit with the "nilList" and "nilString" struct
   127  tags. Using these tags encodes/decodes a Go nil pointer value as the kind of empty
   128  RLP value defined by the tag.
   129  */
   130  package rlp