bsc/ethutil/rlp.go

package ethutil

import (
	"bytes"
	_ "encoding/binary"
	"fmt"
	_ "log"
	_ "math"
	"math/big"
	"reflect"
)

///////////////////////////////////////
type EthEncoder interface {
	EncodeData(rlpData interface{}) []byte
}
type EthDecoder interface {
	Get(idx int) *RlpValue
}

//////////////////////////////////////

type RlpEncoder struct {
	rlpData []byte
}

func NewRlpEncoder() *RlpEncoder {
	encoder := &RlpEncoder{}

	return encoder
}
func (coder *RlpEncoder) EncodeData(rlpData interface{}) []byte {
	return Encode(rlpData)
}

// Data rlpValueutes are returned by the rlp decoder. The data rlpValueutes represents
// one item within the rlp data structure. It's responsible for all the casting
// It always returns something rlpValueid
type RlpValue struct {
	Value interface{}
	kind  reflect.Value
}

func (rlpValue *RlpValue) String() string {
	return fmt.Sprintf("%q", rlpValue.Value)
}

func Conv(rlpValue interface{}) *RlpValue {
	return &RlpValue{Value: rlpValue, kind: reflect.ValueOf(rlpValue)}
}

func NewRlpValue(rlpValue interface{}) *RlpValue {
	return &RlpValue{Value: rlpValue}
}

func (rlpValue *RlpValue) Type() reflect.Kind {
	return reflect.TypeOf(rlpValue.Value).Kind()
}

func (rlpValue *RlpValue) IsNil() bool {
	return rlpValue.Value == nil
}

func (rlpValue *RlpValue) Length() int {
	//return rlpValue.kind.Len()
	if data, ok := rlpValue.Value.([]interface{}); ok {
		return len(data)
	}

	return 0
}

func (rlpValue *RlpValue) AsRaw() interface{} {
	return rlpValue.Value
}

func (rlpValue *RlpValue) AsUint() uint64 {
	if Value, ok := rlpValue.Value.(uint8); ok {
		return uint64(Value)
	} else if Value, ok := rlpValue.Value.(uint16); ok {
		return uint64(Value)
	} else if Value, ok := rlpValue.Value.(uint32); ok {
		return uint64(Value)
	} else if Value, ok := rlpValue.Value.(uint64); ok {
		return Value
	}

	return 0
}

func (rlpValue *RlpValue) AsByte() byte {
	if Value, ok := rlpValue.Value.(byte); ok {
		return Value
	}

	return 0x0
}

func (rlpValue *RlpValue) AsBigInt() *big.Int {
	if a, ok := rlpValue.Value.([]byte); ok {
		b := new(big.Int)
		b.SetBytes(a)
		return b
	}

	return big.NewInt(0)
}

func (rlpValue *RlpValue) AsString() string {
	if a, ok := rlpValue.Value.([]byte); ok {
		return string(a)
	} else if a, ok := rlpValue.Value.(string); ok {
		return a
	} else {
		//panic(fmt.Sprintf("not string %T: %v", rlpValue.Value, rlpValue.Value))
	}

	return ""
}

func (rlpValue *RlpValue) AsBytes() []byte {
	if a, ok := rlpValue.Value.([]byte); ok {
		return a
	}

	return make([]byte, 0)
}

func (rlpValue *RlpValue) AsSlice() []interface{} {
	if d, ok := rlpValue.Value.([]interface{}); ok {
		return d
	}

	return []interface{}{}
}

func (rlpValue *RlpValue) AsSliceFrom(from int) *RlpValue {
	slice := rlpValue.AsSlice()

	return NewRlpValue(slice[from:])
}

func (rlpValue *RlpValue) AsSliceTo(to int) *RlpValue {
	slice := rlpValue.AsSlice()

	return NewRlpValue(slice[:to])
}

func (rlpValue *RlpValue) AsSliceFromTo(from, to int) *RlpValue {
	slice := rlpValue.AsSlice()

	return NewRlpValue(slice[from:to])
}

// Threat the rlpValueute as a slice
func (rlpValue *RlpValue) Get(idx int) *RlpValue {
	if d, ok := rlpValue.Value.([]interface{}); ok {
		// Guard for oob
		if len(d) <= idx {
			return NewRlpValue(nil)
		}

		if idx < 0 {
			panic("negative idx for Rlp Get")
		}

		return NewRlpValue(d[idx])
	}

	// If this wasn't a slice you probably shouldn't be using this function
	return NewRlpValue(nil)
}

func (rlpValue *RlpValue) Cmp(o *RlpValue) bool {
	return reflect.DeepEqual(rlpValue.Value, o.Value)
}

func (rlpValue *RlpValue) Encode() []byte {
	return Encode(rlpValue.Value)
}

func NewRlpValueFromBytes(rlpData []byte) *RlpValue {
	if len(rlpData) != 0 {
		data, _ := Decode(rlpData, 0)
		return NewRlpValue(data)
	}

	return NewRlpValue(nil)
}

// RlpValue value setters
// An empty rlp value is always a list
func EmptyRlpValue() *RlpValue {
	return NewRlpValue([]interface{}{})
}

func (rlpValue *RlpValue) AppendList() *RlpValue {
	list := EmptyRlpValue()
	rlpValue.Value = append(rlpValue.AsSlice(), list)

	return list
}

func (rlpValue *RlpValue) Append(v interface{}) *RlpValue {
	rlpValue.Value = append(rlpValue.AsSlice(), v)

	return rlpValue
}

/*
func FromBin(data []byte) uint64 {
	if len(data) == 0 {
		return 0
	}

	return FromBin(data[:len(data)-1])*256 + uint64(data[len(data)-1])
}
*/

const (
	RlpEmptyList = 0x80
	RlpEmptyStr  = 0x40
)

func Char(c []byte) int {
	if len(c) > 0 {
		return int(c[0])
	}

	return 0
}

func DecodeWithReader(reader *bytes.Buffer) interface{} {
	var slice []interface{}

	// Read the next byte
	char := Char(reader.Next(1))
	switch {
	case char == 0:
		return nil
	case char <= 0x7c:
		return char

	case char <= 0xb7:
		return reader.Next(int(char - 0x80))

	case char <= 0xbf:
		buff := bytes.NewReader(reader.Next(int(char - 0xb8)))
		length := ReadVarint(buff)

		return reader.Next(int(length))

	case char <= 0xf7:
		length := int(char - 0xc0)
		for i := 0; i < length; i++ {
			obj := DecodeWithReader(reader)
			if obj != nil {
				slice = append(slice, obj)
			} else {
				break
			}
		}

		return slice

	}

	return slice
}

// TODO Use a bytes.Buffer instead of a raw byte slice.
// Cleaner code, and use draining instead of seeking the next bytes to read
func Decode(data []byte, pos uint64) (interface{}, uint64) {
	/*
		if pos > uint64(len(data)-1) {
			log.Println(data)
			log.Panicf("index out of range %d for data %q, l = %d", pos, data, len(data))
		}
	*/

	var slice []interface{}
	char := int(data[pos])
	switch {
	case char <= 0x7f:
		return data[pos], pos + 1

	case char <= 0xb7:
		b := uint64(data[pos]) - 0x80

		return data[pos+1 : pos+1+b], pos + 1 + b

	case char <= 0xbf:
		b := uint64(data[pos]) - 0xb7

		b2 := ReadVarint(bytes.NewReader(data[pos+1 : pos+1+b]))

		return data[pos+1+b : pos+1+b+b2], pos + 1 + b + b2

	case char <= 0xf7:
		b := uint64(data[pos]) - 0xc0
		prevPos := pos
		pos++
		for i := uint64(0); i < b; {
			var obj interface{}

			// Get the next item in the data list and append it
			obj, prevPos = Decode(data, pos)
			slice = append(slice, obj)

			// Increment i by the amount bytes read in the previous
			// read
			i += (prevPos - pos)
			pos = prevPos
		}
		return slice, pos

	case char <= 0xff:
		l := uint64(data[pos]) - 0xf7
		//b := BigD(data[pos+1 : pos+1+l]).Uint64()
		b := ReadVarint(bytes.NewReader(data[pos+1 : pos+1+l]))

		pos = pos + l + 1

		prevPos := b
		for i := uint64(0); i < uint64(b); {
			var obj interface{}

			obj, prevPos = Decode(data, pos)
			slice = append(slice, obj)

			i += (prevPos - pos)
			pos = prevPos
		}
		return slice, pos

	default:
		panic(fmt.Sprintf("byte not supported: %q", char))
	}

	return slice, 0
}

var (
	directRlp = big.NewInt(0x7f)
	numberRlp = big.NewInt(0xb7)
	zeroRlp   = big.NewInt(0x0)
)

func Encode(object interface{}) []byte {
	var buff bytes.Buffer

	if object != nil {
		switch t := object.(type) {
		case *RlpValue:
			buff.Write(Encode(t.AsRaw()))
		// Code dup :-/
		case int:
			buff.Write(Encode(big.NewInt(int64(t))))
		case uint:
			buff.Write(Encode(big.NewInt(int64(t))))
		case int8:
			buff.Write(Encode(big.NewInt(int64(t))))
		case int16:
			buff.Write(Encode(big.NewInt(int64(t))))
		case int32:
			buff.Write(Encode(big.NewInt(int64(t))))
		case int64:
			buff.Write(Encode(big.NewInt(t)))
		case uint16:
			buff.Write(Encode(big.NewInt(int64(t))))
		case uint32:
			buff.Write(Encode(big.NewInt(int64(t))))
		case uint64:
			buff.Write(Encode(big.NewInt(int64(t))))
		case byte:
			buff.Write(Encode(big.NewInt(int64(t))))
		case *big.Int:
			buff.Write(Encode(t.Bytes()))
		case []byte:
			if len(t) == 1 && t[0] <= 0x7f {
				buff.Write(t)
			} else if len(t) < 56 {
				buff.WriteByte(byte(len(t) + 0x80))
				buff.Write(t)
			} else {
				b := big.NewInt(int64(len(t)))
				buff.WriteByte(byte(len(b.Bytes()) + 0xb7))
				buff.Write(b.Bytes())
				buff.Write(t)
			}
		case string:
			buff.Write(Encode([]byte(t)))
		case []interface{}:
			// Inline function for writing the slice header
			WriteSliceHeader := func(length int) {
				if length < 56 {
					buff.WriteByte(byte(length + 0xc0))
				} else {
					b := big.NewInt(int64(length))
					buff.WriteByte(byte(len(b.Bytes()) + 0xf7))
					buff.Write(b.Bytes())
				}
			}

			var b bytes.Buffer
			for _, val := range t {
				b.Write(Encode(val))
			}
			WriteSliceHeader(len(b.Bytes()))
			buff.Write(b.Bytes())
		}
	} else {
		// Empty list for nil
		buff.WriteByte(0xc0)
	}

	return buff.Bytes()
}