Removed RlpValue in favour of Value
This commit is contained in:
obscuren
parent
f247f0c518
commit
73fd358d94
@ -102,7 +102,7 @@ func CreateBlock(root interface{},
|
||||
|
||||
// Returns a hash of the block
|
||||
func (block *Block) Hash() []byte {
|
||||
return ethutil.Sha3Bin(block.RlpValue().Encode())
|
||||
return ethutil.Sha3Bin(block.Value().Encode())
|
||||
}
|
||||
|
||||
func (block *Block) HashNoNonce() []byte {
|
||||
@ -261,14 +261,14 @@ func (block *Block) SetTransactions(txs []*Transaction) {
|
||||
block.TxSha = ethutil.Sha3Bin(ethutil.Encode(block.rlpTxs()))
|
||||
}
|
||||
|
||||
func (block *Block) RlpValue() *ethutil.RlpValue {
|
||||
return ethutil.NewRlpValue([]interface{}{block.header(), block.rlpTxs(), block.rlpUncles()})
|
||||
func (block *Block) Value() *ethutil.Value {
|
||||
return ethutil.NewValue([]interface{}{block.header(), block.rlpTxs(), block.rlpUncles()})
|
||||
}
|
||||
|
||||
func (block *Block) RlpEncode() []byte {
|
||||
// Encode a slice interface which contains the header and the list of
|
||||
// transactions.
|
||||
return block.RlpValue().Encode()
|
||||
return block.Value().Encode()
|
||||
}
|
||||
|
||||
func (block *Block) RlpDecode(data []byte) {
|
||||
|
||||
@ -103,7 +103,7 @@ func (bc *BlockChain) GetChainFromHash(hash []byte, max uint64) []interface{} {
|
||||
block := bc.GetBlock(currentHash)
|
||||
currentHash = block.PrevHash
|
||||
|
||||
chain = append(chain, block.RlpValue().Value)
|
||||
chain = append(chain, block.Value().Val)
|
||||
//chain = append([]interface{}{block.RlpValue().Value}, chain...)
|
||||
|
||||
num--
|
||||
|
||||
@ -553,9 +553,9 @@ out:
|
||||
// Load the value in storage and push it on the stack
|
||||
x := bm.stack.Pop()
|
||||
// decode the object as a big integer
|
||||
decoder := ethutil.NewRlpValueFromBytes([]byte(contract.State().Get(x.String())))
|
||||
decoder := ethutil.NewValueFromBytes([]byte(contract.State().Get(x.String())))
|
||||
if !decoder.IsNil() {
|
||||
bm.stack.Push(decoder.AsBigInt())
|
||||
bm.stack.Push(decoder.BigInt())
|
||||
} else {
|
||||
bm.stack.Push(ethutil.BigFalse)
|
||||
}
|
||||
@ -618,10 +618,10 @@ func getContractMemory(block *Block, contractAddr []byte, memAddr *big.Int) *big
|
||||
val := contract.State().Get(memAddr.String())
|
||||
|
||||
// decode the object as a big integer
|
||||
decoder := ethutil.NewRlpValueFromBytes([]byte(val))
|
||||
decoder := ethutil.NewValueFromBytes([]byte(val))
|
||||
if decoder.IsNil() {
|
||||
return ethutil.BigFalse
|
||||
}
|
||||
|
||||
return decoder.AsBigInt()
|
||||
return decoder.BigInt()
|
||||
}
|
||||
|
||||
@ -23,11 +23,11 @@ func (c *Contract) RlpEncode() []byte {
|
||||
}
|
||||
|
||||
func (c *Contract) RlpDecode(data []byte) {
|
||||
decoder := ethutil.NewRlpValueFromBytes(data)
|
||||
decoder := ethutil.NewValueFromBytes(data)
|
||||
|
||||
c.Amount = decoder.Get(0).AsBigInt()
|
||||
c.Nonce = decoder.Get(1).AsUint()
|
||||
c.state = ethutil.NewTrie(ethutil.Config.Db, decoder.Get(2).AsRaw())
|
||||
c.Amount = decoder.Get(0).BigInt()
|
||||
c.Nonce = decoder.Get(1).Uint()
|
||||
c.state = ethutil.NewTrie(ethutil.Config.Db, decoder.Get(2).Interface())
|
||||
}
|
||||
|
||||
func (c *Contract) State() *ethutil.Trie {
|
||||
@ -59,8 +59,8 @@ func (a *Address) RlpEncode() []byte {
|
||||
}
|
||||
|
||||
func (a *Address) RlpDecode(data []byte) {
|
||||
decoder := ethutil.NewRlpValueFromBytes(data)
|
||||
decoder := ethutil.NewValueFromBytes(data)
|
||||
|
||||
a.Amount = decoder.Get(0).AsBigInt()
|
||||
a.Nonce = decoder.Get(1).AsUint()
|
||||
a.Amount = decoder.Get(0).BigInt()
|
||||
a.Nonce = decoder.Get(1).Uint()
|
||||
}
|
||||
|
||||
@ -29,9 +29,8 @@ func (db *MemDatabase) Get(key []byte) ([]byte, error) {
|
||||
func (db *MemDatabase) Print() {
|
||||
for key, val := range db.db {
|
||||
fmt.Printf("%x(%d): ", key, len(key))
|
||||
dec, _ := ethutil.Decode(val, 0)
|
||||
node := ethutil.Conv(dec)
|
||||
fmt.Printf("%q\n", node.AsRaw())
|
||||
node := ethutil.NewValueFromBytes(val)
|
||||
fmt.Printf("%q\n", node.Interface())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -60,8 +60,8 @@ type Ethereum struct {
|
||||
}
|
||||
|
||||
func New(caps Caps, usePnp bool) (*Ethereum, error) {
|
||||
//db, err := ethdb.NewLDBDatabase()
|
||||
db, err := ethdb.NewMemDatabase()
|
||||
db, err := ethdb.NewLDBDatabase()
|
||||
//db, err := ethdb.NewMemDatabase()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
189
ethutil/rlp.go
189
ethutil/rlp.go
@ -7,19 +7,8 @@ import (
|
||||
_ "log"
|
||||
_ "math"
|
||||
"math/big"
|
||||
"reflect"
|
||||
)
|
||||
|
||||
///////////////////////////////////////
|
||||
type EthEncoder interface {
|
||||
EncodeData(rlpData interface{}) []byte
|
||||
}
|
||||
type EthDecoder interface {
|
||||
Get(idx int) *RlpValue
|
||||
}
|
||||
|
||||
//////////////////////////////////////
|
||||
|
||||
type RlpEncoder struct {
|
||||
rlpData []byte
|
||||
}
|
||||
@ -33,180 +22,6 @@ 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 {
|
||||
@ -351,8 +166,8 @@ func Encode(object interface{}) []byte {
|
||||
|
||||
if object != nil {
|
||||
switch t := object.(type) {
|
||||
case *RlpValue:
|
||||
buff.Write(Encode(t.AsRaw()))
|
||||
case *Value:
|
||||
buff.Write(Encode(t.Raw()))
|
||||
// Code dup :-/
|
||||
case int:
|
||||
buff.Write(Encode(big.NewInt(int64(t))))
|
||||
|
||||
@ -82,7 +82,12 @@ func (cache *Cache) Undo() {
|
||||
}
|
||||
}
|
||||
|
||||
// A (modified) Radix Trie implementation
|
||||
// A (modified) Radix Trie implementation. The Trie implements
|
||||
// a caching mechanism and will used cached values if they are
|
||||
// present. If a node is not present in the cache it will try to
|
||||
// fetch it from the database and store the cached value.
|
||||
// Please note that the data isn't persisted unless `Sync` is
|
||||
// explicitly called.
|
||||
type Trie struct {
|
||||
Root interface{}
|
||||
//db Database
|
||||
@ -93,6 +98,7 @@ func NewTrie(db Database, Root interface{}) *Trie {
|
||||
return &Trie{cache: NewCache(db), Root: Root}
|
||||
}
|
||||
|
||||
// Save the cached value to the database.
|
||||
func (t *Trie) Sync() {
|
||||
t.cache.Commit()
|
||||
}
|
||||
@ -157,20 +163,8 @@ func (t *Trie) GetNode(node interface{}) *Value {
|
||||
} else if len(str) < 32 {
|
||||
return NewValueFromBytes([]byte(str))
|
||||
}
|
||||
/*
|
||||
else {
|
||||
// Fetch the encoded node from the db
|
||||
o, err := t.db.Get(n.Bytes())
|
||||
if err != nil {
|
||||
fmt.Println("Error InsertState", err)
|
||||
return NewValue("")
|
||||
}
|
||||
|
||||
return NewValueFromBytes(o)
|
||||
}
|
||||
*/
|
||||
return t.cache.Get(n.Bytes())
|
||||
|
||||
}
|
||||
|
||||
func (t *Trie) UpdateState(node interface{}, key []int, value string) interface{} {
|
||||
@ -302,53 +296,3 @@ func (t *Trie) Copy() *Trie {
|
||||
|
||||
return trie
|
||||
}
|
||||
|
||||
/*
|
||||
* Trie helper functions
|
||||
*/
|
||||
// Helper function for printing out the raw contents of a slice
|
||||
func PrintSlice(slice []string) {
|
||||
fmt.Printf("[")
|
||||
for i, val := range slice {
|
||||
fmt.Printf("%q", val)
|
||||
if i != len(slice)-1 {
|
||||
fmt.Printf(",")
|
||||
}
|
||||
}
|
||||
fmt.Printf("]\n")
|
||||
}
|
||||
|
||||
func PrintSliceT(slice interface{}) {
|
||||
c := Conv(slice)
|
||||
for i := 0; i < c.Length(); i++ {
|
||||
val := c.Get(i)
|
||||
if val.Type() == reflect.Slice {
|
||||
PrintSliceT(val.AsRaw())
|
||||
} else {
|
||||
fmt.Printf("%q", val)
|
||||
if i != c.Length()-1 {
|
||||
fmt.Printf(",")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// RLP Decodes a node in to a [2] or [17] string slice
|
||||
func DecodeNode(data []byte) []string {
|
||||
dec, _ := Decode(data, 0)
|
||||
if slice, ok := dec.([]interface{}); ok {
|
||||
strSlice := make([]string, len(slice))
|
||||
|
||||
for i, s := range slice {
|
||||
if str, ok := s.([]byte); ok {
|
||||
strSlice[i] = string(str)
|
||||
}
|
||||
}
|
||||
|
||||
return strSlice
|
||||
} else {
|
||||
fmt.Printf("It wasn't a []. It's a %T\n", dec)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user