aboutsummaryrefslogtreecommitdiffstats
path: root/common
diff options
context:
space:
mode:
Diffstat (limited to 'common')
-rw-r--r--common/big.go4
-rw-r--r--common/bytes.go2
-rw-r--r--common/rlp.go2
-rw-r--r--common/rlp_test.go28
-rw-r--r--common/types.go82
-rw-r--r--common/types_template.go48
-rw-r--r--common/types_test.go15
-rw-r--r--common/value.go69
-rw-r--r--common/value_test.go2
9 files changed, 204 insertions, 48 deletions
diff --git a/common/big.go b/common/big.go
index 750b28f85..8fe9d8bef 100644
--- a/common/big.go
+++ b/common/big.go
@@ -104,7 +104,7 @@ func BigCopy(src *big.Int) *big.Int {
//
// Returns the maximum size big integer
func BigMax(x, y *big.Int) *big.Int {
- if x.Cmp(y) <= 0 {
+ if x.Cmp(y) < 0 {
return y
}
@@ -115,7 +115,7 @@ func BigMax(x, y *big.Int) *big.Int {
//
// Returns the minimum size big integer
func BigMin(x, y *big.Int) *big.Int {
- if x.Cmp(y) >= 0 {
+ if x.Cmp(y) > 0 {
return y
}
diff --git a/common/bytes.go b/common/bytes.go
index 4aef9a223..5e553d23c 100644
--- a/common/bytes.go
+++ b/common/bytes.go
@@ -211,7 +211,7 @@ func RightPadString(str string, l int) string {
}
-func Address(slice []byte) (addr []byte) {
+func ToAddress(slice []byte) (addr []byte) {
if len(slice) < 20 {
addr = LeftPadBytes(slice, 20)
} else if len(slice) > 20 {
diff --git a/common/rlp.go b/common/rlp.go
index 602f13202..06ac410e9 100644
--- a/common/rlp.go
+++ b/common/rlp.go
@@ -112,7 +112,7 @@ func Encode(object interface{}) []byte {
if object != nil {
switch t := object.(type) {
case *Value:
- buff.Write(Encode(t.Raw()))
+ buff.Write(Encode(t.Val))
case RlpEncodable:
buff.Write(Encode(t.RlpData()))
// Code dup :-/
diff --git a/common/rlp_test.go b/common/rlp_test.go
index 16a3553d7..2a55da928 100644
--- a/common/rlp_test.go
+++ b/common/rlp_test.go
@@ -5,6 +5,8 @@ import (
"math/big"
"reflect"
"testing"
+
+ "github.com/ethereum/go-ethereum/rlp"
)
func TestNonInterfaceSlice(t *testing.T) {
@@ -19,13 +21,16 @@ func TestNonInterfaceSlice(t *testing.T) {
func TestRlpValueEncoding(t *testing.T) {
val := EmptyValue()
- val.AppendList().Append(1).Append(2).Append(3)
- val.Append("4").AppendList().Append(5)
+ val.AppendList().Append(byte(1)).Append(byte(2)).Append(byte(3))
+ val.Append("4").AppendList().Append(byte(5))
- res := val.Encode()
+ res, err := rlp.EncodeToBytes(val)
+ if err != nil {
+ t.Fatalf("encode error: %v", err)
+ }
exp := Encode([]interface{}{[]interface{}{1, 2, 3}, "4", []interface{}{5}})
if bytes.Compare(res, exp) != 0 {
- t.Errorf("expected %q, got %q", res, exp)
+ t.Errorf("expected %x, got %x", exp, res)
}
}
@@ -57,9 +62,7 @@ func TestValueSlice(t *testing.T) {
func TestLargeData(t *testing.T) {
data := make([]byte, 100000)
enc := Encode(data)
- value := NewValue(enc)
- value.Decode()
-
+ value := NewValueFromBytes(enc)
if value.Len() != len(data) {
t.Error("Expected data to be", len(data), "got", value.Len())
}
@@ -133,15 +136,16 @@ func TestEncodeDecodeBigInt(t *testing.T) {
}
func TestEncodeDecodeBytes(t *testing.T) {
- b := NewValue([]interface{}{[]byte{1, 2, 3, 4, 5}, byte(6)})
- val := NewValueFromBytes(b.Encode())
- if !b.Cmp(val) {
- t.Errorf("Expected %v, got %v", val, b)
+ bv := NewValue([]interface{}{[]byte{1, 2, 3, 4, 5}, []byte{6}})
+ b, _ := rlp.EncodeToBytes(bv)
+ val := NewValueFromBytes(b)
+ if !bv.Cmp(val) {
+ t.Errorf("Expected %#v, got %#v", bv, val)
}
}
func TestEncodeZero(t *testing.T) {
- b := NewValue(0).Encode()
+ b, _ := rlp.EncodeToBytes(NewValue(0))
exp := []byte{0xc0}
if bytes.Compare(b, exp) == 0 {
t.Error("Expected", exp, "got", b)
diff --git a/common/types.go b/common/types.go
index 6a9abdf18..daefcde11 100644
--- a/common/types.go
+++ b/common/types.go
@@ -1,6 +1,84 @@
package common
+import "math/big"
+
+const (
+ hashLength = 32
+ addressLength = 20
+)
+
type (
- uHash [32]byte
- uAddress [20]byte
+ Hash [hashLength]byte
+ Address [addressLength]byte
)
+
+func BytesToHash(b []byte) Hash {
+ var h Hash
+ h.SetBytes(b)
+ return h
+}
+func StringToHash(s string) Hash { return BytesToHash([]byte(s)) }
+func BigToHash(b *big.Int) Hash { return BytesToHash(b.Bytes()) }
+func HexToHash(s string) Hash { return BytesToHash(FromHex(s)) }
+
+// Don't use the default 'String' method in case we want to overwrite
+
+// Get the string representation of the underlying hash
+func (h Hash) Str() string { return string(h[:]) }
+func (h Hash) Bytes() []byte { return h[:] }
+func (h Hash) Big() *big.Int { return Bytes2Big(h[:]) }
+func (h Hash) Hex() string { return "0x" + Bytes2Hex(h[:]) }
+
+// Sets the hash to the value of b. If b is larger than len(h) it will panic
+func (h *Hash) SetBytes(b []byte) {
+ if len(b) > len(h) {
+ b = b[len(b)-hashLength:]
+ }
+
+ copy(h[hashLength-len(b):], b)
+}
+
+// Set string `s` to h. If s is larger than len(h) it will panic
+func (h *Hash) SetString(s string) { h.SetBytes([]byte(s)) }
+
+// Sets h to other
+func (h *Hash) Set(other Hash) {
+ for i, v := range other {
+ h[i] = v
+ }
+}
+
+/////////// Address
+func BytesToAddress(b []byte) Address {
+ var a Address
+ a.SetBytes(b)
+ return a
+}
+func StringToAddress(s string) Address { return BytesToAddress([]byte(s)) }
+func BigToAddress(b *big.Int) Address { return BytesToAddress(b.Bytes()) }
+func HexToAddress(s string) Address { return BytesToAddress(FromHex(s)) }
+
+// Get the string representation of the underlying address
+func (a Address) Str() string { return string(a[:]) }
+func (a Address) Bytes() []byte { return a[:] }
+func (a Address) Big() *big.Int { return Bytes2Big(a[:]) }
+func (a Address) Hash() Hash { return BytesToHash(a[:]) }
+func (a Address) Hex() string { return "0x" + Bytes2Hex(a[:]) }
+
+// Sets the address to the value of b. If b is larger than len(a) it will panic
+func (a *Address) SetBytes(b []byte) {
+ if len(b) > len(a) {
+ b = b[len(b)-addressLength:]
+ }
+ copy(a[addressLength-len(b):], b)
+}
+
+// Set string `s` to a. If s is larger than len(a) it will panic
+func (a *Address) SetString(s string) { a.SetBytes([]byte(s)) }
+
+// Sets a to other
+func (a *Address) Set(other Address) {
+ for i, v := range other {
+ a[i] = v
+ }
+}
diff --git a/common/types_template.go b/common/types_template.go
new file mode 100644
index 000000000..1c82a36dc
--- /dev/null
+++ b/common/types_template.go
@@ -0,0 +1,48 @@
+// +build none
+//sed -e 's/_N_/Hash/g' -e 's/_S_/32/g' -e '1d' types_template.go | gofmt -w hash.go
+
+package common
+
+import "math/big"
+
+type _N_ [_S_]byte
+
+func BytesTo_N_(b []byte) _N_ {
+ var h _N_
+ h.SetBytes(b)
+ return h
+}
+func StringTo_N_(s string) _N_ { return BytesTo_N_([]byte(s)) }
+func BigTo_N_(b *big.Int) _N_ { return BytesTo_N_(b.Bytes()) }
+func HexTo_N_(s string) _N_ { return BytesTo_N_(FromHex(s)) }
+
+// Don't use the default 'String' method in case we want to overwrite
+
+// Get the string representation of the underlying hash
+func (h _N_) Str() string { return string(h[:]) }
+func (h _N_) Bytes() []byte { return h[:] }
+func (h _N_) Big() *big.Int { return Bytes2Big(h[:]) }
+func (h _N_) Hex() string { return "0x" + Bytes2Hex(h[:]) }
+
+// Sets the hash to the value of b. If b is larger than len(h) it will panic
+func (h *_N_) SetBytes(b []byte) {
+ // Use the right most bytes
+ if len(b) > len(h) {
+ b = b[len(b)-_S_:]
+ }
+
+ // Reverse the loop
+ for i := len(b) - 1; i >= 0; i-- {
+ h[_S_-len(b)+i] = b[i]
+ }
+}
+
+// Set string `s` to h. If s is larger than len(h) it will panic
+func (h *_N_) SetString(s string) { h.SetBytes([]byte(s)) }
+
+// Sets h to other
+func (h *_N_) Set(other _N_) {
+ for i, v := range other {
+ h[i] = v
+ }
+}
diff --git a/common/types_test.go b/common/types_test.go
new file mode 100644
index 000000000..9f303152c
--- /dev/null
+++ b/common/types_test.go
@@ -0,0 +1,15 @@
+package common
+
+import "testing"
+
+func TestBytesConversion(t *testing.T) {
+ bytes := []byte{5}
+ hash := BytesToHash(bytes)
+
+ var exp Hash
+ exp[31] = 5
+
+ if hash != exp {
+ t.Errorf("expected %x got %x", exp, hash)
+ }
+}
diff --git a/common/value.go b/common/value.go
index 72a123772..c3893d565 100644
--- a/common/value.go
+++ b/common/value.go
@@ -3,18 +3,30 @@ package common
import (
"bytes"
"fmt"
+ "io"
"math/big"
"reflect"
"strconv"
+
+ "github.com/ethereum/go-ethereum/rlp"
)
-// Data values are returned by the rlp decoder. The data values represents
-// one item within the rlp data structure. It's responsible for all the casting
-// It always returns something valid
-type Value struct {
- Val interface{}
- kind reflect.Value
-}
+// Value can hold values of certain basic types and provides ways to
+// convert between types without bothering to check whether the
+// conversion is actually meaningful.
+//
+// It currently supports the following types:
+//
+// - int{,8,16,32,64}
+// - uint{,8,16,32,64}
+// - *big.Int
+// - []byte, string
+// - []interface{}
+//
+// Value is useful whenever you feel that Go's types limit your
+// ability to express yourself. In these situations, use Value and
+// forget about this strong typing nonsense.
+type Value struct{ Val interface{} }
func (val *Value) String() string {
return fmt.Sprintf("%x", val.Val)
@@ -38,7 +50,6 @@ func (val *Value) IsNil() bool {
}
func (val *Value) Len() int {
- //return val.kind.Len()
if data, ok := val.Val.([]interface{}); ok {
return len(data)
}
@@ -46,14 +57,6 @@ func (val *Value) Len() int {
return len(val.Bytes())
}
-func (val *Value) Raw() interface{} {
- return val.Val
-}
-
-func (val *Value) Interface() interface{} {
- return val.Val
-}
-
func (val *Value) Uint() uint64 {
if Val, ok := val.Val.(uint8); ok {
return uint64(Val)
@@ -260,26 +263,34 @@ func (self *Value) DeepCmp(o *Value) bool {
return bytes.Compare(self.Bytes(), o.Bytes()) == 0
}
-func (val *Value) Encode() []byte {
- return Encode(val.Val)
+func (self *Value) DecodeRLP(s *rlp.Stream) error {
+ var v interface{}
+ if err := s.Decode(&v); err != nil {
+ return err
+ }
+ self.Val = v
+ return nil
}
-// Assume that the data we have is encoded
-func (self *Value) Decode() {
- v, _ := Decode(self.Bytes(), 0)
- self.Val = v
- //self.Val = DecodeWithReader(bytes.NewBuffer(self.Bytes()))
+func (self *Value) EncodeRLP(w io.Writer) error {
+ if self == nil {
+ w.Write(rlp.EmptyList)
+ return nil
+ } else {
+ return rlp.Encode(w, self.Val)
+ }
}
+// NewValueFromBytes decodes RLP data.
+// The contained value will be nil if data contains invalid RLP.
func NewValueFromBytes(data []byte) *Value {
+ v := new(Value)
if len(data) != 0 {
- value := NewValue(data)
- value.Decode()
-
- return value
+ if err := rlp.DecodeBytes(data, v); err != nil {
+ v.Val = nil
+ }
}
-
- return NewValue(nil)
+ return v
}
// Value setters
diff --git a/common/value_test.go b/common/value_test.go
index 09d37802d..38a0e9843 100644
--- a/common/value_test.go
+++ b/common/value_test.go
@@ -35,7 +35,7 @@ func (s *ValueSuite) TestValueTypes(c *checker.C) {
c.Assert(str.Str(), checker.Equals, strExp)
c.Assert(num.Uint(), checker.Equals, numExp)
- c.Assert(NewValue(inter.Interface()).Cmp(NewValue(interExp)), checker.Equals, true)
+ c.Assert(NewValue(inter.Val).Cmp(NewValue(interExp)), checker.Equals, true)
c.Assert(byt.Bytes(), checker.DeepEquals, bytExp)
c.Assert(bigInt.BigInt(), checker.DeepEquals, bigExp)
}
generated by cgit (git 2.34.1) at 2024-11-12 15:00:39 +0800