mirror of https://github.com/ethereum/go-ethereum
Taylor Gerring
10 years ago
commit
1e60919d47
@ -0,0 +1,12 @@ |
||||
Jeffrey Wilcke <jeffrey@ethereum.org> |
||||
Jeffrey Wilcke <jeffrey@ethereum.org> <geffobscura@gmail.com> |
||||
Jeffrey Wilcke <jeffrey@ethereum.org> <obscuren@obscura.com> |
||||
Jeffrey Wilcke <jeffrey@ethereum.org> <obscuren@users.noreply.github.com> |
||||
|
||||
Viktor Trón <viktor.tron@gmail.com> |
||||
|
||||
Joseph Goulden <joegoulden@gmail.com> |
||||
|
||||
Nick Savers <nicksavers@gmail.com> |
||||
|
||||
Maran Hidskes <maran.hidskes@gmail.com> |
||||
@ -1,4 +1,29 @@ |
||||
before_install: sudo apt-get install libgmp3-dev |
||||
language: go |
||||
go: |
||||
- 1.3 |
||||
- tip |
||||
before_install: |
||||
- sudo add-apt-repository ppa:beineri/opt-qt54 -y |
||||
- sudo apt-get update -qq |
||||
- sudo apt-get install -yqq libgmp3-dev libreadline6-dev qt54quickcontrols qt54webengine |
||||
install: |
||||
- go get code.google.com/p/go.tools/cmd/goimports |
||||
- go get github.com/golang/lint/golint |
||||
# - go get golang.org/x/tools/cmd/vet |
||||
- if ! go get code.google.com/p/go.tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi |
||||
- go get github.com/mattn/goveralls |
||||
- go get -d github.com/obscuren/qml && cd $HOME/gopath/src/github.com/obscuren/qml && git checkout v1 && cd $TRAVIS_BUILD_DIR |
||||
- ETH_DEPS=$(go list -f '{{.Imports}} {{.TestImports}} {{.XTestImports}}' github.com/ethereum/go-ethereum/... | sed -e 's/\[//g' | sed -e 's/\]//g' | sed -e 's/C //g'); if [ "$ETH_DEPS" ]; then go get $ETH_DEPS; fi |
||||
before_script: |
||||
- gofmt -l -w . |
||||
- goimports -l -w . |
||||
- golint . |
||||
# - go vet ./... |
||||
# - go test -race ./... |
||||
script: |
||||
- ./gocoverage.sh |
||||
env: |
||||
global: |
||||
- PKG_CONFIG_PATH=/opt/qt54/lib/pkgconfig |
||||
- LD_LIBRARY_PATH=/opt/qt54/lib |
||||
- secure: "U2U1AmkU4NJBgKR/uUAebQY87cNL0+1JHjnLOmmXwxYYyj5ralWb1aSuSH3qSXiT93qLBmtaUkuv9fberHVqrbAeVlztVdUsKAq7JMQH+M99iFkC9UiRMqHmtjWJ0ok4COD1sRYixxi21wb/JrMe3M1iL4QJVS61iltjHhVdM64=" |
||||
|
||||
|
||||
@ -0,0 +1,40 @@ |
||||
FROM ubuntu:14.04 |
||||
|
||||
## Environment setup |
||||
ENV HOME /root |
||||
ENV GOPATH /root/go |
||||
ENV PATH /golang/bin:/root/go/bin:/usr/local/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games |
||||
ENV PKG_CONFIG_PATH /opt/qt54/lib/pkgconfig |
||||
|
||||
RUN mkdir -p /root/go |
||||
ENV DEBIAN_FRONTEND noninteractive |
||||
|
||||
## Install base dependencies |
||||
RUN apt-get update && apt-get upgrade -y |
||||
RUN apt-get install -y git mercurial build-essential software-properties-common pkg-config libgmp3-dev libreadline6-dev libpcre3-dev libpcre++-dev mesa-common-dev libglu1-mesa-dev |
||||
|
||||
## Install Qt5.4 dependencies from PPA |
||||
RUN add-apt-repository ppa:beineri/opt-qt54-trusty -y |
||||
RUN apt-get update -y |
||||
RUN apt-get install -y qt54quickcontrols qt54webengine |
||||
|
||||
## Build and install latest Go |
||||
RUN git clone https://go.googlesource.com/go golang |
||||
RUN cd golang && git checkout go1.4.1 |
||||
RUN cd golang/src && ./all.bash && go version |
||||
|
||||
## Fetch and install QML |
||||
RUN go get -u -v -d github.com/obscuren/qml |
||||
WORKDIR $GOPATH/src/github.com/obscuren/qml |
||||
RUN git checkout v1 |
||||
RUN go install -v |
||||
|
||||
## Fetch and install go-ethereum |
||||
RUN go get -u -v -d github.com/ethereum/go-ethereum/... |
||||
WORKDIR $GOPATH/src/github.com/ethereum/go-ethereum |
||||
RUN ETH_DEPS=$(go list -f '{{.Imports}} {{.TestImports}} {{.XTestImports}}' github.com/ethereum/go-ethereum/... | sed -e 's/\[//g' | sed -e 's/\]//g' | sed -e 's/C //g'); if [ "$ETH_DEPS" ]; then go get $ETH_DEPS; fi |
||||
RUN go install -v ./cmd/ethereum |
||||
|
||||
## Run & expose JSON RPC |
||||
ENTRYPOINT ["ethereum", "-rpc=true", "-rpcport=8080"] |
||||
EXPOSE 8080 |
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -0,0 +1,155 @@ |
||||
package abi |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
"fmt" |
||||
"io" |
||||
"strings" |
||||
|
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
) |
||||
|
||||
// Callable method given a `Name` and whether the method is a constant.
|
||||
// If the method is `Const` no transaction needs to be created for this
|
||||
// particular Method call. It can easily be simulated using a local VM.
|
||||
// For example a `Balance()` method only needs to retrieve something
|
||||
// from the storage and therefor requires no Tx to be send to the
|
||||
// network. A method such as `Transact` does require a Tx and thus will
|
||||
// be flagged `true`.
|
||||
// Input specifies the required input parameters for this gives method.
|
||||
type Method struct { |
||||
Name string |
||||
Const bool |
||||
Input []Argument |
||||
Return Type // not yet implemented
|
||||
} |
||||
|
||||
// Returns the methods string signature according to the ABI spec.
|
||||
//
|
||||
// Example
|
||||
//
|
||||
// function foo(uint32 a, int b) = "foo(uint32,int256)"
|
||||
//
|
||||
// Please note that "int" is substitute for its canonical representation "int256"
|
||||
func (m Method) String() (out string) { |
||||
out += m.Name |
||||
types := make([]string, len(m.Input)) |
||||
i := 0 |
||||
for _, input := range m.Input { |
||||
types[i] = input.Type.String() |
||||
i++ |
||||
} |
||||
out += "(" + strings.Join(types, ",") + ")" |
||||
|
||||
return |
||||
} |
||||
|
||||
func (m Method) Id() []byte { |
||||
return crypto.Sha3([]byte(m.String()))[:4] |
||||
} |
||||
|
||||
// Argument holds the name of the argument and the corresponding type.
|
||||
// Types are used when packing and testing arguments.
|
||||
type Argument struct { |
||||
Name string |
||||
Type Type |
||||
} |
||||
|
||||
func (a *Argument) UnmarshalJSON(data []byte) error { |
||||
var extarg struct { |
||||
Name string |
||||
Type string |
||||
} |
||||
err := json.Unmarshal(data, &extarg) |
||||
if err != nil { |
||||
return fmt.Errorf("argument json err: %v", err) |
||||
} |
||||
|
||||
a.Type, err = NewType(extarg.Type) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
a.Name = extarg.Name |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// The ABI holds information about a contract's context and available
|
||||
// invokable methods. It will allow you to type check function calls and
|
||||
// packs data accordingly.
|
||||
type ABI struct { |
||||
Methods map[string]Method |
||||
} |
||||
|
||||
// tests, tests whether the given input would result in a successful
|
||||
// call. Checks argument list count and matches input to `input`.
|
||||
func (abi ABI) pack(name string, args ...interface{}) ([]byte, error) { |
||||
method := abi.Methods[name] |
||||
|
||||
var ret []byte |
||||
for i, a := range args { |
||||
input := method.Input[i] |
||||
|
||||
packed, err := input.Type.pack(a) |
||||
if err != nil { |
||||
return nil, fmt.Errorf("`%s` %v", name, err) |
||||
} |
||||
ret = append(ret, packed...) |
||||
|
||||
} |
||||
|
||||
return ret, nil |
||||
} |
||||
|
||||
// Pack the given method name to conform the ABI. Method call's data
|
||||
// will consist of method_id, args0, arg1, ... argN. Method id consists
|
||||
// of 4 bytes and arguments are all 32 bytes.
|
||||
// Method ids are created from the first 4 bytes of the hash of the
|
||||
// methods string signature. (signature = baz(uint32,string32))
|
||||
func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) { |
||||
method, exist := abi.Methods[name] |
||||
if !exist { |
||||
return nil, fmt.Errorf("method '%s' not found", name) |
||||
} |
||||
|
||||
// start with argument count match
|
||||
if len(args) != len(method.Input) { |
||||
return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(method.Input)) |
||||
} |
||||
|
||||
arguments, err := abi.pack(name, args...) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
// Set function id
|
||||
packed := abi.Methods[name].Id() |
||||
packed = append(packed, arguments...) |
||||
|
||||
return packed, nil |
||||
} |
||||
|
||||
func (abi *ABI) UnmarshalJSON(data []byte) error { |
||||
var methods []Method |
||||
if err := json.Unmarshal(data, &methods); err != nil { |
||||
return err |
||||
} |
||||
|
||||
abi.Methods = make(map[string]Method) |
||||
for _, method := range methods { |
||||
abi.Methods[method.Name] = method |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func JSON(reader io.Reader) (ABI, error) { |
||||
dec := json.NewDecoder(reader) |
||||
|
||||
var abi ABI |
||||
if err := dec.Decode(&abi); err != nil { |
||||
return ABI{}, err |
||||
} |
||||
|
||||
return abi, nil |
||||
} |
||||
@ -0,0 +1,330 @@ |
||||
package abi |
||||
|
||||
import ( |
||||
"bytes" |
||||
"math/big" |
||||
"reflect" |
||||
"strings" |
||||
"testing" |
||||
|
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
) |
||||
|
||||
const jsondata = ` |
||||
[ |
||||
{ "name" : "balance", "const" : true }, |
||||
{ "name" : "send", "const" : false, "input" : [ { "name" : "amount", "type" : "uint256" } ] } |
||||
]` |
||||
|
||||
const jsondata2 = ` |
||||
[ |
||||
{ "name" : "balance", "const" : true }, |
||||
{ "name" : "send", "const" : false, "input" : [ { "name" : "amount", "type" : "uint256" } ] }, |
||||
{ "name" : "test", "const" : false, "input" : [ { "name" : "number", "type" : "uint32" } ] }, |
||||
{ "name" : "string", "const" : false, "input" : [ { "name" : "input", "type" : "string" } ] }, |
||||
{ "name" : "bool", "const" : false, "input" : [ { "name" : "input", "type" : "bool" } ] }, |
||||
{ "name" : "address", "const" : false, "input" : [ { "name" : "input", "type" : "address" } ] }, |
||||
{ "name" : "string32", "const" : false, "input" : [ { "name" : "input", "type" : "string32" } ] }, |
||||
{ "name" : "uint64[2]", "const" : false, "input" : [ { "name" : "input", "type" : "uint64[2]" } ] }, |
||||
{ "name" : "uint64[]", "const" : false, "input" : [ { "name" : "input", "type" : "uint64[]" } ] }, |
||||
{ "name" : "foo", "const" : false, "input" : [ { "name" : "input", "type" : "uint32" } ] }, |
||||
{ "name" : "bar", "const" : false, "input" : [ { "name" : "input", "type" : "uint32" }, { "name" : "string", "type" : "uint16" } ] }, |
||||
{ "name" : "slice", "const" : false, "input" : [ { "name" : "input", "type" : "uint32[2]" } ] }, |
||||
{ "name" : "slice256", "const" : false, "input" : [ { "name" : "input", "type" : "uint256[2]" } ] } |
||||
]` |
||||
|
||||
func TestType(t *testing.T) { |
||||
typ, err := NewType("uint32") |
||||
if err != nil { |
||||
t.Error(err) |
||||
} |
||||
if typ.Kind != reflect.Ptr { |
||||
t.Error("expected uint32 to have kind Ptr") |
||||
} |
||||
|
||||
typ, err = NewType("uint32[]") |
||||
if err != nil { |
||||
t.Error(err) |
||||
} |
||||
if typ.Kind != reflect.Slice { |
||||
t.Error("expected uint32[] to have type slice") |
||||
} |
||||
if typ.Type != ubig_ts { |
||||
t.Error("expcted uith32[] to have type uint64") |
||||
} |
||||
|
||||
typ, err = NewType("uint32[2]") |
||||
if err != nil { |
||||
t.Error(err) |
||||
} |
||||
if typ.Kind != reflect.Slice { |
||||
t.Error("expected uint32[2] to have kind slice") |
||||
} |
||||
if typ.Type != ubig_ts { |
||||
t.Error("expcted uith32[2] to have type uint64") |
||||
} |
||||
if typ.Size != 2 { |
||||
t.Error("expected uint32[2] to have a size of 2") |
||||
} |
||||
} |
||||
|
||||
func TestReader(t *testing.T) { |
||||
Uint256, _ := NewType("uint256") |
||||
exp := ABI{ |
||||
Methods: map[string]Method{ |
||||
"balance": Method{ |
||||
"balance", true, nil, Type{}, |
||||
}, |
||||
"send": Method{ |
||||
"send", false, []Argument{ |
||||
Argument{"amount", Uint256}, |
||||
}, Type{}, |
||||
}, |
||||
}, |
||||
} |
||||
|
||||
abi, err := JSON(strings.NewReader(jsondata)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
// deep equal fails for some reason
|
||||
t.Skip() |
||||
if !reflect.DeepEqual(abi, exp) { |
||||
t.Errorf("\nabi: %v\ndoes not match exp: %v", abi, exp) |
||||
} |
||||
} |
||||
|
||||
func TestTestNumbers(t *testing.T) { |
||||
abi, err := JSON(strings.NewReader(jsondata2)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if _, err := abi.Pack("balance"); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if _, err := abi.Pack("balance", 1); err == nil { |
||||
t.Error("expected error for balance(1)") |
||||
} |
||||
|
||||
if _, err := abi.Pack("doesntexist", nil); err == nil { |
||||
t.Errorf("doesntexist shouldn't exist") |
||||
} |
||||
|
||||
if _, err := abi.Pack("doesntexist", 1); err == nil { |
||||
t.Errorf("doesntexist(1) shouldn't exist") |
||||
} |
||||
|
||||
if _, err := abi.Pack("send", big.NewInt(1000)); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
i := new(int) |
||||
*i = 1000 |
||||
if _, err := abi.Pack("send", i); err == nil { |
||||
t.Errorf("expected send( ptr ) to throw, requires *big.Int instead of *int") |
||||
} |
||||
|
||||
if _, err := abi.Pack("send", 1000); err != nil { |
||||
t.Error("expected send(1000) to cast to big") |
||||
} |
||||
|
||||
if _, err := abi.Pack("test", uint32(1000)); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
|
||||
func TestTestString(t *testing.T) { |
||||
abi, err := JSON(strings.NewReader(jsondata2)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if _, err := abi.Pack("string", "hello world"); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
str10 := string(make([]byte, 10)) |
||||
if _, err := abi.Pack("string32", str10); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
str32 := string(make([]byte, 32)) |
||||
if _, err := abi.Pack("string32", str32); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
str33 := string(make([]byte, 33)) |
||||
if _, err := abi.Pack("string32", str33); err == nil { |
||||
t.Error("expected str33 to throw out of bound error") |
||||
} |
||||
} |
||||
|
||||
func TestTestBool(t *testing.T) { |
||||
abi, err := JSON(strings.NewReader(jsondata2)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if _, err := abi.Pack("bool", true); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
|
||||
func TestTestSlice(t *testing.T) { |
||||
abi, err := JSON(strings.NewReader(jsondata2)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
addr := make([]byte, 20) |
||||
if _, err := abi.Pack("address", addr); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
addr = make([]byte, 21) |
||||
if _, err := abi.Pack("address", addr); err == nil { |
||||
t.Error("expected address of 21 width to throw") |
||||
} |
||||
|
||||
slice := make([]byte, 2) |
||||
if _, err := abi.Pack("uint64[2]", slice); err != nil { |
||||
t.Error(err) |
||||
} |
||||
|
||||
if _, err := abi.Pack("uint64[]", slice); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
|
||||
func TestTestAddress(t *testing.T) { |
||||
abi, err := JSON(strings.NewReader(jsondata2)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
addr := make([]byte, 20) |
||||
if _, err := abi.Pack("address", addr); err != nil { |
||||
t.Error(err) |
||||
} |
||||
} |
||||
|
||||
func TestMethodSignature(t *testing.T) { |
||||
String, _ := NewType("string") |
||||
String32, _ := NewType("string32") |
||||
m := Method{"foo", false, []Argument{Argument{"bar", String32}, Argument{"baz", String}}, Type{}} |
||||
exp := "foo(string32,string)" |
||||
if m.String() != exp { |
||||
t.Error("signature mismatch", exp, "!=", m.String()) |
||||
} |
||||
|
||||
idexp := crypto.Sha3([]byte(exp))[:4] |
||||
if !bytes.Equal(m.Id(), idexp) { |
||||
t.Errorf("expected ids to match %x != %x", m.Id(), idexp) |
||||
} |
||||
|
||||
uintt, _ := NewType("uint") |
||||
m = Method{"foo", false, []Argument{Argument{"bar", uintt}}, Type{}} |
||||
exp = "foo(uint256)" |
||||
if m.String() != exp { |
||||
t.Error("signature mismatch", exp, "!=", m.String()) |
||||
} |
||||
} |
||||
|
||||
func TestPack(t *testing.T) { |
||||
abi, err := JSON(strings.NewReader(jsondata2)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
sig := crypto.Sha3([]byte("foo(uint32)"))[:4] |
||||
sig = append(sig, make([]byte, 32)...) |
||||
sig[35] = 10 |
||||
|
||||
packed, err := abi.Pack("foo", uint32(10)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if !bytes.Equal(packed, sig) { |
||||
t.Errorf("expected %x got %x", sig, packed) |
||||
} |
||||
} |
||||
|
||||
func TestMultiPack(t *testing.T) { |
||||
abi, err := JSON(strings.NewReader(jsondata2)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
sig := crypto.Sha3([]byte("bar(uint32,uint16)"))[:4] |
||||
sig = append(sig, make([]byte, 64)...) |
||||
sig[35] = 10 |
||||
sig[67] = 11 |
||||
|
||||
packed, err := abi.Pack("bar", uint32(10), uint16(11)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if !bytes.Equal(packed, sig) { |
||||
t.Errorf("expected %x got %x", sig, packed) |
||||
} |
||||
} |
||||
|
||||
func TestPackSlice(t *testing.T) { |
||||
abi, err := JSON(strings.NewReader(jsondata2)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
sig := crypto.Sha3([]byte("slice(uint32[2])"))[:4] |
||||
sig = append(sig, make([]byte, 64)...) |
||||
sig[35] = 1 |
||||
sig[67] = 2 |
||||
|
||||
packed, err := abi.Pack("slice", []uint32{1, 2}) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if !bytes.Equal(packed, sig) { |
||||
t.Errorf("expected %x got %x", sig, packed) |
||||
} |
||||
} |
||||
|
||||
func TestPackSliceBig(t *testing.T) { |
||||
abi, err := JSON(strings.NewReader(jsondata2)) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
sig := crypto.Sha3([]byte("slice256(uint256[2])"))[:4] |
||||
sig = append(sig, make([]byte, 64)...) |
||||
sig[35] = 1 |
||||
sig[67] = 2 |
||||
|
||||
packed, err := abi.Pack("slice256", []*big.Int{big.NewInt(1), big.NewInt(2)}) |
||||
if err != nil { |
||||
t.Error(err) |
||||
t.FailNow() |
||||
} |
||||
|
||||
if !bytes.Equal(packed, sig) { |
||||
t.Errorf("expected %x got %x", sig, packed) |
||||
} |
||||
} |
||||
@ -0,0 +1,10 @@ |
||||
// Package abi implements the Ethereum ABI (Application Binary
|
||||
// Interface).
|
||||
//
|
||||
// The Ethereum ABI is strongly typed, known at compile time
|
||||
// and static. This ABI will handle basic type casting; unsigned
|
||||
// to signed and visa versa. It does not handle slice casting such
|
||||
// as unsigned slice to signed slice. Bit size type casting is also
|
||||
// handled. ints with a bit size of 32 will be properly cast to int256,
|
||||
// etc.
|
||||
package abi |
||||
@ -0,0 +1,106 @@ |
||||
package abi |
||||
|
||||
import ( |
||||
"math/big" |
||||
"reflect" |
||||
|
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
) |
||||
|
||||
var big_t = reflect.TypeOf(&big.Int{}) |
||||
var ubig_t = reflect.TypeOf(&big.Int{}) |
||||
var byte_t = reflect.TypeOf(byte(0)) |
||||
var byte_ts = reflect.TypeOf([]byte(nil)) |
||||
var uint_t = reflect.TypeOf(uint(0)) |
||||
var uint8_t = reflect.TypeOf(uint8(0)) |
||||
var uint16_t = reflect.TypeOf(uint16(0)) |
||||
var uint32_t = reflect.TypeOf(uint32(0)) |
||||
var uint64_t = reflect.TypeOf(uint64(0)) |
||||
var int_t = reflect.TypeOf(int(0)) |
||||
var int8_t = reflect.TypeOf(int8(0)) |
||||
var int16_t = reflect.TypeOf(int16(0)) |
||||
var int32_t = reflect.TypeOf(int32(0)) |
||||
var int64_t = reflect.TypeOf(int64(0)) |
||||
|
||||
var uint_ts = reflect.TypeOf([]uint(nil)) |
||||
var uint8_ts = reflect.TypeOf([]uint8(nil)) |
||||
var uint16_ts = reflect.TypeOf([]uint16(nil)) |
||||
var uint32_ts = reflect.TypeOf([]uint32(nil)) |
||||
var uint64_ts = reflect.TypeOf([]uint64(nil)) |
||||
var ubig_ts = reflect.TypeOf([]*big.Int(nil)) |
||||
|
||||
var int_ts = reflect.TypeOf([]int(nil)) |
||||
var int8_ts = reflect.TypeOf([]int8(nil)) |
||||
var int16_ts = reflect.TypeOf([]int16(nil)) |
||||
var int32_ts = reflect.TypeOf([]int32(nil)) |
||||
var int64_ts = reflect.TypeOf([]int64(nil)) |
||||
var big_ts = reflect.TypeOf([]*big.Int(nil)) |
||||
|
||||
// U256 will ensure unsigned 256bit on big nums
|
||||
func U256(n *big.Int) []byte { |
||||
return ethutil.LeftPadBytes(ethutil.U256(n).Bytes(), 32) |
||||
} |
||||
|
||||
func S256(n *big.Int) []byte { |
||||
sint := ethutil.S256(n) |
||||
ret := ethutil.LeftPadBytes(sint.Bytes(), 32) |
||||
if sint.Cmp(ethutil.Big0) < 0 { |
||||
for i, b := range ret { |
||||
if b == 0 { |
||||
ret[i] = 1 |
||||
continue |
||||
} |
||||
break |
||||
} |
||||
} |
||||
|
||||
return ret |
||||
} |
||||
|
||||
// S256 will ensure signed 256bit on big nums
|
||||
func U2U256(n uint64) []byte { |
||||
return U256(big.NewInt(int64(n))) |
||||
} |
||||
|
||||
func S2S256(n int64) []byte { |
||||
return S256(big.NewInt(n)) |
||||
} |
||||
|
||||
// packNum packs the given number (using the reflect value) and will cast it to appropriate number representation
|
||||
func packNum(value reflect.Value, to byte) []byte { |
||||
switch kind := value.Kind(); kind { |
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: |
||||
if to == UintTy { |
||||
return U2U256(value.Uint()) |
||||
} else { |
||||
return S2S256(int64(value.Uint())) |
||||
} |
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
||||
if to == UintTy { |
||||
return U2U256(uint64(value.Int())) |
||||
} else { |
||||
return S2S256(value.Int()) |
||||
} |
||||
case reflect.Ptr: |
||||
// This only takes care of packing and casting. No type checking is done here. It should be done prior to using this function.
|
||||
if to == UintTy { |
||||
return U256(value.Interface().(*big.Int)) |
||||
} else { |
||||
return S256(value.Interface().(*big.Int)) |
||||
} |
||||
|
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// checks whether the given reflect value is signed. This also works for slices with a number type
|
||||
func isSigned(v reflect.Value) bool { |
||||
switch v.Type() { |
||||
case ubig_ts, big_ts, big_t, ubig_t: |
||||
return true |
||||
case int_ts, int8_ts, int16_ts, int32_ts, int64_ts, int_t, int8_t, int16_t, int32_t, int64_t: |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
@ -0,0 +1,72 @@ |
||||
package abi |
||||
|
||||
import ( |
||||
"bytes" |
||||
"math/big" |
||||
"reflect" |
||||
"testing" |
||||
) |
||||
|
||||
func TestNumberTypes(t *testing.T) { |
||||
ubytes := make([]byte, 32) |
||||
ubytes[31] = 1 |
||||
sbytesmin := []byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1} |
||||
|
||||
unsigned := U256(big.NewInt(1)) |
||||
if !bytes.Equal(unsigned, ubytes) { |
||||
t.Error("expected %x got %x", ubytes, unsigned) |
||||
} |
||||
|
||||
signed := S256(big.NewInt(1)) |
||||
if !bytes.Equal(signed, ubytes) { |
||||
t.Error("expected %x got %x", ubytes, unsigned) |
||||
} |
||||
|
||||
signed = S256(big.NewInt(-1)) |
||||
if !bytes.Equal(signed, sbytesmin) { |
||||
t.Error("expected %x got %x", ubytes, unsigned) |
||||
} |
||||
} |
||||
|
||||
func TestPackNumber(t *testing.T) { |
||||
ubytes := make([]byte, 32) |
||||
ubytes[31] = 1 |
||||
sbytesmin := []byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1} |
||||
maxunsigned := []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255} |
||||
|
||||
packed := packNum(reflect.ValueOf(1), IntTy) |
||||
if !bytes.Equal(packed, ubytes) { |
||||
t.Errorf("expected %x got %x", ubytes, packed) |
||||
} |
||||
packed = packNum(reflect.ValueOf(-1), IntTy) |
||||
if !bytes.Equal(packed, sbytesmin) { |
||||
t.Errorf("expected %x got %x", ubytes, packed) |
||||
} |
||||
packed = packNum(reflect.ValueOf(1), UintTy) |
||||
if !bytes.Equal(packed, ubytes) { |
||||
t.Errorf("expected %x got %x", ubytes, packed) |
||||
} |
||||
packed = packNum(reflect.ValueOf(-1), UintTy) |
||||
if !bytes.Equal(packed, maxunsigned) { |
||||
t.Errorf("expected %x got %x", maxunsigned, packed) |
||||
} |
||||
|
||||
packed = packNum(reflect.ValueOf("string"), UintTy) |
||||
if packed != nil { |
||||
t.Errorf("expected 'string' to pack to nil. got %x instead", packed) |
||||
} |
||||
} |
||||
|
||||
func TestSigned(t *testing.T) { |
||||
if isSigned(reflect.ValueOf(uint(10))) { |
||||
t.Error() |
||||
} |
||||
|
||||
if !isSigned(reflect.ValueOf(int(10))) { |
||||
t.Error() |
||||
} |
||||
|
||||
if !isSigned(reflect.ValueOf(big.NewInt(10))) { |
||||
t.Error() |
||||
} |
||||
} |
||||
@ -0,0 +1,106 @@ |
||||
mode: set |
||||
github.com/ethereum/go-ethereum/abi/abi.go:27.39,31.32 4 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:35.2,37.8 2 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:31.32,34.3 2 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:40.29,42.2 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:51.53,57.16 3 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:61.2,62.16 2 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:65.2,67.12 2 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:57.16,59.3 1 0 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:62.16,64.3 1 0 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:79.71,83.25 3 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:94.2,94.17 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:83.25,87.17 3 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:90.3,90.31 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:87.17,89.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:102.71,104.12 2 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:109.2,109.36 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:113.2,114.16 2 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:119.2,122.20 3 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:104.12,106.3 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:109.36,111.3 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:114.16,116.3 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:125.50,127.55 2 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:131.2,132.33 2 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:136.2,136.12 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:127.55,129.3 1 0 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:132.33,134.3 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:139.42,143.41 3 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:147.2,147.17 1 1 |
||||
github.com/ethereum/go-ethereum/abi/abi.go:143.41,145.3 1 0 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:39.30,41.2 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:43.30,46.32 3 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:56.2,56.12 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:46.32,47.25 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:47.25,48.14 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:52.4,52.9 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:48.14,50.13 2 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:59.30,61.2 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:63.29,65.2 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:67.51,68.36 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:91.2,91.12 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:69.2,70.19 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:75.2,76.19 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:81.2,83.19 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:70.19,72.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:72.4,74.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:76.19,78.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:78.4,80.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:83.19,85.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:85.4,87.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:94.37,95.18 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:101.2,101.14 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:96.2,97.14 1 1 |
||||
github.com/ethereum/go-ethereum/abi/numbers.go:98.2,99.14 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:32.46,35.16 2 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:38.2,43.9 3 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:55.2,56.16 2 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:60.2,64.55 4 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:69.2,69.13 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:111.2,113.8 2 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:35.16,37.3 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:44.2,47.17 2 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:48.2,50.12 2 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:51.2,52.60 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:56.16,58.3 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:64.55,67.3 2 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:69.13,72.16 3 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:73.3,74.21 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:75.3,76.22 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:77.3,78.66 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:80.3,81.16 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:82.3,86.17 4 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:87.3,91.18 4 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:92.3,93.27 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:94.3,95.30 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:96.3,100.21 4 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:101.3,104.17 3 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:107.3,108.60 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:104.17,106.5 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:116.37,118.2 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:126.51,128.36 2 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:179.2,179.20 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:129.2,130.23 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:133.3,133.34 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:134.2,135.23 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:138.3,138.34 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:139.2,142.49 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:145.3,145.34 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:146.2,147.42 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:150.3,150.60 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:151.2,152.42 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:157.3,157.23 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:162.3,162.78 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:166.3,167.36 2 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:170.3,170.21 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:171.2,172.19 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:130.23,132.4 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:135.23,137.4 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:142.49,144.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:147.42,149.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:152.42,154.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:157.23,159.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:162.78,164.4 1 0 |
||||
github.com/ethereum/go-ethereum/abi/type.go:167.36,169.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:172.19,174.4 1 1 |
||||
github.com/ethereum/go-ethereum/abi/type.go:174.4,176.4 1 0 |
||||
@ -0,0 +1,190 @@ |
||||
package abi |
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"regexp" |
||||
"strconv" |
||||
|
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
) |
||||
|
||||
const ( |
||||
IntTy byte = iota |
||||
UintTy |
||||
BoolTy |
||||
SliceTy |
||||
AddressTy |
||||
RealTy |
||||
) |
||||
|
||||
// Type is the reflection of the supported argument type
|
||||
type Type struct { |
||||
Kind reflect.Kind |
||||
Type reflect.Type |
||||
Size int |
||||
T byte // Our own type checking
|
||||
stringKind string // holds the unparsed string for deriving signatures
|
||||
} |
||||
|
||||
// New type returns a fully parsed Type given by the input string or an error if it can't be parsed.
|
||||
//
|
||||
// Strings can be in the format of:
|
||||
//
|
||||
// Input = Type [ "[" [ Number ] "]" ] Name .
|
||||
// Type = [ "u" ] "int" [ Number ] .
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// string int uint real
|
||||
// string32 int8 uint8 uint[]
|
||||
// address int256 uint256 real[2]
|
||||
func NewType(t string) (typ Type, err error) { |
||||
// 1. full string 2. type 3. (opt.) is slice 4. (opt.) size
|
||||
freg, err := regexp.Compile("([a-zA-Z0-9]+)(\\[([0-9]*)?\\])?") |
||||
if err != nil { |
||||
return Type{}, err |
||||
} |
||||
res := freg.FindAllStringSubmatch(t, -1)[0] |
||||
var ( |
||||
isslice bool |
||||
size int |
||||
) |
||||
switch { |
||||
case res[3] != "": |
||||
// err is ignored. Already checked for number through the regexp
|
||||
size, _ = strconv.Atoi(res[3]) |
||||
isslice = true |
||||
case res[2] != "": |
||||
isslice = true |
||||
size = -1 |
||||
case res[0] == "": |
||||
return Type{}, fmt.Errorf("type parse error for `%s`", t) |
||||
} |
||||
|
||||
treg, err := regexp.Compile("([a-zA-Z]+)([0-9]*)?") |
||||
if err != nil { |
||||
return Type{}, err |
||||
} |
||||
|
||||
parsedType := treg.FindAllStringSubmatch(res[1], -1)[0] |
||||
vsize, _ := strconv.Atoi(parsedType[2]) |
||||
vtype := parsedType[1] |
||||
// substitute canonical representation
|
||||
if vsize == 0 && (vtype == "int" || vtype == "uint") { |
||||
vsize = 256 |
||||
t += "256" |
||||
} |
||||
|
||||
if isslice { |
||||
typ.Kind = reflect.Slice |
||||
typ.Size = size |
||||
switch vtype { |
||||
case "int": |
||||
typ.Type = big_ts |
||||
case "uint": |
||||
typ.Type = ubig_ts |
||||
default: |
||||
return Type{}, fmt.Errorf("unsupported arg slice type: %s", t) |
||||
} |
||||
} else { |
||||
switch vtype { |
||||
case "int": |
||||
typ.Kind = reflect.Ptr |
||||
typ.Type = big_t |
||||
typ.Size = 256 |
||||
typ.T = IntTy |
||||
case "uint": |
||||
typ.Kind = reflect.Ptr |
||||
typ.Type = ubig_t |
||||
typ.Size = 256 |
||||
typ.T = UintTy |
||||
case "bool": |
||||
typ.Kind = reflect.Bool |
||||
case "real": // TODO
|
||||
typ.Kind = reflect.Invalid |
||||
case "address": |
||||
typ.Kind = reflect.Slice |
||||
typ.Type = byte_ts |
||||
typ.Size = 20 |
||||
typ.T = AddressTy |
||||
case "string": |
||||
typ.Kind = reflect.String |
||||
typ.Size = -1 |
||||
if vsize > 0 { |
||||
typ.Size = 32 |
||||
} |
||||
default: |
||||
return Type{}, fmt.Errorf("unsupported arg type: %s", t) |
||||
} |
||||
} |
||||
typ.stringKind = t |
||||
|
||||
return |
||||
} |
||||
|
||||
func (t Type) String() (out string) { |
||||
return t.stringKind |
||||
} |
||||
|
||||
// Test the given input parameter `v` and checks if it matches certain
|
||||
// criteria
|
||||
// * Big integers are checks for ptr types and if the given value is
|
||||
// assignable
|
||||
// * Integer are checked for size
|
||||
// * Strings, addresses and bytes are checks for type and size
|
||||
func (t Type) pack(v interface{}) ([]byte, error) { |
||||
value := reflect.ValueOf(v) |
||||
switch kind := value.Kind(); kind { |
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: |
||||
if t.Type != ubig_t { |
||||
return nil, fmt.Errorf("type mismatch: %s for %T", t.Type, v) |
||||
} |
||||
return packNum(value, t.T), nil |
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
||||
if t.Type != ubig_t { |
||||
return nil, fmt.Errorf("type mismatch: %s for %T", t.Type, v) |
||||
} |
||||
return packNum(value, t.T), nil |
||||
case reflect.Ptr: |
||||
// If the value is a ptr do a assign check (only used by
|
||||
// big.Int for now)
|
||||
if t.Type == ubig_t && value.Type() != ubig_t { |
||||
return nil, fmt.Errorf("type mismatch: %s for %T", t.Type, v) |
||||
} |
||||
return packNum(value, t.T), nil |
||||
case reflect.String: |
||||
if t.Size > -1 && value.Len() > t.Size { |
||||
return nil, fmt.Errorf("%v out of bound. %d for %d", value.Kind(), value.Len(), t.Size) |
||||
} |
||||
return []byte(ethutil.LeftPadString(t.String(), 32)), nil |
||||
case reflect.Slice: |
||||
if t.Size > -1 && value.Len() > t.Size { |
||||
return nil, fmt.Errorf("%v out of bound. %d for %d", value.Kind(), value.Len(), t.Size) |
||||
} |
||||
|
||||
// Address is a special slice. The slice acts as one rather than a list of elements.
|
||||
if t.T == AddressTy { |
||||
return ethutil.LeftPadBytes(v.([]byte), 32), nil |
||||
} |
||||
|
||||
// Signed / Unsigned check
|
||||
if (t.T != IntTy && isSigned(value)) || (t.T == UintTy && isSigned(value)) { |
||||
return nil, fmt.Errorf("slice of incompatible types.") |
||||
} |
||||
|
||||
var packed []byte |
||||
for i := 0; i < value.Len(); i++ { |
||||
packed = append(packed, packNum(value.Index(i), t.T)...) |
||||
} |
||||
return packed, nil |
||||
case reflect.Bool: |
||||
if value.Bool() { |
||||
return ethutil.LeftPadBytes(ethutil.Big1.Bytes(), 32), nil |
||||
} else { |
||||
return ethutil.LeftPadBytes(ethutil.Big0.Bytes(), 32), nil |
||||
} |
||||
} |
||||
|
||||
panic("unreached") |
||||
} |
||||
@ -0,0 +1,95 @@ |
||||
/* |
||||
This file is part of go-ethereum |
||||
|
||||
go-ethereum 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. |
||||
|
||||
go-ethereum 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 General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU Lesser General Public License |
||||
along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
/** |
||||
* @authors |
||||
* Gustav Simonsson <gustav.simonsson@gmail.com> |
||||
* @date 2015 |
||||
* |
||||
*/ |
||||
/* |
||||
|
||||
This abstracts part of a user's interaction with an account she controls. |
||||
It's not an abstraction of core Ethereum accounts data type / logic - |
||||
for that see the core processing code of blocks / txs. |
||||
|
||||
Currently this is pretty much a passthrough to the KeyStore2 interface, |
||||
and accounts persistence is derived from stored keys' addresses |
||||
|
||||
*/ |
||||
package accounts |
||||
|
||||
import ( |
||||
crand "crypto/rand" |
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
) |
||||
|
||||
// TODO: better name for this struct?
|
||||
type Account struct { |
||||
Address []byte |
||||
} |
||||
|
||||
type AccountManager struct { |
||||
keyStore crypto.KeyStore2 |
||||
} |
||||
|
||||
// TODO: get key by addr - modify KeyStore2 GetKey to work with addr
|
||||
|
||||
// TODO: pass through passphrase for APIs which require access to private key?
|
||||
func NewAccountManager(keyStore crypto.KeyStore2) AccountManager { |
||||
am := &AccountManager{ |
||||
keyStore: keyStore, |
||||
} |
||||
return *am |
||||
} |
||||
|
||||
func (am *AccountManager) Sign(fromAccount *Account, keyAuth string, toSign []byte) (signature []byte, err error) { |
||||
key, err := am.keyStore.GetKey(fromAccount.Address, keyAuth) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
signature, err = crypto.Sign(toSign, key.PrivateKey) |
||||
return signature, err |
||||
} |
||||
|
||||
func (am AccountManager) NewAccount(auth string) (*Account, error) { |
||||
key, err := am.keyStore.GenerateNewKey(crand.Reader, auth) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
ua := &Account{ |
||||
Address: key.Address, |
||||
} |
||||
return ua, err |
||||
} |
||||
|
||||
// set of accounts == set of keys in given key store
|
||||
// TODO: do we need persistence of accounts as well?
|
||||
func (am *AccountManager) Accounts() ([]Account, error) { |
||||
addresses, err := am.keyStore.GetKeyAddresses() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
accounts := make([]Account, len(addresses)) |
||||
|
||||
for i, addr := range addresses { |
||||
accounts[i] = Account{ |
||||
Address: addr, |
||||
} |
||||
} |
||||
return accounts, err |
||||
} |
||||
@ -0,0 +1,18 @@ |
||||
package accounts |
||||
|
||||
import ( |
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
"testing" |
||||
) |
||||
|
||||
func TestAccountManager(t *testing.T) { |
||||
ks := crypto.NewKeyStorePlain(crypto.DefaultDataDir()) |
||||
am := NewAccountManager(ks) |
||||
pass := "" // not used but required by API
|
||||
a1, err := am.NewAccount(pass) |
||||
toSign := crypto.GetEntropyCSPRNG(32) |
||||
_, err = am.Sign(a1, pass, toSign) |
||||
if err != nil { |
||||
t.Fatal(err) |
||||
} |
||||
} |
||||
@ -1,344 +0,0 @@ |
||||
package eth |
||||
|
||||
import ( |
||||
"bytes" |
||||
"container/list" |
||||
"fmt" |
||||
"math" |
||||
"math/big" |
||||
"sync" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/chain" |
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
"github.com/ethereum/go-ethereum/logger" |
||||
"github.com/ethereum/go-ethereum/wire" |
||||
) |
||||
|
||||
var poollogger = logger.NewLogger("BPOOL") |
||||
|
||||
type block struct { |
||||
from *Peer |
||||
peer *Peer |
||||
block *chain.Block |
||||
reqAt time.Time |
||||
requested int |
||||
} |
||||
|
||||
type BlockPool struct { |
||||
mut sync.Mutex |
||||
|
||||
eth *Ethereum |
||||
|
||||
hashes [][]byte |
||||
pool map[string]*block |
||||
|
||||
td *big.Int |
||||
quit chan bool |
||||
|
||||
fetchingHashes bool |
||||
downloadStartedAt time.Time |
||||
|
||||
ChainLength, BlocksProcessed int |
||||
|
||||
peer *Peer |
||||
} |
||||
|
||||
func NewBlockPool(eth *Ethereum) *BlockPool { |
||||
return &BlockPool{ |
||||
eth: eth, |
||||
pool: make(map[string]*block), |
||||
td: ethutil.Big0, |
||||
quit: make(chan bool), |
||||
} |
||||
} |
||||
|
||||
func (self *BlockPool) Len() int { |
||||
return len(self.hashes) |
||||
} |
||||
|
||||
func (self *BlockPool) Reset() { |
||||
self.pool = make(map[string]*block) |
||||
self.hashes = nil |
||||
} |
||||
|
||||
func (self *BlockPool) HasLatestHash() bool { |
||||
self.mut.Lock() |
||||
defer self.mut.Unlock() |
||||
|
||||
return self.pool[string(self.eth.ChainManager().CurrentBlock.Hash())] != nil |
||||
} |
||||
|
||||
func (self *BlockPool) HasCommonHash(hash []byte) bool { |
||||
return self.eth.ChainManager().GetBlock(hash) != nil |
||||
} |
||||
|
||||
func (self *BlockPool) Blocks() (blocks chain.Blocks) { |
||||
for _, item := range self.pool { |
||||
if item.block != nil { |
||||
blocks = append(blocks, item.block) |
||||
} |
||||
} |
||||
|
||||
return |
||||
} |
||||
|
||||
func (self *BlockPool) FetchHashes(peer *Peer) bool { |
||||
highestTd := self.eth.HighestTDPeer() |
||||
|
||||
if (self.peer == nil && peer.td.Cmp(highestTd) >= 0) || (self.peer != nil && peer.td.Cmp(self.peer.td) > 0) || self.peer == peer { |
||||
if self.peer != peer { |
||||
poollogger.Debugf("Found better suitable peer (%v vs %v)\n", self.td, peer.td) |
||||
|
||||
if self.peer != nil { |
||||
self.peer.doneFetchingHashes = true |
||||
} |
||||
} |
||||
|
||||
self.peer = peer |
||||
self.td = peer.td |
||||
|
||||
if !self.HasLatestHash() { |
||||
peer.doneFetchingHashes = false |
||||
|
||||
const amount = 256 |
||||
peerlogger.Debugf("Fetching hashes (%d) %x...\n", amount, peer.lastReceivedHash[0:4]) |
||||
peer.QueueMessage(wire.NewMessage(wire.MsgGetBlockHashesTy, []interface{}{peer.lastReceivedHash, uint32(amount)})) |
||||
} |
||||
|
||||
return true |
||||
} |
||||
|
||||
return false |
||||
} |
||||
|
||||
func (self *BlockPool) AddHash(hash []byte, peer *Peer) { |
||||
self.mut.Lock() |
||||
defer self.mut.Unlock() |
||||
|
||||
if self.pool[string(hash)] == nil { |
||||
self.pool[string(hash)] = &block{peer, nil, nil, time.Now(), 0} |
||||
|
||||
self.hashes = append([][]byte{hash}, self.hashes...) |
||||
} |
||||
} |
||||
|
||||
func (self *BlockPool) Add(b *chain.Block, peer *Peer) { |
||||
self.addBlock(b, peer, false) |
||||
} |
||||
|
||||
func (self *BlockPool) AddNew(b *chain.Block, peer *Peer) { |
||||
self.addBlock(b, peer, true) |
||||
} |
||||
|
||||
func (self *BlockPool) addBlock(b *chain.Block, peer *Peer, newBlock bool) { |
||||
self.mut.Lock() |
||||
defer self.mut.Unlock() |
||||
|
||||
hash := string(b.Hash()) |
||||
|
||||
if self.pool[hash] == nil && !self.eth.ChainManager().HasBlock(b.Hash()) { |
||||
poollogger.Infof("Got unrequested block (%x...)\n", hash[0:4]) |
||||
|
||||
self.hashes = append(self.hashes, b.Hash()) |
||||
self.pool[hash] = &block{peer, peer, b, time.Now(), 0} |
||||
|
||||
// The following is only performed on an unrequested new block
|
||||
if newBlock { |
||||
fmt.Println("1.", !self.eth.ChainManager().HasBlock(b.PrevHash), ethutil.Bytes2Hex(b.Hash()[0:4]), ethutil.Bytes2Hex(b.PrevHash[0:4])) |
||||
fmt.Println("2.", self.pool[string(b.PrevHash)] == nil) |
||||
fmt.Println("3.", !self.fetchingHashes) |
||||
if !self.eth.ChainManager().HasBlock(b.PrevHash) && self.pool[string(b.PrevHash)] == nil && !self.fetchingHashes { |
||||
poollogger.Infof("Unknown chain, requesting (%x...)\n", b.PrevHash[0:4]) |
||||
peer.QueueMessage(wire.NewMessage(wire.MsgGetBlockHashesTy, []interface{}{b.Hash(), uint32(256)})) |
||||
} |
||||
} |
||||
} else if self.pool[hash] != nil { |
||||
self.pool[hash].block = b |
||||
} |
||||
|
||||
self.BlocksProcessed++ |
||||
} |
||||
|
||||
func (self *BlockPool) Remove(hash []byte) { |
||||
self.mut.Lock() |
||||
defer self.mut.Unlock() |
||||
|
||||
self.hashes = ethutil.DeleteFromByteSlice(self.hashes, hash) |
||||
delete(self.pool, string(hash)) |
||||
} |
||||
|
||||
func (self *BlockPool) DistributeHashes() { |
||||
self.mut.Lock() |
||||
defer self.mut.Unlock() |
||||
|
||||
var ( |
||||
peerLen = self.eth.peers.Len() |
||||
amount = 256 * peerLen |
||||
dist = make(map[*Peer][][]byte) |
||||
) |
||||
|
||||
num := int(math.Min(float64(amount), float64(len(self.pool)))) |
||||
for i, j := 0, 0; i < len(self.hashes) && j < num; i++ { |
||||
hash := self.hashes[i] |
||||
item := self.pool[string(hash)] |
||||
|
||||
if item != nil && item.block == nil { |
||||
var peer *Peer |
||||
lastFetchFailed := time.Since(item.reqAt) > 5*time.Second |
||||
|
||||
// Handle failed requests
|
||||
if lastFetchFailed && item.requested > 5 && item.peer != nil { |
||||
if item.requested < 100 { |
||||
// Select peer the hash was retrieved off
|
||||
peer = item.from |
||||
} else { |
||||
// Remove it
|
||||
self.hashes = ethutil.DeleteFromByteSlice(self.hashes, hash) |
||||
delete(self.pool, string(hash)) |
||||
} |
||||
} else if lastFetchFailed || item.peer == nil { |
||||
// Find a suitable, available peer
|
||||
eachPeer(self.eth.peers, func(p *Peer, v *list.Element) { |
||||
if peer == nil && len(dist[p]) < amount/peerLen { |
||||
peer = p |
||||
} |
||||
}) |
||||
} |
||||
|
||||
if peer != nil { |
||||
item.reqAt = time.Now() |
||||
item.peer = peer |
||||
item.requested++ |
||||
|
||||
dist[peer] = append(dist[peer], hash) |
||||
} |
||||
} |
||||
} |
||||
|
||||
for peer, hashes := range dist { |
||||
peer.FetchBlocks(hashes) |
||||
} |
||||
|
||||
if len(dist) > 0 { |
||||
self.downloadStartedAt = time.Now() |
||||
} |
||||
} |
||||
|
||||
func (self *BlockPool) Start() { |
||||
go self.downloadThread() |
||||
go self.chainThread() |
||||
} |
||||
|
||||
func (self *BlockPool) Stop() { |
||||
close(self.quit) |
||||
} |
||||
|
||||
func (self *BlockPool) downloadThread() { |
||||
serviceTimer := time.NewTicker(100 * time.Millisecond) |
||||
out: |
||||
for { |
||||
select { |
||||
case <-self.quit: |
||||
break out |
||||
case <-serviceTimer.C: |
||||
// Check if we're catching up. If not distribute the hashes to
|
||||
// the peers and download the blockchain
|
||||
self.fetchingHashes = false |
||||
eachPeer(self.eth.peers, func(p *Peer, v *list.Element) { |
||||
if p.statusKnown && p.FetchingHashes() { |
||||
self.fetchingHashes = true |
||||
} |
||||
}) |
||||
|
||||
if len(self.hashes) > 0 { |
||||
self.DistributeHashes() |
||||
} |
||||
|
||||
if self.ChainLength < len(self.hashes) { |
||||
self.ChainLength = len(self.hashes) |
||||
} |
||||
|
||||
/* |
||||
if !self.fetchingHashes { |
||||
blocks := self.Blocks() |
||||
chain.BlockBy(chain.Number).Sort(blocks) |
||||
|
||||
if len(blocks) > 0 { |
||||
if !self.eth.ChainManager().HasBlock(b.PrevHash) && self.pool[string(b.PrevHash)] == nil && !self.fetchingHashes { |
||||
} |
||||
} |
||||
} |
||||
*/ |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (self *BlockPool) chainThread() { |
||||
procTimer := time.NewTicker(500 * time.Millisecond) |
||||
out: |
||||
for { |
||||
select { |
||||
case <-self.quit: |
||||
break out |
||||
case <-procTimer.C: |
||||
blocks := self.Blocks() |
||||
chain.BlockBy(chain.Number).Sort(blocks) |
||||
|
||||
// Find common block
|
||||
for i, block := range blocks { |
||||
if self.eth.ChainManager().HasBlock(block.PrevHash) { |
||||
blocks = blocks[i:] |
||||
break |
||||
} |
||||
} |
||||
|
||||
if len(blocks) > 0 { |
||||
if self.eth.ChainManager().HasBlock(blocks[0].PrevHash) { |
||||
for i, block := range blocks[1:] { |
||||
// NOTE: The Ith element in this loop refers to the previous block in
|
||||
// outer "blocks"
|
||||
if bytes.Compare(block.PrevHash, blocks[i].Hash()) != 0 { |
||||
blocks = blocks[:i] |
||||
|
||||
break |
||||
} |
||||
} |
||||
} else { |
||||
blocks = nil |
||||
} |
||||
} |
||||
|
||||
// TODO figure out whether we were catching up
|
||||
// If caught up and just a new block has been propagated:
|
||||
// sm.eth.EventMux().Post(NewBlockEvent{block})
|
||||
// otherwise process and don't emit anything
|
||||
var err error |
||||
for i, block := range blocks { |
||||
err = self.eth.BlockManager().Process(block) |
||||
if err != nil { |
||||
poollogger.Infoln(err) |
||||
poollogger.Debugf("Block #%v failed (%x...)\n", block.Number, block.Hash()[0:4]) |
||||
poollogger.Debugln(block) |
||||
|
||||
blocks = blocks[i:] |
||||
|
||||
break |
||||
} |
||||
|
||||
self.Remove(block.Hash()) |
||||
} |
||||
|
||||
if err != nil { |
||||
self.Reset() |
||||
|
||||
poollogger.Debugf("Punishing peer for supplying bad chain (%v)\n", self.peer.conn.RemoteAddr()) |
||||
// This peer gave us bad hashes and made us fetch a bad chain, therefor he shall be punished.
|
||||
self.eth.BlacklistPeer(self.peer) |
||||
self.peer.StopWithReason(DiscBadPeer) |
||||
self.td = ethutil.Big0 |
||||
self.peer = nil |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -1,419 +0,0 @@ |
||||
package chain |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"math/big" |
||||
"sort" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
"github.com/ethereum/go-ethereum/state" |
||||
"github.com/ethereum/go-ethereum/trie" |
||||
) |
||||
|
||||
type BlockInfo struct { |
||||
Number uint64 |
||||
Hash []byte |
||||
Parent []byte |
||||
TD *big.Int |
||||
} |
||||
|
||||
func (bi *BlockInfo) RlpDecode(data []byte) { |
||||
decoder := ethutil.NewValueFromBytes(data) |
||||
|
||||
bi.Number = decoder.Get(0).Uint() |
||||
bi.Hash = decoder.Get(1).Bytes() |
||||
bi.Parent = decoder.Get(2).Bytes() |
||||
bi.TD = decoder.Get(3).BigInt() |
||||
} |
||||
|
||||
func (bi *BlockInfo) RlpEncode() []byte { |
||||
return ethutil.Encode([]interface{}{bi.Number, bi.Hash, bi.Parent, bi.TD}) |
||||
} |
||||
|
||||
type Blocks []*Block |
||||
|
||||
func (self Blocks) AsSet() ethutil.UniqueSet { |
||||
set := make(ethutil.UniqueSet) |
||||
for _, block := range self { |
||||
set.Insert(block.Hash()) |
||||
} |
||||
|
||||
return set |
||||
} |
||||
|
||||
type BlockBy func(b1, b2 *Block) bool |
||||
|
||||
func (self BlockBy) Sort(blocks Blocks) { |
||||
bs := blockSorter{ |
||||
blocks: blocks, |
||||
by: self, |
||||
} |
||||
sort.Sort(bs) |
||||
} |
||||
|
||||
type blockSorter struct { |
||||
blocks Blocks |
||||
by func(b1, b2 *Block) bool |
||||
} |
||||
|
||||
func (self blockSorter) Len() int { return len(self.blocks) } |
||||
func (self blockSorter) Swap(i, j int) { |
||||
self.blocks[i], self.blocks[j] = self.blocks[j], self.blocks[i] |
||||
} |
||||
func (self blockSorter) Less(i, j int) bool { return self.by(self.blocks[i], self.blocks[j]) } |
||||
|
||||
func Number(b1, b2 *Block) bool { return b1.Number.Cmp(b2.Number) < 0 } |
||||
|
||||
type Block struct { |
||||
// Hash to the previous block
|
||||
PrevHash ethutil.Bytes |
||||
// Uncles of this block
|
||||
Uncles Blocks |
||||
UncleSha []byte |
||||
// The coin base address
|
||||
Coinbase []byte |
||||
// Block Trie state
|
||||
//state *ethutil.Trie
|
||||
state *state.State |
||||
// Difficulty for the current block
|
||||
Difficulty *big.Int |
||||
// Creation time
|
||||
Time int64 |
||||
// The block number
|
||||
Number *big.Int |
||||
// Minimum Gas Price
|
||||
MinGasPrice *big.Int |
||||
// Gas limit
|
||||
GasLimit *big.Int |
||||
// Gas used
|
||||
GasUsed *big.Int |
||||
// Extra data
|
||||
Extra string |
||||
// Block Nonce for verification
|
||||
Nonce ethutil.Bytes |
||||
// List of transactions and/or contracts
|
||||
transactions Transactions |
||||
receipts Receipts |
||||
TxSha, ReceiptSha []byte |
||||
LogsBloom []byte |
||||
} |
||||
|
||||
func NewBlockFromBytes(raw []byte) *Block { |
||||
block := &Block{} |
||||
block.RlpDecode(raw) |
||||
|
||||
return block |
||||
} |
||||
|
||||
// New block takes a raw encoded string
|
||||
func NewBlockFromRlpValue(rlpValue *ethutil.Value) *Block { |
||||
block := &Block{} |
||||
block.RlpValueDecode(rlpValue) |
||||
|
||||
return block |
||||
} |
||||
|
||||
func CreateBlock(root interface{}, |
||||
prevHash []byte, |
||||
base []byte, |
||||
Difficulty *big.Int, |
||||
Nonce []byte, |
||||
extra string) *Block { |
||||
|
||||
block := &Block{ |
||||
PrevHash: prevHash, |
||||
Coinbase: base, |
||||
Difficulty: Difficulty, |
||||
Nonce: Nonce, |
||||
Time: time.Now().Unix(), |
||||
Extra: extra, |
||||
UncleSha: nil, |
||||
GasUsed: new(big.Int), |
||||
MinGasPrice: new(big.Int), |
||||
GasLimit: new(big.Int), |
||||
} |
||||
block.SetUncles([]*Block{}) |
||||
|
||||
block.state = state.New(trie.New(ethutil.Config.Db, root)) |
||||
|
||||
return block |
||||
} |
||||
|
||||
// Returns a hash of the block
|
||||
func (block *Block) Hash() ethutil.Bytes { |
||||
return crypto.Sha3(ethutil.NewValue(block.header()).Encode()) |
||||
//return crypto.Sha3(block.Value().Encode())
|
||||
} |
||||
|
||||
func (block *Block) HashNoNonce() []byte { |
||||
return crypto.Sha3(ethutil.Encode(block.miningHeader())) |
||||
} |
||||
|
||||
func (block *Block) State() *state.State { |
||||
return block.state |
||||
} |
||||
|
||||
func (block *Block) Transactions() []*Transaction { |
||||
return block.transactions |
||||
} |
||||
|
||||
func (block *Block) CalcGasLimit(parent *Block) *big.Int { |
||||
if block.Number.Cmp(big.NewInt(0)) == 0 { |
||||
return ethutil.BigPow(10, 6) |
||||
} |
||||
|
||||
// ((1024-1) * parent.gasLimit + (gasUsed * 6 / 5)) / 1024
|
||||
|
||||
previous := new(big.Int).Mul(big.NewInt(1024-1), parent.GasLimit) |
||||
current := new(big.Rat).Mul(new(big.Rat).SetInt(parent.GasUsed), big.NewRat(6, 5)) |
||||
curInt := new(big.Int).Div(current.Num(), current.Denom()) |
||||
|
||||
result := new(big.Int).Add(previous, curInt) |
||||
result.Div(result, big.NewInt(1024)) |
||||
|
||||
min := big.NewInt(125000) |
||||
|
||||
return ethutil.BigMax(min, result) |
||||
} |
||||
|
||||
func (block *Block) BlockInfo() BlockInfo { |
||||
bi := BlockInfo{} |
||||
data, _ := ethutil.Config.Db.Get(append(block.Hash(), []byte("Info")...)) |
||||
bi.RlpDecode(data) |
||||
|
||||
return bi |
||||
} |
||||
|
||||
func (self *Block) GetTransaction(hash []byte) *Transaction { |
||||
for _, tx := range self.transactions { |
||||
if bytes.Compare(tx.Hash(), hash) == 0 { |
||||
return tx |
||||
} |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// Sync the block's state and contract respectively
|
||||
func (block *Block) Sync() { |
||||
block.state.Sync() |
||||
} |
||||
|
||||
func (block *Block) Undo() { |
||||
// Sync the block state itself
|
||||
block.state.Reset() |
||||
} |
||||
|
||||
/////// Block Encoding
|
||||
func (block *Block) rlpReceipts() interface{} { |
||||
// Marshal the transactions of this block
|
||||
encR := make([]interface{}, len(block.receipts)) |
||||
for i, r := range block.receipts { |
||||
// Cast it to a string (safe)
|
||||
encR[i] = r.RlpData() |
||||
} |
||||
|
||||
return encR |
||||
} |
||||
|
||||
func (block *Block) rlpUncles() interface{} { |
||||
// Marshal the transactions of this block
|
||||
uncles := make([]interface{}, len(block.Uncles)) |
||||
for i, uncle := range block.Uncles { |
||||
// Cast it to a string (safe)
|
||||
uncles[i] = uncle.header() |
||||
} |
||||
|
||||
return uncles |
||||
} |
||||
|
||||
func (block *Block) SetUncles(uncles []*Block) { |
||||
block.Uncles = uncles |
||||
block.UncleSha = crypto.Sha3(ethutil.Encode(block.rlpUncles())) |
||||
} |
||||
|
||||
func (self *Block) SetReceipts(receipts Receipts) { |
||||
self.receipts = receipts |
||||
self.ReceiptSha = DeriveSha(receipts) |
||||
self.LogsBloom = CreateBloom(self) |
||||
} |
||||
|
||||
func (self *Block) SetTransactions(txs Transactions) { |
||||
self.transactions = txs |
||||
self.TxSha = DeriveSha(txs) |
||||
} |
||||
|
||||
func (block *Block) Value() *ethutil.Value { |
||||
return ethutil.NewValue([]interface{}{block.header(), block.transactions, block.rlpUncles()}) |
||||
} |
||||
|
||||
func (block *Block) RlpEncode() []byte { |
||||
// Encode a slice interface which contains the header and the list of
|
||||
// transactions.
|
||||
return block.Value().Encode() |
||||
} |
||||
|
||||
func (block *Block) RlpDecode(data []byte) { |
||||
rlpValue := ethutil.NewValueFromBytes(data) |
||||
block.RlpValueDecode(rlpValue) |
||||
} |
||||
|
||||
func (block *Block) RlpValueDecode(decoder *ethutil.Value) { |
||||
block.setHeader(decoder.Get(0)) |
||||
|
||||
// Tx list might be empty if this is an uncle. Uncles only have their
|
||||
// header set.
|
||||
if decoder.Get(1).IsNil() == false { // Yes explicitness
|
||||
//receipts := decoder.Get(1)
|
||||
//block.receipts = make([]*Receipt, receipts.Len())
|
||||
txs := decoder.Get(1) |
||||
block.transactions = make(Transactions, txs.Len()) |
||||
for i := 0; i < txs.Len(); i++ { |
||||
block.transactions[i] = NewTransactionFromValue(txs.Get(i)) |
||||
//receipt := NewRecieptFromValue(receipts.Get(i))
|
||||
//block.transactions[i] = receipt.Tx
|
||||
//block.receipts[i] = receipt
|
||||
} |
||||
|
||||
} |
||||
|
||||
if decoder.Get(2).IsNil() == false { // Yes explicitness
|
||||
uncles := decoder.Get(2) |
||||
block.Uncles = make([]*Block, uncles.Len()) |
||||
for i := 0; i < uncles.Len(); i++ { |
||||
block.Uncles[i] = NewUncleBlockFromValue(uncles.Get(i)) |
||||
} |
||||
} |
||||
|
||||
} |
||||
|
||||
func (self *Block) setHeader(header *ethutil.Value) { |
||||
self.PrevHash = header.Get(0).Bytes() |
||||
self.UncleSha = header.Get(1).Bytes() |
||||
self.Coinbase = header.Get(2).Bytes() |
||||
self.state = state.New(trie.New(ethutil.Config.Db, header.Get(3).Val)) |
||||
self.TxSha = header.Get(4).Bytes() |
||||
self.ReceiptSha = header.Get(5).Bytes() |
||||
self.LogsBloom = header.Get(6).Bytes() |
||||
self.Difficulty = header.Get(7).BigInt() |
||||
self.Number = header.Get(8).BigInt() |
||||
self.MinGasPrice = header.Get(9).BigInt() |
||||
self.GasLimit = header.Get(10).BigInt() |
||||
self.GasUsed = header.Get(11).BigInt() |
||||
self.Time = int64(header.Get(12).BigInt().Uint64()) |
||||
self.Extra = header.Get(13).Str() |
||||
self.Nonce = header.Get(14).Bytes() |
||||
} |
||||
|
||||
func NewUncleBlockFromValue(header *ethutil.Value) *Block { |
||||
block := &Block{} |
||||
block.setHeader(header) |
||||
|
||||
return block |
||||
} |
||||
|
||||
func (block *Block) Trie() *trie.Trie { |
||||
return block.state.Trie |
||||
} |
||||
|
||||
func (block *Block) GetRoot() interface{} { |
||||
return block.state.Trie.Root |
||||
} |
||||
|
||||
func (block *Block) Diff() *big.Int { |
||||
return block.Difficulty |
||||
} |
||||
|
||||
func (self *Block) Receipts() []*Receipt { |
||||
return self.receipts |
||||
} |
||||
|
||||
func (block *Block) miningHeader() []interface{} { |
||||
return []interface{}{ |
||||
// Sha of the previous block
|
||||
block.PrevHash, |
||||
// Sha of uncles
|
||||
block.UncleSha, |
||||
// Coinbase address
|
||||
block.Coinbase, |
||||
// root state
|
||||
block.state.Trie.Root, |
||||
// tx root
|
||||
block.TxSha, |
||||
// Sha of tx
|
||||
block.ReceiptSha, |
||||
// Bloom
|
||||
block.LogsBloom, |
||||
// Current block Difficulty
|
||||
block.Difficulty, |
||||
// The block number
|
||||
block.Number, |
||||
// Block minimum gas price
|
||||
block.MinGasPrice, |
||||
// Block upper gas bound
|
||||
block.GasLimit, |
||||
// Block gas used
|
||||
block.GasUsed, |
||||
// Time the block was found?
|
||||
block.Time, |
||||
// Extra data
|
||||
block.Extra, |
||||
} |
||||
} |
||||
|
||||
func (block *Block) header() []interface{} { |
||||
return append(block.miningHeader(), block.Nonce) |
||||
} |
||||
|
||||
func (block *Block) String() string { |
||||
return fmt.Sprintf(` |
||||
BLOCK(%x): Size: %v |
||||
PrevHash: %x |
||||
UncleSha: %x |
||||
Coinbase: %x |
||||
Root: %x |
||||
TxSha %x |
||||
ReceiptSha: %x |
||||
Bloom: %x |
||||
Difficulty: %v |
||||
Number: %v |
||||
MinGas: %v |
||||
MaxLimit: %v |
||||
GasUsed: %v |
||||
Time: %v |
||||
Extra: %v |
||||
Nonce: %x |
||||
NumTx: %v |
||||
`, |
||||
block.Hash(), |
||||
block.Size(), |
||||
block.PrevHash, |
||||
block.UncleSha, |
||||
block.Coinbase, |
||||
block.state.Trie.Root, |
||||
block.TxSha, |
||||
block.ReceiptSha, |
||||
block.LogsBloom, |
||||
block.Difficulty, |
||||
block.Number, |
||||
block.MinGasPrice, |
||||
block.GasLimit, |
||||
block.GasUsed, |
||||
block.Time, |
||||
block.Extra, |
||||
block.Nonce, |
||||
len(block.transactions), |
||||
) |
||||
} |
||||
|
||||
func (self *Block) Size() ethutil.StorageSize { |
||||
return ethutil.StorageSize(len(self.RlpEncode())) |
||||
} |
||||
|
||||
// Implement RlpEncodable
|
||||
func (self *Block) RlpData() interface{} { |
||||
return self.Value().Val |
||||
} |
||||
@ -1,439 +0,0 @@ |
||||
package chain |
||||
|
||||
import ( |
||||
"bytes" |
||||
"container/list" |
||||
"fmt" |
||||
"math/big" |
||||
"os" |
||||
"sync" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
"github.com/ethereum/go-ethereum/event" |
||||
"github.com/ethereum/go-ethereum/logger" |
||||
"github.com/ethereum/go-ethereum/state" |
||||
"github.com/ethereum/go-ethereum/wire" |
||||
) |
||||
|
||||
var statelogger = logger.NewLogger("BLOCK") |
||||
|
||||
type Peer interface { |
||||
Inbound() bool |
||||
LastSend() time.Time |
||||
LastPong() int64 |
||||
Host() []byte |
||||
Port() uint16 |
||||
Version() string |
||||
PingTime() string |
||||
Connected() *int32 |
||||
Caps() *ethutil.Value |
||||
} |
||||
|
||||
type EthManager interface { |
||||
BlockManager() *BlockManager |
||||
ChainManager() *ChainManager |
||||
TxPool() *TxPool |
||||
Broadcast(msgType wire.MsgType, data []interface{}) |
||||
PeerCount() int |
||||
IsMining() bool |
||||
IsListening() bool |
||||
Peers() *list.List |
||||
KeyManager() *crypto.KeyManager |
||||
ClientIdentity() wire.ClientIdentity |
||||
Db() ethutil.Database |
||||
EventMux() *event.TypeMux |
||||
} |
||||
|
||||
type BlockManager struct { |
||||
// Mutex for locking the block processor. Blocks can only be handled one at a time
|
||||
mutex sync.Mutex |
||||
// Canonical block chain
|
||||
bc *ChainManager |
||||
// non-persistent key/value memory storage
|
||||
mem map[string]*big.Int |
||||
// Proof of work used for validating
|
||||
Pow PoW |
||||
// The ethereum manager interface
|
||||
eth EthManager |
||||
// The managed states
|
||||
// Transiently state. The trans state isn't ever saved, validated and
|
||||
// it could be used for setting account nonces without effecting
|
||||
// the main states.
|
||||
transState *state.State |
||||
// Mining state. The mining state is used purely and solely by the mining
|
||||
// operation.
|
||||
miningState *state.State |
||||
|
||||
// The last attempted block is mainly used for debugging purposes
|
||||
// This does not have to be a valid block and will be set during
|
||||
// 'Process' & canonical validation.
|
||||
lastAttemptedBlock *Block |
||||
|
||||
events event.Subscription |
||||
} |
||||
|
||||
func NewBlockManager(ethereum EthManager) *BlockManager { |
||||
sm := &BlockManager{ |
||||
mem: make(map[string]*big.Int), |
||||
Pow: &EasyPow{}, |
||||
eth: ethereum, |
||||
bc: ethereum.ChainManager(), |
||||
} |
||||
sm.transState = ethereum.ChainManager().CurrentBlock.State().Copy() |
||||
sm.miningState = ethereum.ChainManager().CurrentBlock.State().Copy() |
||||
|
||||
return sm |
||||
} |
||||
|
||||
func (self *BlockManager) Start() { |
||||
statelogger.Debugln("Starting state manager") |
||||
self.events = self.eth.EventMux().Subscribe(Blocks(nil)) |
||||
go self.updateThread() |
||||
} |
||||
|
||||
func (self *BlockManager) Stop() { |
||||
statelogger.Debugln("Stopping state manager") |
||||
self.events.Unsubscribe() |
||||
} |
||||
|
||||
func (self *BlockManager) updateThread() { |
||||
for ev := range self.events.Chan() { |
||||
for _, block := range ev.(Blocks) { |
||||
err := self.Process(block) |
||||
if err != nil { |
||||
statelogger.Infoln(err) |
||||
statelogger.Debugf("Block #%v failed (%x...)\n", block.Number, block.Hash()[0:4]) |
||||
statelogger.Debugln(block) |
||||
break |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (sm *BlockManager) CurrentState() *state.State { |
||||
return sm.eth.ChainManager().CurrentBlock.State() |
||||
} |
||||
|
||||
func (sm *BlockManager) TransState() *state.State { |
||||
return sm.transState |
||||
} |
||||
|
||||
func (sm *BlockManager) MiningState() *state.State { |
||||
return sm.miningState |
||||
} |
||||
|
||||
func (sm *BlockManager) NewMiningState() *state.State { |
||||
sm.miningState = sm.eth.ChainManager().CurrentBlock.State().Copy() |
||||
|
||||
return sm.miningState |
||||
} |
||||
|
||||
func (sm *BlockManager) ChainManager() *ChainManager { |
||||
return sm.bc |
||||
} |
||||
|
||||
func (self *BlockManager) ProcessTransactions(coinbase *state.StateObject, state *state.State, block, parent *Block, txs Transactions) (Receipts, Transactions, Transactions, Transactions, error) { |
||||
var ( |
||||
receipts Receipts |
||||
handled, unhandled Transactions |
||||
erroneous Transactions |
||||
totalUsedGas = big.NewInt(0) |
||||
err error |
||||
) |
||||
|
||||
done: |
||||
for i, tx := range txs { |
||||
// If we are mining this block and validating we want to set the logs back to 0
|
||||
state.EmptyLogs() |
||||
|
||||
txGas := new(big.Int).Set(tx.Gas) |
||||
|
||||
cb := state.GetStateObject(coinbase.Address()) |
||||
st := NewStateTransition(cb, tx, state, block) |
||||
err = st.TransitionState() |
||||
if err != nil { |
||||
statelogger.Infoln(err) |
||||
switch { |
||||
case IsNonceErr(err): |
||||
err = nil // ignore error
|
||||
continue |
||||
case IsGasLimitErr(err): |
||||
unhandled = txs[i:] |
||||
|
||||
break done |
||||
default: |
||||
statelogger.Infoln(err) |
||||
erroneous = append(erroneous, tx) |
||||
err = nil |
||||
continue |
||||
//return nil, nil, nil, err
|
||||
} |
||||
} |
||||
|
||||
// Update the state with pending changes
|
||||
state.Update() |
||||
|
||||
txGas.Sub(txGas, st.gas) |
||||
cumulative := new(big.Int).Set(totalUsedGas.Add(totalUsedGas, txGas)) |
||||
//receipt := &Receipt{tx, ethutil.CopyBytes(state.Root().([]byte)), accumelative}
|
||||
receipt := &Receipt{ethutil.CopyBytes(state.Root().([]byte)), cumulative, LogsBloom(state.Logs()).Bytes(), state.Logs()} |
||||
|
||||
if i < len(block.Receipts()) { |
||||
original := block.Receipts()[i] |
||||
if !original.Cmp(receipt) { |
||||
if ethutil.Config.Diff { |
||||
os.Exit(1) |
||||
} |
||||
|
||||
err := fmt.Errorf("#%d receipt failed (r) %v ~ %x <=> (c) %v ~ %x (%x...)", i+1, original.CumulativeGasUsed, original.PostState[0:4], receipt.CumulativeGasUsed, receipt.PostState[0:4], tx.Hash()[0:4]) |
||||
|
||||
return nil, nil, nil, nil, err |
||||
} |
||||
} |
||||
|
||||
// Notify all subscribers
|
||||
go self.eth.EventMux().Post(TxPostEvent{tx}) |
||||
|
||||
receipts = append(receipts, receipt) |
||||
handled = append(handled, tx) |
||||
|
||||
if ethutil.Config.Diff && ethutil.Config.DiffType == "all" { |
||||
state.CreateOutputForDiff() |
||||
} |
||||
} |
||||
|
||||
parent.GasUsed = totalUsedGas |
||||
|
||||
return receipts, handled, unhandled, erroneous, err |
||||
} |
||||
|
||||
func (sm *BlockManager) Process(block *Block) (err error) { |
||||
// Processing a blocks may never happen simultaneously
|
||||
sm.mutex.Lock() |
||||
defer sm.mutex.Unlock() |
||||
|
||||
if sm.bc.HasBlock(block.Hash()) { |
||||
return nil |
||||
} |
||||
|
||||
if !sm.bc.HasBlock(block.PrevHash) { |
||||
return ParentError(block.PrevHash) |
||||
} |
||||
|
||||
sm.lastAttemptedBlock = block |
||||
|
||||
var ( |
||||
parent = sm.bc.GetBlock(block.PrevHash) |
||||
state = parent.State() |
||||
) |
||||
|
||||
// Defer the Undo on the Trie. If the block processing happened
|
||||
// we don't want to undo but since undo only happens on dirty
|
||||
// nodes this won't happen because Commit would have been called
|
||||
// before that.
|
||||
defer state.Reset() |
||||
|
||||
if ethutil.Config.Diff && ethutil.Config.DiffType == "all" { |
||||
fmt.Printf("## %x %x ##\n", block.Hash(), block.Number) |
||||
} |
||||
|
||||
txSha := DeriveSha(block.transactions) |
||||
if bytes.Compare(txSha, block.TxSha) != 0 { |
||||
return fmt.Errorf("Error validating transaction sha. Received %x, got %x", block.TxSha, txSha) |
||||
} |
||||
|
||||
receipts, err := sm.ApplyDiff(state, parent, block) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
receiptSha := DeriveSha(receipts) |
||||
if bytes.Compare(receiptSha, block.ReceiptSha) != 0 { |
||||
return fmt.Errorf("Error validating receipt sha. Received %x, got %x", block.ReceiptSha, receiptSha) |
||||
} |
||||
|
||||
// TODO validate bloom
|
||||
|
||||
// Block validation
|
||||
if err = sm.ValidateBlock(block); err != nil { |
||||
statelogger.Errorln("Error validating block:", err) |
||||
return err |
||||
} |
||||
|
||||
if err = sm.AccumelateRewards(state, block, parent); err != nil { |
||||
statelogger.Errorln("Error accumulating reward", err) |
||||
return err |
||||
} |
||||
|
||||
state.Update() |
||||
|
||||
if !block.State().Cmp(state) { |
||||
err = fmt.Errorf("Invalid merkle root.\nrec: %x\nis: %x", block.State().Trie.Root, state.Trie.Root) |
||||
return |
||||
} |
||||
|
||||
// Calculate the new total difficulty and sync back to the db
|
||||
if sm.CalculateTD(block) { |
||||
// Sync the current block's state to the database and cancelling out the deferred Undo
|
||||
state.Sync() |
||||
|
||||
// Add the block to the chain
|
||||
sm.bc.Add(block) |
||||
|
||||
// TODO at this point we should also insert LOGS in to a database
|
||||
|
||||
sm.transState = state.Copy() |
||||
|
||||
statelogger.Infof("Imported block #%d (%x...)\n", block.Number, block.Hash()[0:4]) |
||||
|
||||
state.Manifest().Reset() |
||||
|
||||
sm.eth.TxPool().RemoveSet(block.Transactions()) |
||||
} else { |
||||
statelogger.Errorln("total diff failed") |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (sm *BlockManager) ApplyDiff(state *state.State, parent, block *Block) (receipts Receipts, err error) { |
||||
coinbase := state.GetOrNewStateObject(block.Coinbase) |
||||
coinbase.SetGasPool(block.CalcGasLimit(parent)) |
||||
|
||||
// Process the transactions on to current block
|
||||
receipts, _, _, _, err = sm.ProcessTransactions(coinbase, state, block, parent, block.Transactions()) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return receipts, nil |
||||
} |
||||
|
||||
func (sm *BlockManager) CalculateTD(block *Block) bool { |
||||
uncleDiff := new(big.Int) |
||||
for _, uncle := range block.Uncles { |
||||
uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty) |
||||
} |
||||
|
||||
// TD(genesis_block) = 0 and TD(B) = TD(B.parent) + sum(u.difficulty for u in B.uncles) + B.difficulty
|
||||
td := new(big.Int) |
||||
td = td.Add(sm.bc.TD, uncleDiff) |
||||
td = td.Add(td, block.Difficulty) |
||||
|
||||
// The new TD will only be accepted if the new difficulty is
|
||||
// is greater than the previous.
|
||||
if td.Cmp(sm.bc.TD) > 0 { |
||||
// Set the new total difficulty back to the block chain
|
||||
sm.bc.SetTotalDifficulty(td) |
||||
|
||||
return true |
||||
} |
||||
|
||||
return false |
||||
} |
||||
|
||||
// Validates the current block. Returns an error if the block was invalid,
|
||||
// an uncle or anything that isn't on the current block chain.
|
||||
// Validation validates easy over difficult (dagger takes longer time = difficult)
|
||||
func (sm *BlockManager) ValidateBlock(block *Block) error { |
||||
// Check each uncle's previous hash. In order for it to be valid
|
||||
// is if it has the same block hash as the current
|
||||
parent := sm.bc.GetBlock(block.PrevHash) |
||||
/* |
||||
for _, uncle := range block.Uncles { |
||||
if bytes.Compare(uncle.PrevHash,parent.PrevHash) != 0 { |
||||
return ValidationError("Mismatch uncle's previous hash. Expected %x, got %x",parent.PrevHash, uncle.PrevHash) |
||||
} |
||||
} |
||||
*/ |
||||
|
||||
expd := CalcDifficulty(block, parent) |
||||
if expd.Cmp(block.Difficulty) < 0 { |
||||
return fmt.Errorf("Difficulty check failed for block %v, %v", block.Difficulty, expd) |
||||
} |
||||
|
||||
diff := block.Time - parent.Time |
||||
if diff < 0 { |
||||
return ValidationError("Block timestamp less then prev block %v (%v - %v)", diff, block.Time, sm.bc.CurrentBlock.Time) |
||||
} |
||||
|
||||
/* XXX |
||||
// New blocks must be within the 15 minute range of the last block.
|
||||
if diff > int64(15*time.Minute) { |
||||
return ValidationError("Block is too far in the future of last block (> 15 minutes)") |
||||
} |
||||
*/ |
||||
|
||||
// Verify the nonce of the block. Return an error if it's not valid
|
||||
if !sm.Pow.Verify(block.HashNoNonce(), block.Difficulty, block.Nonce) { |
||||
return ValidationError("Block's nonce is invalid (= %v)", ethutil.Bytes2Hex(block.Nonce)) |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (sm *BlockManager) AccumelateRewards(state *state.State, block, parent *Block) error { |
||||
reward := new(big.Int).Set(BlockReward) |
||||
|
||||
knownUncles := ethutil.Set(parent.Uncles) |
||||
nonces := ethutil.NewSet(block.Nonce) |
||||
for _, uncle := range block.Uncles { |
||||
if nonces.Include(uncle.Nonce) { |
||||
// Error not unique
|
||||
return UncleError("Uncle not unique") |
||||
} |
||||
|
||||
uncleParent := sm.bc.GetBlock(uncle.PrevHash) |
||||
if uncleParent == nil { |
||||
return UncleError("Uncle's parent unknown") |
||||
} |
||||
|
||||
if uncleParent.Number.Cmp(new(big.Int).Sub(parent.Number, big.NewInt(6))) < 0 { |
||||
return UncleError("Uncle too old") |
||||
} |
||||
|
||||
if knownUncles.Include(uncle.Hash()) { |
||||
return UncleError("Uncle in chain") |
||||
} |
||||
|
||||
nonces.Insert(uncle.Nonce) |
||||
|
||||
r := new(big.Int) |
||||
r.Mul(BlockReward, big.NewInt(15)).Div(r, big.NewInt(16)) |
||||
|
||||
uncleAccount := state.GetAccount(uncle.Coinbase) |
||||
uncleAccount.AddAmount(r) |
||||
|
||||
reward.Add(reward, new(big.Int).Div(BlockReward, big.NewInt(32))) |
||||
} |
||||
|
||||
// Get the account associated with the coinbase
|
||||
account := state.GetAccount(block.Coinbase) |
||||
// Reward amount of ether to the coinbase address
|
||||
account.AddAmount(reward) |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (sm *BlockManager) GetMessages(block *Block) (messages []*state.Message, err error) { |
||||
if !sm.bc.HasBlock(block.PrevHash) { |
||||
return nil, ParentError(block.PrevHash) |
||||
} |
||||
|
||||
sm.lastAttemptedBlock = block |
||||
|
||||
var ( |
||||
parent = sm.bc.GetBlock(block.PrevHash) |
||||
state = parent.State().Copy() |
||||
) |
||||
|
||||
defer state.Reset() |
||||
|
||||
sm.ApplyDiff(state, parent, block) |
||||
|
||||
sm.AccumelateRewards(state, block, parent) |
||||
|
||||
return state.Manifest().Messages, nil |
||||
} |
||||
@ -1,289 +0,0 @@ |
||||
package chain |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"math/big" |
||||
|
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
"github.com/ethereum/go-ethereum/logger" |
||||
) |
||||
|
||||
var chainlogger = logger.NewLogger("CHAIN") |
||||
|
||||
type ChainManager struct { |
||||
Ethereum EthManager |
||||
// The famous, the fabulous Mister GENESIIIIIIS (block)
|
||||
genesisBlock *Block |
||||
// Last known total difficulty
|
||||
TD *big.Int |
||||
|
||||
LastBlockNumber uint64 |
||||
|
||||
CurrentBlock *Block |
||||
LastBlockHash []byte |
||||
} |
||||
|
||||
func NewChainManager(ethereum EthManager) *ChainManager { |
||||
bc := &ChainManager{} |
||||
bc.genesisBlock = NewBlockFromBytes(ethutil.Encode(Genesis)) |
||||
bc.Ethereum = ethereum |
||||
|
||||
bc.setLastBlock() |
||||
|
||||
return bc |
||||
} |
||||
|
||||
func (bc *ChainManager) Genesis() *Block { |
||||
return bc.genesisBlock |
||||
} |
||||
|
||||
func (bc *ChainManager) NewBlock(coinbase []byte) *Block { |
||||
var root interface{} |
||||
hash := ZeroHash256 |
||||
|
||||
if bc.CurrentBlock != nil { |
||||
root = bc.CurrentBlock.state.Trie.Root |
||||
hash = bc.LastBlockHash |
||||
} |
||||
|
||||
block := CreateBlock( |
||||
root, |
||||
hash, |
||||
coinbase, |
||||
ethutil.BigPow(2, 32), |
||||
nil, |
||||
"") |
||||
|
||||
block.MinGasPrice = big.NewInt(10000000000000) |
||||
|
||||
parent := bc.CurrentBlock |
||||
if parent != nil { |
||||
block.Difficulty = CalcDifficulty(block, parent) |
||||
block.Number = new(big.Int).Add(bc.CurrentBlock.Number, ethutil.Big1) |
||||
block.GasLimit = block.CalcGasLimit(bc.CurrentBlock) |
||||
|
||||
} |
||||
|
||||
return block |
||||
} |
||||
|
||||
func CalcDifficulty(block, parent *Block) *big.Int { |
||||
diff := new(big.Int) |
||||
|
||||
adjust := new(big.Int).Rsh(parent.Difficulty, 10) |
||||
if block.Time >= parent.Time+5 { |
||||
diff.Sub(parent.Difficulty, adjust) |
||||
} else { |
||||
diff.Add(parent.Difficulty, adjust) |
||||
} |
||||
|
||||
return diff |
||||
} |
||||
|
||||
func (bc *ChainManager) Reset() { |
||||
AddTestNetFunds(bc.genesisBlock) |
||||
|
||||
bc.genesisBlock.state.Trie.Sync() |
||||
// Prepare the genesis block
|
||||
bc.Add(bc.genesisBlock) |
||||
bc.CurrentBlock = bc.genesisBlock |
||||
|
||||
bc.SetTotalDifficulty(ethutil.Big("0")) |
||||
|
||||
// Set the last know difficulty (might be 0x0 as initial value, Genesis)
|
||||
bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD()) |
||||
} |
||||
|
||||
func (bc *ChainManager) HasBlock(hash []byte) bool { |
||||
data, _ := ethutil.Config.Db.Get(hash) |
||||
return len(data) != 0 |
||||
} |
||||
|
||||
// TODO: At one point we might want to save a block by prevHash in the db to optimise this...
|
||||
func (bc *ChainManager) HasBlockWithPrevHash(hash []byte) bool { |
||||
block := bc.CurrentBlock |
||||
|
||||
for ; block != nil; block = bc.GetBlock(block.PrevHash) { |
||||
if bytes.Compare(hash, block.PrevHash) == 0 { |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func (bc *ChainManager) CalculateBlockTD(block *Block) *big.Int { |
||||
blockDiff := new(big.Int) |
||||
|
||||
for _, uncle := range block.Uncles { |
||||
blockDiff = blockDiff.Add(blockDiff, uncle.Difficulty) |
||||
} |
||||
blockDiff = blockDiff.Add(blockDiff, block.Difficulty) |
||||
|
||||
return blockDiff |
||||
} |
||||
|
||||
func (bc *ChainManager) GenesisBlock() *Block { |
||||
return bc.genesisBlock |
||||
} |
||||
|
||||
func (self *ChainManager) GetChainHashesFromHash(hash []byte, max uint64) (chain [][]byte) { |
||||
block := self.GetBlock(hash) |
||||
if block == nil { |
||||
return |
||||
} |
||||
|
||||
// XXX Could be optimised by using a different database which only holds hashes (i.e., linked list)
|
||||
for i := uint64(0); i < max; i++ { |
||||
chain = append(chain, block.Hash()) |
||||
|
||||
if block.Number.Cmp(ethutil.Big0) <= 0 { |
||||
break |
||||
} |
||||
|
||||
block = self.GetBlock(block.PrevHash) |
||||
} |
||||
|
||||
return |
||||
} |
||||
|
||||
func AddTestNetFunds(block *Block) { |
||||
for _, addr := range []string{ |
||||
"51ba59315b3a95761d0863b05ccc7a7f54703d99", |
||||
"e4157b34ea9615cfbde6b4fda419828124b70c78", |
||||
"b9c015918bdaba24b4ff057a92a3873d6eb201be", |
||||
"6c386a4b26f73c802f34673f7248bb118f97424a", |
||||
"cd2a3d9f938e13cd947ec05abc7fe734df8dd826", |
||||
"2ef47100e0787b915105fd5e3f4ff6752079d5cb", |
||||
"e6716f9544a56c530d868e4bfbacb172315bdead", |
||||
"1a26338f0d905e295fccb71fa9ea849ffa12aaf4", |
||||
} { |
||||
codedAddr := ethutil.Hex2Bytes(addr) |
||||
account := block.state.GetAccount(codedAddr) |
||||
account.SetBalance(ethutil.Big("1606938044258990275541962092341162602522202993782792835301376")) //ethutil.BigPow(2, 200)
|
||||
block.state.UpdateStateObject(account) |
||||
} |
||||
} |
||||
|
||||
func (bc *ChainManager) setLastBlock() { |
||||
data, _ := ethutil.Config.Db.Get([]byte("LastBlock")) |
||||
if len(data) != 0 { |
||||
// Prep genesis
|
||||
AddTestNetFunds(bc.genesisBlock) |
||||
|
||||
block := NewBlockFromBytes(data) |
||||
bc.CurrentBlock = block |
||||
bc.LastBlockHash = block.Hash() |
||||
bc.LastBlockNumber = block.Number.Uint64() |
||||
|
||||
// Set the last know difficulty (might be 0x0 as initial value, Genesis)
|
||||
bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD()) |
||||
} else { |
||||
bc.Reset() |
||||
} |
||||
|
||||
chainlogger.Infof("Last block (#%d) %x\n", bc.LastBlockNumber, bc.CurrentBlock.Hash()) |
||||
} |
||||
|
||||
func (bc *ChainManager) SetTotalDifficulty(td *big.Int) { |
||||
ethutil.Config.Db.Put([]byte("LTD"), td.Bytes()) |
||||
bc.TD = td |
||||
} |
||||
|
||||
// Add a block to the chain and record addition information
|
||||
func (bc *ChainManager) Add(block *Block) { |
||||
bc.writeBlockInfo(block) |
||||
// Prepare the genesis block
|
||||
|
||||
bc.CurrentBlock = block |
||||
bc.LastBlockHash = block.Hash() |
||||
|
||||
encodedBlock := block.RlpEncode() |
||||
ethutil.Config.Db.Put(block.Hash(), encodedBlock) |
||||
ethutil.Config.Db.Put([]byte("LastBlock"), encodedBlock) |
||||
} |
||||
|
||||
func (self *ChainManager) CalcTotalDiff(block *Block) (*big.Int, error) { |
||||
parent := self.GetBlock(block.PrevHash) |
||||
if parent == nil { |
||||
return nil, fmt.Errorf("Unable to calculate total diff without known parent %x", block.PrevHash) |
||||
} |
||||
|
||||
parentTd := parent.BlockInfo().TD |
||||
|
||||
uncleDiff := new(big.Int) |
||||
for _, uncle := range block.Uncles { |
||||
uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty) |
||||
} |
||||
|
||||
td := new(big.Int) |
||||
td = td.Add(parentTd, uncleDiff) |
||||
td = td.Add(td, block.Difficulty) |
||||
|
||||
return td, nil |
||||
} |
||||
|
||||
func (bc *ChainManager) GetBlock(hash []byte) *Block { |
||||
data, _ := ethutil.Config.Db.Get(hash) |
||||
if len(data) == 0 { |
||||
return nil |
||||
} |
||||
|
||||
return NewBlockFromBytes(data) |
||||
} |
||||
|
||||
func (self *ChainManager) GetBlockByNumber(num uint64) *Block { |
||||
block := self.CurrentBlock |
||||
for ; block != nil; block = self.GetBlock(block.PrevHash) { |
||||
if block.Number.Uint64() == num { |
||||
break |
||||
} |
||||
} |
||||
|
||||
if block != nil && block.Number.Uint64() == 0 && num != 0 { |
||||
return nil |
||||
} |
||||
|
||||
return block |
||||
} |
||||
|
||||
func (self *ChainManager) GetBlockBack(num uint64) *Block { |
||||
block := self.CurrentBlock |
||||
|
||||
for ; num != 0 && block != nil; num-- { |
||||
block = self.GetBlock(block.PrevHash) |
||||
} |
||||
|
||||
return block |
||||
} |
||||
|
||||
func (bc *ChainManager) BlockInfoByHash(hash []byte) BlockInfo { |
||||
bi := BlockInfo{} |
||||
data, _ := ethutil.Config.Db.Get(append(hash, []byte("Info")...)) |
||||
bi.RlpDecode(data) |
||||
|
||||
return bi |
||||
} |
||||
|
||||
func (bc *ChainManager) BlockInfo(block *Block) BlockInfo { |
||||
bi := BlockInfo{} |
||||
data, _ := ethutil.Config.Db.Get(append(block.Hash(), []byte("Info")...)) |
||||
bi.RlpDecode(data) |
||||
|
||||
return bi |
||||
} |
||||
|
||||
// Unexported method for writing extra non-essential block info to the db
|
||||
func (bc *ChainManager) writeBlockInfo(block *Block) { |
||||
bc.LastBlockNumber++ |
||||
bi := BlockInfo{Number: bc.LastBlockNumber, Hash: block.Hash(), Parent: block.PrevHash, TD: bc.TD} |
||||
|
||||
// For now we use the block hash with the words "info" appended as key
|
||||
ethutil.Config.Db.Put(append(block.Hash(), []byte("Info")...), bi.RlpEncode()) |
||||
} |
||||
|
||||
func (bc *ChainManager) Stop() { |
||||
if bc.CurrentBlock != nil { |
||||
chainlogger.Infoln("Stopped") |
||||
} |
||||
} |
||||
@ -1 +0,0 @@ |
||||
package chain |
||||
@ -1,10 +0,0 @@ |
||||
package chain |
||||
|
||||
// TxPreEvent is posted when a transaction enters the transaction pool.
|
||||
type TxPreEvent struct{ Tx *Transaction } |
||||
|
||||
// TxPostEvent is posted when a transaction has been processed.
|
||||
type TxPostEvent struct{ Tx *Transaction } |
||||
|
||||
// NewBlockEvent is posted when a block has been imported.
|
||||
type NewBlockEvent struct{ Block *Block } |
||||
@ -1,197 +0,0 @@ |
||||
package chain |
||||
|
||||
import ( |
||||
"bytes" |
||||
"math" |
||||
|
||||
"github.com/ethereum/go-ethereum/state" |
||||
) |
||||
|
||||
type AccountChange struct { |
||||
Address, StateAddress []byte |
||||
} |
||||
|
||||
// Filtering interface
|
||||
type Filter struct { |
||||
eth EthManager |
||||
earliest int64 |
||||
latest int64 |
||||
skip int |
||||
from, to [][]byte |
||||
max int |
||||
|
||||
Altered []AccountChange |
||||
|
||||
BlockCallback func(*Block) |
||||
MessageCallback func(state.Messages) |
||||
} |
||||
|
||||
// Create a new filter which uses a bloom filter on blocks to figure out whether a particular block
|
||||
// is interesting or not.
|
||||
func NewFilter(eth EthManager) *Filter { |
||||
return &Filter{eth: eth} |
||||
} |
||||
|
||||
func (self *Filter) AddAltered(address, stateAddress []byte) { |
||||
self.Altered = append(self.Altered, AccountChange{address, stateAddress}) |
||||
} |
||||
|
||||
// Set the earliest and latest block for filtering.
|
||||
// -1 = latest block (i.e., the current block)
|
||||
// hash = particular hash from-to
|
||||
func (self *Filter) SetEarliestBlock(earliest int64) { |
||||
self.earliest = earliest |
||||
} |
||||
|
||||
func (self *Filter) SetLatestBlock(latest int64) { |
||||
self.latest = latest |
||||
} |
||||
|
||||
func (self *Filter) SetFrom(addr [][]byte) { |
||||
self.from = addr |
||||
} |
||||
|
||||
func (self *Filter) AddFrom(addr []byte) { |
||||
self.from = append(self.from, addr) |
||||
} |
||||
|
||||
func (self *Filter) SetTo(addr [][]byte) { |
||||
self.to = addr |
||||
} |
||||
|
||||
func (self *Filter) AddTo(addr []byte) { |
||||
self.to = append(self.to, addr) |
||||
} |
||||
|
||||
func (self *Filter) SetMax(max int) { |
||||
self.max = max |
||||
} |
||||
|
||||
func (self *Filter) SetSkip(skip int) { |
||||
self.skip = skip |
||||
} |
||||
|
||||
// Run filters messages with the current parameters set
|
||||
func (self *Filter) Find() []*state.Message { |
||||
var earliestBlockNo uint64 = uint64(self.earliest) |
||||
if self.earliest == -1 { |
||||
earliestBlockNo = self.eth.ChainManager().CurrentBlock.Number.Uint64() |
||||
} |
||||
var latestBlockNo uint64 = uint64(self.latest) |
||||
if self.latest == -1 { |
||||
latestBlockNo = self.eth.ChainManager().CurrentBlock.Number.Uint64() |
||||
} |
||||
|
||||
var ( |
||||
messages []*state.Message |
||||
block = self.eth.ChainManager().GetBlockByNumber(latestBlockNo) |
||||
quit bool |
||||
) |
||||
for i := 0; !quit && block != nil; i++ { |
||||
// Quit on latest
|
||||
switch { |
||||
case block.Number.Uint64() == earliestBlockNo, block.Number.Uint64() == 0: |
||||
quit = true |
||||
case self.max <= len(messages): |
||||
break |
||||
} |
||||
|
||||
// Use bloom filtering to see if this block is interesting given the
|
||||
// current parameters
|
||||
if self.bloomFilter(block) { |
||||
// Get the messages of the block
|
||||
msgs, err := self.eth.BlockManager().GetMessages(block) |
||||
if err != nil { |
||||
chainlogger.Warnln("err: filter get messages ", err) |
||||
|
||||
break |
||||
} |
||||
|
||||
messages = append(messages, self.FilterMessages(msgs)...) |
||||
} |
||||
|
||||
block = self.eth.ChainManager().GetBlock(block.PrevHash) |
||||
} |
||||
|
||||
skip := int(math.Min(float64(len(messages)), float64(self.skip))) |
||||
|
||||
return messages[skip:] |
||||
} |
||||
|
||||
func includes(addresses [][]byte, a []byte) (found bool) { |
||||
for _, addr := range addresses { |
||||
if bytes.Compare(addr, a) == 0 { |
||||
return true |
||||
} |
||||
} |
||||
|
||||
return |
||||
} |
||||
|
||||
func (self *Filter) FilterMessages(msgs []*state.Message) []*state.Message { |
||||
var messages []*state.Message |
||||
|
||||
// Filter the messages for interesting stuff
|
||||
for _, message := range msgs { |
||||
if len(self.to) > 0 && !includes(self.to, message.To) { |
||||
continue |
||||
} |
||||
|
||||
if len(self.from) > 0 && !includes(self.from, message.From) { |
||||
continue |
||||
} |
||||
|
||||
var match bool |
||||
if len(self.Altered) == 0 { |
||||
match = true |
||||
} |
||||
|
||||
for _, accountChange := range self.Altered { |
||||
if len(accountChange.Address) > 0 && bytes.Compare(message.To, accountChange.Address) != 0 { |
||||
continue |
||||
} |
||||
|
||||
if len(accountChange.StateAddress) > 0 && !includes(message.ChangedAddresses, accountChange.StateAddress) { |
||||
continue |
||||
} |
||||
|
||||
match = true |
||||
break |
||||
} |
||||
|
||||
if !match { |
||||
continue |
||||
} |
||||
|
||||
messages = append(messages, message) |
||||
} |
||||
|
||||
return messages |
||||
} |
||||
|
||||
func (self *Filter) bloomFilter(block *Block) bool { |
||||
var fromIncluded, toIncluded bool |
||||
if len(self.from) > 0 { |
||||
for _, from := range self.from { |
||||
if BloomLookup(block.LogsBloom, from) { |
||||
fromIncluded = true |
||||
break |
||||
} |
||||
} |
||||
} else { |
||||
fromIncluded = true |
||||
} |
||||
|
||||
if len(self.to) > 0 { |
||||
for _, to := range self.to { |
||||
if BloomLookup(block.LogsBloom, to) { |
||||
toIncluded = true |
||||
break |
||||
} |
||||
} |
||||
} else { |
||||
toIncluded = true |
||||
} |
||||
|
||||
return fromIncluded && toIncluded |
||||
} |
||||
@ -1,7 +0,0 @@ |
||||
package chain |
||||
|
||||
import "testing" |
||||
|
||||
func TestFilter(t *testing.T) { |
||||
NewFilter(NewTestManager()) |
||||
} |
||||
@ -1,54 +0,0 @@ |
||||
package chain |
||||
|
||||
import ( |
||||
"math/big" |
||||
|
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
) |
||||
|
||||
/* |
||||
* This is the special genesis block. |
||||
*/ |
||||
|
||||
var ZeroHash256 = make([]byte, 32) |
||||
var ZeroHash160 = make([]byte, 20) |
||||
var ZeroHash512 = make([]byte, 64) |
||||
var EmptyShaList = crypto.Sha3(ethutil.Encode([]interface{}{})) |
||||
var EmptyListRoot = crypto.Sha3(ethutil.Encode("")) |
||||
|
||||
var GenesisHeader = []interface{}{ |
||||
// Previous hash (none)
|
||||
ZeroHash256, |
||||
// Empty uncles
|
||||
EmptyShaList, |
||||
// Coinbase
|
||||
ZeroHash160, |
||||
// Root state
|
||||
EmptyShaList, |
||||
// tx root
|
||||
EmptyListRoot, |
||||
// receipt root
|
||||
EmptyListRoot, |
||||
// bloom
|
||||
ZeroHash512, |
||||
// Difficulty
|
||||
//ethutil.BigPow(2, 22),
|
||||
big.NewInt(131072), |
||||
// Number
|
||||
ethutil.Big0, |
||||
// Block minimum gas price
|
||||
ethutil.Big0, |
||||
// Block upper gas bound
|
||||
big.NewInt(1000000), |
||||
// Block gas used
|
||||
ethutil.Big0, |
||||
// Time
|
||||
ethutil.Big0, |
||||
// Extra
|
||||
nil, |
||||
// Nonce
|
||||
crypto.Sha3(big.NewInt(42).Bytes()), |
||||
} |
||||
|
||||
var Genesis = []interface{}{GenesisHeader, []interface{}{}, []interface{}{}} |
||||
@ -1,264 +0,0 @@ |
||||
package chain |
||||
|
||||
import ( |
||||
"fmt" |
||||
"math/big" |
||||
|
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
"github.com/ethereum/go-ethereum/state" |
||||
"github.com/ethereum/go-ethereum/vm" |
||||
) |
||||
|
||||
/* |
||||
* The State transitioning model |
||||
* |
||||
* A state transition is a change made when a transaction is applied to the current world state |
||||
* The state transitioning model does all all the necessary work to work out a valid new state root. |
||||
* 1) Nonce handling |
||||
* 2) Pre pay / buy gas of the coinbase (miner) |
||||
* 3) Create a new state object if the recipient is \0*32 |
||||
* 4) Value transfer |
||||
* == If contract creation == |
||||
* 4a) Attempt to run transaction data |
||||
* 4b) If valid, use result as code for the new state object |
||||
* == end == |
||||
* 5) Run Script section |
||||
* 6) Derive new state root |
||||
*/ |
||||
type StateTransition struct { |
||||
coinbase, receiver []byte |
||||
tx *Transaction |
||||
gas, gasPrice *big.Int |
||||
value *big.Int |
||||
data []byte |
||||
state *state.State |
||||
block *Block |
||||
|
||||
cb, rec, sen *state.StateObject |
||||
} |
||||
|
||||
func NewStateTransition(coinbase *state.StateObject, tx *Transaction, state *state.State, block *Block) *StateTransition { |
||||
return &StateTransition{coinbase.Address(), tx.Recipient, tx, new(big.Int), new(big.Int).Set(tx.GasPrice), tx.Value, tx.Data, state, block, coinbase, nil, nil} |
||||
} |
||||
|
||||
func (self *StateTransition) Coinbase() *state.StateObject { |
||||
if self.cb != nil { |
||||
return self.cb |
||||
} |
||||
|
||||
self.cb = self.state.GetOrNewStateObject(self.coinbase) |
||||
return self.cb |
||||
} |
||||
func (self *StateTransition) Sender() *state.StateObject { |
||||
if self.sen != nil { |
||||
return self.sen |
||||
} |
||||
|
||||
self.sen = self.state.GetOrNewStateObject(self.tx.Sender()) |
||||
|
||||
return self.sen |
||||
} |
||||
func (self *StateTransition) Receiver() *state.StateObject { |
||||
if self.tx != nil && self.tx.CreatesContract() { |
||||
return nil |
||||
} |
||||
|
||||
if self.rec != nil { |
||||
return self.rec |
||||
} |
||||
|
||||
self.rec = self.state.GetOrNewStateObject(self.tx.Recipient) |
||||
return self.rec |
||||
} |
||||
|
||||
func (self *StateTransition) UseGas(amount *big.Int) error { |
||||
if self.gas.Cmp(amount) < 0 { |
||||
return OutOfGasError() |
||||
} |
||||
self.gas.Sub(self.gas, amount) |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (self *StateTransition) AddGas(amount *big.Int) { |
||||
self.gas.Add(self.gas, amount) |
||||
} |
||||
|
||||
func (self *StateTransition) BuyGas() error { |
||||
var err error |
||||
|
||||
sender := self.Sender() |
||||
if sender.Balance().Cmp(self.tx.GasValue()) < 0 { |
||||
return fmt.Errorf("Insufficient funds to pre-pay gas. Req %v, has %v", self.tx.GasValue(), sender.Balance()) |
||||
} |
||||
|
||||
coinbase := self.Coinbase() |
||||
err = coinbase.BuyGas(self.tx.Gas, self.tx.GasPrice) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
self.AddGas(self.tx.Gas) |
||||
sender.SubAmount(self.tx.GasValue()) |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (self *StateTransition) RefundGas() { |
||||
coinbase, sender := self.Coinbase(), self.Sender() |
||||
coinbase.RefundGas(self.gas, self.tx.GasPrice) |
||||
|
||||
// Return remaining gas
|
||||
remaining := new(big.Int).Mul(self.gas, self.tx.GasPrice) |
||||
sender.AddAmount(remaining) |
||||
} |
||||
|
||||
func (self *StateTransition) preCheck() (err error) { |
||||
var ( |
||||
tx = self.tx |
||||
sender = self.Sender() |
||||
) |
||||
|
||||
// Make sure this transaction's nonce is correct
|
||||
if sender.Nonce != tx.Nonce { |
||||
return NonceError(tx.Nonce, sender.Nonce) |
||||
} |
||||
|
||||
// Pre-pay gas / Buy gas of the coinbase account
|
||||
if err = self.BuyGas(); err != nil { |
||||
return err |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (self *StateTransition) TransitionState() (err error) { |
||||
statelogger.Debugf("(~) %x\n", self.tx.Hash()) |
||||
|
||||
// XXX Transactions after this point are considered valid.
|
||||
if err = self.preCheck(); err != nil { |
||||
return |
||||
} |
||||
|
||||
var ( |
||||
tx = self.tx |
||||
sender = self.Sender() |
||||
receiver *state.StateObject |
||||
) |
||||
|
||||
defer self.RefundGas() |
||||
|
||||
// Increment the nonce for the next transaction
|
||||
sender.Nonce += 1 |
||||
|
||||
// Transaction gas
|
||||
if err = self.UseGas(vm.GasTx); err != nil { |
||||
return |
||||
} |
||||
|
||||
// Pay data gas
|
||||
dataPrice := big.NewInt(int64(len(self.data))) |
||||
dataPrice.Mul(dataPrice, vm.GasData) |
||||
if err = self.UseGas(dataPrice); err != nil { |
||||
return |
||||
} |
||||
|
||||
if sender.Balance().Cmp(self.value) < 0 { |
||||
return fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", self.value, sender.Balance) |
||||
} |
||||
|
||||
var snapshot *state.State |
||||
// If the receiver is nil it's a contract (\0*32).
|
||||
if tx.CreatesContract() { |
||||
// Subtract the (irreversible) amount from the senders account
|
||||
sender.SubAmount(self.value) |
||||
|
||||
snapshot = self.state.Copy() |
||||
|
||||
// Create a new state object for the contract
|
||||
receiver = MakeContract(tx, self.state) |
||||
self.rec = receiver |
||||
if receiver == nil { |
||||
return fmt.Errorf("Unable to create contract") |
||||
} |
||||
|
||||
// Add the amount to receivers account which should conclude this transaction
|
||||
receiver.AddAmount(self.value) |
||||
} else { |
||||
receiver = self.Receiver() |
||||
|
||||
// Subtract the amount from the senders account
|
||||
sender.SubAmount(self.value) |
||||
// Add the amount to receivers account which should conclude this transaction
|
||||
receiver.AddAmount(self.value) |
||||
|
||||
snapshot = self.state.Copy() |
||||
} |
||||
|
||||
msg := self.state.Manifest().AddMessage(&state.Message{ |
||||
To: receiver.Address(), From: sender.Address(), |
||||
Input: self.tx.Data, |
||||
Origin: sender.Address(), |
||||
Block: self.block.Hash(), Timestamp: self.block.Time, Coinbase: self.block.Coinbase, Number: self.block.Number, |
||||
Value: self.value, |
||||
}) |
||||
|
||||
// Process the init code and create 'valid' contract
|
||||
if IsContractAddr(self.receiver) { |
||||
// Evaluate the initialization script
|
||||
// and use the return value as the
|
||||
// script section for the state object.
|
||||
self.data = nil |
||||
|
||||
code, evmerr := self.Eval(msg, receiver.Init(), receiver) |
||||
if evmerr != nil { |
||||
self.state.Set(snapshot) |
||||
|
||||
statelogger.Debugf("Error during init execution %v", evmerr) |
||||
} |
||||
|
||||
receiver.Code = code |
||||
msg.Output = code |
||||
} else { |
||||
if len(receiver.Code) > 0 { |
||||
ret, evmerr := self.Eval(msg, receiver.Code, receiver) |
||||
if evmerr != nil { |
||||
self.state.Set(snapshot) |
||||
|
||||
statelogger.Debugf("Error during code execution %v", evmerr) |
||||
} |
||||
|
||||
msg.Output = ret |
||||
} else { |
||||
// Add default LOG. Default = big(sender.addr) + 1
|
||||
addr := ethutil.BigD(receiver.Address()) |
||||
self.state.AddLog(state.Log{sender.Address(), [][]byte{ethutil.U256(addr.Add(addr, ethutil.Big1)).Bytes()}, nil}) |
||||
} |
||||
} |
||||
|
||||
return |
||||
} |
||||
|
||||
func (self *StateTransition) Eval(msg *state.Message, script []byte, context *state.StateObject) (ret []byte, err error) { |
||||
var ( |
||||
transactor = self.Sender() |
||||
state = self.state |
||||
env = NewEnv(state, self.tx, self.block) |
||||
callerClosure = vm.NewClosure(msg, transactor, context, script, self.gas, self.gasPrice) |
||||
) |
||||
|
||||
evm := vm.New(env, vm.DebugVmTy) |
||||
ret, _, err = callerClosure.Call(evm, self.tx.Data) |
||||
|
||||
return |
||||
} |
||||
|
||||
// Converts an transaction in to a state object
|
||||
func MakeContract(tx *Transaction, state *state.State) *state.StateObject { |
||||
addr := tx.CreationAddress(state) |
||||
|
||||
contract := state.GetOrNewStateObject(addr) |
||||
contract.InitCode = tx.Data |
||||
|
||||
return contract |
||||
} |
||||
@ -1,271 +0,0 @@ |
||||
package chain |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"math/big" |
||||
|
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
"github.com/ethereum/go-ethereum/state" |
||||
"github.com/obscuren/secp256k1-go" |
||||
) |
||||
|
||||
var ContractAddr = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
||||
|
||||
func IsContractAddr(addr []byte) bool { |
||||
return len(addr) == 0 |
||||
//return bytes.Compare(addr, ContractAddr) == 0
|
||||
} |
||||
|
||||
type Transaction struct { |
||||
Nonce uint64 |
||||
Recipient []byte |
||||
Value *big.Int |
||||
Gas *big.Int |
||||
GasPrice *big.Int |
||||
Data []byte |
||||
v byte |
||||
r, s []byte |
||||
|
||||
// Indicates whether this tx is a contract creation transaction
|
||||
contractCreation bool |
||||
} |
||||
|
||||
func NewContractCreationTx(value, gas, gasPrice *big.Int, script []byte) *Transaction { |
||||
return &Transaction{Recipient: nil, Value: value, Gas: gas, GasPrice: gasPrice, Data: script, contractCreation: true} |
||||
} |
||||
|
||||
func NewTransactionMessage(to []byte, value, gas, gasPrice *big.Int, data []byte) *Transaction { |
||||
return &Transaction{Recipient: to, Value: value, GasPrice: gasPrice, Gas: gas, Data: data, contractCreation: IsContractAddr(to)} |
||||
} |
||||
|
||||
func NewTransactionFromBytes(data []byte) *Transaction { |
||||
tx := &Transaction{} |
||||
tx.RlpDecode(data) |
||||
|
||||
return tx |
||||
} |
||||
|
||||
func NewTransactionFromValue(val *ethutil.Value) *Transaction { |
||||
tx := &Transaction{} |
||||
tx.RlpValueDecode(val) |
||||
|
||||
return tx |
||||
} |
||||
|
||||
func (self *Transaction) GasValue() *big.Int { |
||||
return new(big.Int).Mul(self.Gas, self.GasPrice) |
||||
} |
||||
|
||||
func (self *Transaction) TotalValue() *big.Int { |
||||
v := self.GasValue() |
||||
return v.Add(v, self.Value) |
||||
} |
||||
|
||||
func (tx *Transaction) Hash() []byte { |
||||
data := []interface{}{tx.Nonce, tx.GasPrice, tx.Gas, tx.Recipient, tx.Value, tx.Data} |
||||
|
||||
return crypto.Sha3(ethutil.NewValue(data).Encode()) |
||||
} |
||||
|
||||
func (tx *Transaction) CreatesContract() bool { |
||||
return tx.contractCreation |
||||
} |
||||
|
||||
/* Deprecated */ |
||||
func (tx *Transaction) IsContract() bool { |
||||
return tx.CreatesContract() |
||||
} |
||||
|
||||
func (tx *Transaction) CreationAddress(state *state.State) []byte { |
||||
// Generate a new address
|
||||
addr := crypto.Sha3(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce}).Encode())[12:] |
||||
//for i := uint64(0); state.GetStateObject(addr) != nil; i++ {
|
||||
// addr = crypto.Sha3(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce + i}).Encode())[12:]
|
||||
//}
|
||||
|
||||
return addr |
||||
} |
||||
|
||||
func (tx *Transaction) Signature(key []byte) []byte { |
||||
hash := tx.Hash() |
||||
|
||||
sig, _ := secp256k1.Sign(hash, key) |
||||
|
||||
return sig |
||||
} |
||||
|
||||
func (tx *Transaction) PublicKey() []byte { |
||||
hash := tx.Hash() |
||||
|
||||
// TODO
|
||||
r := ethutil.LeftPadBytes(tx.r, 32) |
||||
s := ethutil.LeftPadBytes(tx.s, 32) |
||||
|
||||
sig := append(r, s...) |
||||
sig = append(sig, tx.v-27) |
||||
|
||||
pubkey := crypto.Ecrecover(append(hash, sig...)) |
||||
//pubkey, _ := secp256k1.RecoverPubkey(hash, sig)
|
||||
|
||||
return pubkey |
||||
} |
||||
|
||||
func (tx *Transaction) Sender() []byte { |
||||
pubkey := tx.PublicKey() |
||||
|
||||
// Validate the returned key.
|
||||
// Return nil if public key isn't in full format
|
||||
if pubkey[0] != 4 { |
||||
return nil |
||||
} |
||||
|
||||
return crypto.Sha3(pubkey[1:])[12:] |
||||
} |
||||
|
||||
func (tx *Transaction) Sign(privk []byte) error { |
||||
|
||||
sig := tx.Signature(privk) |
||||
|
||||
tx.r = sig[:32] |
||||
tx.s = sig[32:64] |
||||
tx.v = sig[64] + 27 |
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (tx *Transaction) RlpData() interface{} { |
||||
data := []interface{}{tx.Nonce, tx.GasPrice, tx.Gas, tx.Recipient, tx.Value, tx.Data} |
||||
|
||||
// TODO Remove prefixing zero's
|
||||
|
||||
return append(data, tx.v, new(big.Int).SetBytes(tx.r).Bytes(), new(big.Int).SetBytes(tx.s).Bytes()) |
||||
} |
||||
|
||||
func (tx *Transaction) RlpValue() *ethutil.Value { |
||||
return ethutil.NewValue(tx.RlpData()) |
||||
} |
||||
|
||||
func (tx *Transaction) RlpEncode() []byte { |
||||
return tx.RlpValue().Encode() |
||||
} |
||||
|
||||
func (tx *Transaction) RlpDecode(data []byte) { |
||||
tx.RlpValueDecode(ethutil.NewValueFromBytes(data)) |
||||
} |
||||
|
||||
func (tx *Transaction) RlpValueDecode(decoder *ethutil.Value) { |
||||
tx.Nonce = decoder.Get(0).Uint() |
||||
tx.GasPrice = decoder.Get(1).BigInt() |
||||
tx.Gas = decoder.Get(2).BigInt() |
||||
tx.Recipient = decoder.Get(3).Bytes() |
||||
tx.Value = decoder.Get(4).BigInt() |
||||
tx.Data = decoder.Get(5).Bytes() |
||||
tx.v = byte(decoder.Get(6).Uint()) |
||||
|
||||
tx.r = decoder.Get(7).Bytes() |
||||
tx.s = decoder.Get(8).Bytes() |
||||
|
||||
if IsContractAddr(tx.Recipient) { |
||||
tx.contractCreation = true |
||||
} |
||||
} |
||||
|
||||
func (tx *Transaction) String() string { |
||||
return fmt.Sprintf(` |
||||
TX(%x) |
||||
Contract: %v |
||||
From: %x |
||||
To: %x |
||||
Nonce: %v |
||||
GasPrice: %v |
||||
Gas: %v |
||||
Value: %v |
||||
Data: 0x%x |
||||
V: 0x%x |
||||
R: 0x%x |
||||
S: 0x%x |
||||
`, |
||||
tx.Hash(), |
||||
len(tx.Recipient) == 0, |
||||
tx.Sender(), |
||||
tx.Recipient, |
||||
tx.Nonce, |
||||
tx.GasPrice, |
||||
tx.Gas, |
||||
tx.Value, |
||||
tx.Data, |
||||
tx.v, |
||||
tx.r, |
||||
tx.s) |
||||
} |
||||
|
||||
type Receipt struct { |
||||
PostState []byte |
||||
CumulativeGasUsed *big.Int |
||||
Bloom []byte |
||||
logs state.Logs |
||||
} |
||||
|
||||
func NewRecieptFromValue(val *ethutil.Value) *Receipt { |
||||
r := &Receipt{} |
||||
r.RlpValueDecode(val) |
||||
|
||||
return r |
||||
} |
||||
|
||||
func (self *Receipt) RlpValueDecode(decoder *ethutil.Value) { |
||||
self.PostState = decoder.Get(0).Bytes() |
||||
self.CumulativeGasUsed = decoder.Get(1).BigInt() |
||||
self.Bloom = decoder.Get(2).Bytes() |
||||
|
||||
it := decoder.Get(3).NewIterator() |
||||
for it.Next() { |
||||
self.logs = append(self.logs, state.NewLogFromValue(it.Value())) |
||||
} |
||||
} |
||||
|
||||
func (self *Receipt) RlpData() interface{} { |
||||
return []interface{}{self.PostState, self.CumulativeGasUsed, self.Bloom, self.logs.RlpData()} |
||||
} |
||||
|
||||
func (self *Receipt) RlpEncode() []byte { |
||||
return ethutil.Encode(self.RlpData()) |
||||
} |
||||
|
||||
func (self *Receipt) Cmp(other *Receipt) bool { |
||||
if bytes.Compare(self.PostState, other.PostState) != 0 { |
||||
return false |
||||
} |
||||
|
||||
return true |
||||
} |
||||
|
||||
type Receipts []*Receipt |
||||
|
||||
func (self Receipts) Len() int { return len(self) } |
||||
func (self Receipts) GetRlp(i int) []byte { return ethutil.Rlp(self[i]) } |
||||
|
||||
// Transaction slice type for basic sorting
|
||||
type Transactions []*Transaction |
||||
|
||||
func (self Transactions) RlpData() interface{} { |
||||
// Marshal the transactions of this block
|
||||
enc := make([]interface{}, len(self)) |
||||
for i, tx := range self { |
||||
// Cast it to a string (safe)
|
||||
enc[i] = tx.RlpData() |
||||
} |
||||
|
||||
return enc |
||||
} |
||||
func (s Transactions) Len() int { return len(s) } |
||||
func (s Transactions) Swap(i, j int) { s[i], s[j] = s[j], s[i] } |
||||
func (s Transactions) GetRlp(i int) []byte { return ethutil.Rlp(s[i]) } |
||||
|
||||
type TxByNonce struct{ Transactions } |
||||
|
||||
func (s TxByNonce) Less(i, j int) bool { |
||||
return s.Transactions[i].Nonce < s.Transactions[j].Nonce |
||||
} |
||||
@ -1,245 +0,0 @@ |
||||
package chain |
||||
|
||||
import ( |
||||
"bytes" |
||||
"container/list" |
||||
"fmt" |
||||
"math/big" |
||||
"sync" |
||||
|
||||
"github.com/ethereum/go-ethereum/logger" |
||||
"github.com/ethereum/go-ethereum/state" |
||||
"github.com/ethereum/go-ethereum/wire" |
||||
) |
||||
|
||||
var txplogger = logger.NewLogger("TXP") |
||||
|
||||
const txPoolQueueSize = 50 |
||||
|
||||
type TxPoolHook chan *Transaction |
||||
type TxMsgTy byte |
||||
|
||||
const ( |
||||
minGasPrice = 1000000 |
||||
) |
||||
|
||||
var MinGasPrice = big.NewInt(10000000000000) |
||||
|
||||
type TxMsg struct { |
||||
Tx *Transaction |
||||
Type TxMsgTy |
||||
} |
||||
|
||||
func EachTx(pool *list.List, it func(*Transaction, *list.Element) bool) { |
||||
for e := pool.Front(); e != nil; e = e.Next() { |
||||
if it(e.Value.(*Transaction), e) { |
||||
break |
||||
} |
||||
} |
||||
} |
||||
|
||||
func FindTx(pool *list.List, finder func(*Transaction, *list.Element) bool) *Transaction { |
||||
for e := pool.Front(); e != nil; e = e.Next() { |
||||
if tx, ok := e.Value.(*Transaction); ok { |
||||
if finder(tx, e) { |
||||
return tx |
||||
} |
||||
} |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
type TxProcessor interface { |
||||
ProcessTransaction(tx *Transaction) |
||||
} |
||||
|
||||
// The tx pool a thread safe transaction pool handler. In order to
|
||||
// guarantee a non blocking pool we use a queue channel which can be
|
||||
// independently read without needing access to the actual pool. If the
|
||||
// pool is being drained or synced for whatever reason the transactions
|
||||
// will simple queue up and handled when the mutex is freed.
|
||||
type TxPool struct { |
||||
Ethereum EthManager |
||||
// The mutex for accessing the Tx pool.
|
||||
mutex sync.Mutex |
||||
// Queueing channel for reading and writing incoming
|
||||
// transactions to
|
||||
queueChan chan *Transaction |
||||
// Quiting channel
|
||||
quit chan bool |
||||
// The actual pool
|
||||
pool *list.List |
||||
|
||||
SecondaryProcessor TxProcessor |
||||
|
||||
subscribers []chan TxMsg |
||||
} |
||||
|
||||
func NewTxPool(ethereum EthManager) *TxPool { |
||||
return &TxPool{ |
||||
pool: list.New(), |
||||
queueChan: make(chan *Transaction, txPoolQueueSize), |
||||
quit: make(chan bool), |
||||
Ethereum: ethereum, |
||||
} |
||||
} |
||||
|
||||
// Blocking function. Don't use directly. Use QueueTransaction instead
|
||||
func (pool *TxPool) addTransaction(tx *Transaction) { |
||||
pool.mutex.Lock() |
||||
defer pool.mutex.Unlock() |
||||
|
||||
pool.pool.PushBack(tx) |
||||
|
||||
// Broadcast the transaction to the rest of the peers
|
||||
pool.Ethereum.Broadcast(wire.MsgTxTy, []interface{}{tx.RlpData()}) |
||||
} |
||||
|
||||
func (pool *TxPool) ValidateTransaction(tx *Transaction) error { |
||||
// Get the last block so we can retrieve the sender and receiver from
|
||||
// the merkle trie
|
||||
block := pool.Ethereum.ChainManager().CurrentBlock |
||||
// Something has gone horribly wrong if this happens
|
||||
if block == nil { |
||||
return fmt.Errorf("[TXPL] No last block on the block chain") |
||||
} |
||||
|
||||
if len(tx.Recipient) != 0 && len(tx.Recipient) != 20 { |
||||
return fmt.Errorf("[TXPL] Invalid recipient. len = %d", len(tx.Recipient)) |
||||
} |
||||
|
||||
if tx.GasPrice.Cmp(MinGasPrice) < 0 { |
||||
return fmt.Errorf("Gas price to low. Require %v > Got %v", MinGasPrice, tx.GasPrice) |
||||
} |
||||
|
||||
// Get the sender
|
||||
//sender := pool.Ethereum.BlockManager().procState.GetAccount(tx.Sender())
|
||||
sender := pool.Ethereum.BlockManager().CurrentState().GetAccount(tx.Sender()) |
||||
|
||||
totAmount := new(big.Int).Set(tx.Value) |
||||
// Make sure there's enough in the sender's account. Having insufficient
|
||||
// funds won't invalidate this transaction but simple ignores it.
|
||||
if sender.Balance().Cmp(totAmount) < 0 { |
||||
return fmt.Errorf("[TXPL] Insufficient amount in sender's (%x) account", tx.Sender()) |
||||
} |
||||
|
||||
if tx.IsContract() { |
||||
if tx.GasPrice.Cmp(big.NewInt(minGasPrice)) < 0 { |
||||
return fmt.Errorf("[TXPL] Gasprice too low, %s given should be at least %d.", tx.GasPrice, minGasPrice) |
||||
} |
||||
} |
||||
|
||||
// Increment the nonce making each tx valid only once to prevent replay
|
||||
// attacks
|
||||
|
||||
return nil |
||||
} |
||||
|
||||
func (pool *TxPool) queueHandler() { |
||||
out: |
||||
for { |
||||
select { |
||||
case tx := <-pool.queueChan: |
||||
hash := tx.Hash() |
||||
foundTx := FindTx(pool.pool, func(tx *Transaction, e *list.Element) bool { |
||||
return bytes.Compare(tx.Hash(), hash) == 0 |
||||
}) |
||||
|
||||
if foundTx != nil { |
||||
break |
||||
} |
||||
|
||||
// Validate the transaction
|
||||
err := pool.ValidateTransaction(tx) |
||||
if err != nil { |
||||
txplogger.Debugln("Validating Tx failed", err) |
||||
} else { |
||||
// Call blocking version.
|
||||
pool.addTransaction(tx) |
||||
|
||||
tmp := make([]byte, 4) |
||||
copy(tmp, tx.Recipient) |
||||
|
||||
txplogger.Debugf("(t) %x => %x (%v) %x\n", tx.Sender()[:4], tmp, tx.Value, tx.Hash()) |
||||
|
||||
// Notify the subscribers
|
||||
pool.Ethereum.EventMux().Post(TxPreEvent{tx}) |
||||
} |
||||
case <-pool.quit: |
||||
break out |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (pool *TxPool) QueueTransaction(tx *Transaction) { |
||||
pool.queueChan <- tx |
||||
} |
||||
|
||||
func (pool *TxPool) CurrentTransactions() []*Transaction { |
||||
pool.mutex.Lock() |
||||
defer pool.mutex.Unlock() |
||||
|
||||
txList := make([]*Transaction, pool.pool.Len()) |
||||
i := 0 |
||||
for e := pool.pool.Front(); e != nil; e = e.Next() { |
||||
tx := e.Value.(*Transaction) |
||||
|
||||
txList[i] = tx |
||||
|
||||
i++ |
||||
} |
||||
|
||||
return txList |
||||
} |
||||
|
||||
func (pool *TxPool) RemoveInvalid(state *state.State) { |
||||
pool.mutex.Lock() |
||||
defer pool.mutex.Unlock() |
||||
|
||||
for e := pool.pool.Front(); e != nil; e = e.Next() { |
||||
tx := e.Value.(*Transaction) |
||||
sender := state.GetAccount(tx.Sender()) |
||||
err := pool.ValidateTransaction(tx) |
||||
if err != nil || sender.Nonce >= tx.Nonce { |
||||
pool.pool.Remove(e) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (self *TxPool) RemoveSet(txs Transactions) { |
||||
self.mutex.Lock() |
||||
defer self.mutex.Unlock() |
||||
|
||||
for _, tx := range txs { |
||||
EachTx(self.pool, func(t *Transaction, element *list.Element) bool { |
||||
if t == tx { |
||||
self.pool.Remove(element) |
||||
return true // To stop the loop
|
||||
} |
||||
return false |
||||
}) |
||||
} |
||||
} |
||||
|
||||
func (pool *TxPool) Flush() []*Transaction { |
||||
txList := pool.CurrentTransactions() |
||||
|
||||
// Recreate a new list all together
|
||||
// XXX Is this the fastest way?
|
||||
pool.pool = list.New() |
||||
|
||||
return txList |
||||
} |
||||
|
||||
func (pool *TxPool) Start() { |
||||
go pool.queueHandler() |
||||
} |
||||
|
||||
func (pool *TxPool) Stop() { |
||||
close(pool.quit) |
||||
|
||||
pool.Flush() |
||||
|
||||
txplogger.Infoln("Stopped") |
||||
} |
||||
@ -1 +0,0 @@ |
||||
package chain |
||||
@ -1,39 +0,0 @@ |
||||
package chain |
||||
|
||||
import ( |
||||
"math/big" |
||||
|
||||
"github.com/ethereum/go-ethereum/state" |
||||
"github.com/ethereum/go-ethereum/vm" |
||||
) |
||||
|
||||
type VMEnv struct { |
||||
state *state.State |
||||
block *Block |
||||
tx *Transaction |
||||
} |
||||
|
||||
func NewEnv(state *state.State, tx *Transaction, block *Block) *VMEnv { |
||||
return &VMEnv{ |
||||
state: state, |
||||
block: block, |
||||
tx: tx, |
||||
} |
||||
} |
||||
|
||||
func (self *VMEnv) Origin() []byte { return self.tx.Sender() } |
||||
func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number } |
||||
func (self *VMEnv) PrevHash() []byte { return self.block.PrevHash } |
||||
func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase } |
||||
func (self *VMEnv) Time() int64 { return self.block.Time } |
||||
func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty } |
||||
func (self *VMEnv) BlockHash() []byte { return self.block.Hash() } |
||||
func (self *VMEnv) Value() *big.Int { return self.tx.Value } |
||||
func (self *VMEnv) State() *state.State { return self.state } |
||||
func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit } |
||||
func (self *VMEnv) AddLog(log state.Log) { |
||||
self.state.AddLog(log) |
||||
} |
||||
func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error { |
||||
return vm.Transfer(from, to, amount) |
||||
} |
||||
@ -0,0 +1,34 @@ |
||||
package main |
||||
|
||||
import ( |
||||
"fmt" |
||||
"io/ioutil" |
||||
"os" |
||||
|
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
"github.com/ethereum/go-ethereum/vm" |
||||
) |
||||
|
||||
func main() { |
||||
code, err := ioutil.ReadAll(os.Stdin) |
||||
if err != nil { |
||||
fmt.Println(err) |
||||
os.Exit(1) |
||||
} |
||||
code = ethutil.Hex2Bytes(string(code[:len(code)-1])) |
||||
fmt.Printf("%x\n", code) |
||||
|
||||
for pc := uint64(0); pc < uint64(len(code)); pc++ { |
||||
op := vm.OpCode(code[pc]) |
||||
fmt.Printf("%-5d %v", pc, op) |
||||
|
||||
switch op { |
||||
case vm.PUSH1, vm.PUSH2, vm.PUSH3, vm.PUSH4, vm.PUSH5, vm.PUSH6, vm.PUSH7, vm.PUSH8, vm.PUSH9, vm.PUSH10, vm.PUSH11, vm.PUSH12, vm.PUSH13, vm.PUSH14, vm.PUSH15, vm.PUSH16, vm.PUSH17, vm.PUSH18, vm.PUSH19, vm.PUSH20, vm.PUSH21, vm.PUSH22, vm.PUSH23, vm.PUSH24, vm.PUSH25, vm.PUSH26, vm.PUSH27, vm.PUSH28, vm.PUSH29, vm.PUSH30, vm.PUSH31, vm.PUSH32: |
||||
a := uint64(op) - uint64(vm.PUSH1) + 1 |
||||
fmt.Printf(" => %x", code[pc+1:pc+1+a]) |
||||
|
||||
pc += a |
||||
} |
||||
fmt.Println() |
||||
} |
||||
} |
||||
@ -0,0 +1,5 @@ |
||||
{ |
||||
"directory": "example/js/", |
||||
"cwd": "./", |
||||
"analytics": false |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
root = true |
||||
|
||||
[*] |
||||
indent_style = space |
||||
indent_size = 4 |
||||
end_of_line = lf |
||||
charset = utf-8 |
||||
trim_trailing_whitespace = true |
||||
insert_final_newline = true |
||||
|
||||
[*.md] |
||||
trim_trailing_whitespace = false |
||||
@ -0,0 +1,50 @@ |
||||
{ |
||||
"predef": [ |
||||
"console", |
||||
"require", |
||||
"equal", |
||||
"test", |
||||
"testBoth", |
||||
"testWithDefault", |
||||
"raises", |
||||
"deepEqual", |
||||
"start", |
||||
"stop", |
||||
"ok", |
||||
"strictEqual", |
||||
"module", |
||||
"expect", |
||||
"reject", |
||||
"impl" |
||||
], |
||||
|
||||
"esnext": true, |
||||
"proto": true, |
||||
"node" : true, |
||||
"browser" : true, |
||||
"browserify" : true, |
||||
|
||||
"boss" : true, |
||||
"curly": false, |
||||
"debug": true, |
||||
"devel": true, |
||||
"eqeqeq": true, |
||||
"evil": true, |
||||
"forin": false, |
||||
"immed": false, |
||||
"laxbreak": false, |
||||
"newcap": true, |
||||
"noarg": true, |
||||
"noempty": false, |
||||
"nonew": false, |
||||
"nomen": false, |
||||
"onevar": false, |
||||
"plusplus": false, |
||||
"regexp": false, |
||||
"undef": true, |
||||
"sub": true, |
||||
"strict": false, |
||||
"white": false, |
||||
"shadow": true, |
||||
"eqnull": true |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
example/js |
||||
node_modules |
||||
test |
||||
.gitignore |
||||
.editorconfig |
||||
.travis.yml |
||||
.npmignore |
||||
component.json |
||||
testling.html |
||||
@ -0,0 +1,11 @@ |
||||
language: node_js |
||||
node_js: |
||||
- "0.11" |
||||
- "0.10" |
||||
before_script: |
||||
- npm install |
||||
- npm install jshint |
||||
script: |
||||
- "jshint *.js lib" |
||||
after_script: |
||||
- npm run-script gulp |
||||
@ -0,0 +1 @@ |
||||
60006102ff5360003560001a60008114156103395760013560405260216040516020025990590160009052606052604051602002816060513760405160200281019050506002604051121561005957604051602002606051f35b604051602002599059016000905260a052600060c052604051602002599059016000905260e0526000610100526001610120525b604051610120511215610109576060515161012051602002606051015112156100d8576101205160200260605101516101005160200260e051015260016101005101610100526100f9565b61012051602002606051015160c05160200260a0510152600160c0510160c0525b600161012051016101205261008d565b60216020599059016000905260c051808252806020028301925050602082015990590160009052600081538151600182015260218101825160200260a0518260005b8381101561016657808301518186015260208101905061014b565b50505050825160200281019050604059905901600090526102405281610240515283602061024051015261024051905090509050905060c05160200280599059016000905281816020850151855160003060195a03f1508090509050905060a05260216020599059016000905261010051808252806020028301925050602082015990590160009052600081538151600182015260218101825160200260e0518260005b8381101561022557808301518186015260208101905061020a565b50505050825160200281019050604059905901600090526102c052816102c051528360206102c05101526102c05190509050905090506101005160200280599059016000905281816020850151855160003060195a03f1508090509050905060e05260405160200259905901600090526102e0526000610120525b610100516101205112156102d7576101205160200260e0510151610120516020026102e051015260016101205101610120526102a0565b60605151610100516020026102e05101526000610120525b60c05161012051121561032d576101205160200260a05101516101205160016101005101016020026102e051015260016101205101610120526102ef565b6040516020026102e051f35b50 |
||||
File diff suppressed because one or more lines are too long
@ -0,0 +1,165 @@ |
||||
/* |
||||
This file is part of go-ethereum |
||||
|
||||
go-ethereum is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 3 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
go-ethereum 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 General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
/** |
||||
* @authors |
||||
* Jeffrey Wilcke <i@jev.io> |
||||
*/ |
||||
|
||||
package main |
||||
|
||||
import ( |
||||
"flag" |
||||
"fmt" |
||||
"log" |
||||
"math/big" |
||||
"os" |
||||
"runtime" |
||||
"time" |
||||
|
||||
"github.com/ethereum/go-ethereum/core" |
||||
"github.com/ethereum/go-ethereum/core/types" |
||||
"github.com/ethereum/go-ethereum/ethdb" |
||||
"github.com/ethereum/go-ethereum/ethutil" |
||||
"github.com/ethereum/go-ethereum/logger" |
||||
"github.com/ethereum/go-ethereum/state" |
||||
"github.com/ethereum/go-ethereum/vm" |
||||
) |
||||
|
||||
var ( |
||||
code = flag.String("code", "", "evm code") |
||||
loglevel = flag.Int("log", 4, "log level") |
||||
gas = flag.String("gas", "1000000000", "gas amount") |
||||
price = flag.String("price", "0", "gas price") |
||||
value = flag.String("value", "0", "tx value") |
||||
dump = flag.Bool("dump", false, "dump state after run") |
||||
data = flag.String("data", "", "data") |
||||
) |
||||
|
||||
func perr(v ...interface{}) { |
||||
fmt.Println(v...) |
||||
//os.Exit(1)
|
||||
} |
||||
|
||||
func main() { |
||||
flag.Parse() |
||||
|
||||
logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.LogLevel(*loglevel))) |
||||
|
||||
ethutil.ReadConfig("/tmp/evmtest", "/tmp/evm", "") |
||||
|
||||
db, _ := ethdb.NewMemDatabase() |
||||
statedb := state.New(nil, db) |
||||
sender := statedb.NewStateObject([]byte("sender")) |
||||
receiver := statedb.NewStateObject([]byte("receiver")) |
||||
//receiver.SetCode([]byte(*code))
|
||||
receiver.SetCode(ethutil.Hex2Bytes(*code)) |
||||
|
||||
vmenv := NewEnv(statedb, []byte("evmuser"), ethutil.Big(*value)) |
||||
|
||||
tstart := time.Now() |
||||
|
||||
ret, e := vmenv.Call(sender, receiver.Address(), ethutil.Hex2Bytes(*data), ethutil.Big(*gas), ethutil.Big(*price), ethutil.Big(*value)) |
||||
|
||||
logger.Flush() |
||||
if e != nil { |
||||
perr(e) |
||||
} |
||||
|
||||
if *dump { |
||||
fmt.Println(string(statedb.Dump())) |
||||
} |
||||
|
||||
var mem runtime.MemStats |
||||
runtime.ReadMemStats(&mem) |
||||
fmt.Printf("vm took %v\n", time.Since(tstart)) |
||||
fmt.Printf(`alloc: %d |
||||
tot alloc: %d |
||||
no. malloc: %d |
||||
heap alloc: %d |
||||
heap objs: %d |
||||
num gc: %d |
||||
`, mem.Alloc, mem.TotalAlloc, mem.Mallocs, mem.HeapAlloc, mem.HeapObjects, mem.NumGC) |
||||
|
||||
fmt.Printf("%x\n", ret) |
||||
} |
||||
|
||||
type VMEnv struct { |
||||
state *state.StateDB |
||||
block *types.Block |
||||
|
||||
transactor []byte |
||||
value *big.Int |
||||
|
||||
depth int |
||||
Gas *big.Int |
||||
time int64 |
||||
} |
||||
|
||||
func NewEnv(state *state.StateDB, transactor []byte, value *big.Int) *VMEnv { |
||||
return &VMEnv{ |
||||
state: state, |
||||
transactor: transactor, |
||||
value: value, |
||||
time: time.Now().Unix(), |
||||
} |
||||
} |
||||
|
||||
func (self *VMEnv) State() *state.StateDB { return self.state } |
||||
func (self *VMEnv) Origin() []byte { return self.transactor } |
||||
func (self *VMEnv) BlockNumber() *big.Int { return ethutil.Big0 } |
||||
func (self *VMEnv) PrevHash() []byte { return make([]byte, 32) } |
||||
func (self *VMEnv) Coinbase() []byte { return self.transactor } |
||||
func (self *VMEnv) Time() int64 { return self.time } |
||||
func (self *VMEnv) Difficulty() *big.Int { return ethutil.Big1 } |
||||
func (self *VMEnv) BlockHash() []byte { return make([]byte, 32) } |
||||
func (self *VMEnv) Value() *big.Int { return self.value } |
||||
func (self *VMEnv) GasLimit() *big.Int { return big.NewInt(1000000000) } |
||||
func (self *VMEnv) Depth() int { return 0 } |
||||
func (self *VMEnv) SetDepth(i int) { self.depth = i } |
||||
func (self *VMEnv) GetHash(n uint64) []byte { |
||||
if self.block.Number().Cmp(big.NewInt(int64(n))) == 0 { |
||||
return self.block.Hash() |
||||
} |
||||
return nil |
||||
} |
||||
func (self *VMEnv) AddLog(log state.Log) { |
||||
self.state.AddLog(log) |
||||
} |
||||
func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error { |
||||
return vm.Transfer(from, to, amount) |
||||
} |
||||
|
||||
func (self *VMEnv) vm(addr, data []byte, gas, price, value *big.Int) *core.Execution { |
||||
return core.NewExecution(self, addr, data, gas, price, value) |
||||
} |
||||
|
||||
func (self *VMEnv) Call(caller vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) { |
||||
exe := self.vm(addr, data, gas, price, value) |
||||
ret, err := exe.Call(addr, caller) |
||||
self.Gas = exe.Gas |
||||
|
||||
return ret, err |
||||
} |
||||
func (self *VMEnv) CallCode(caller vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) { |
||||
exe := self.vm(caller.Address(), data, gas, price, value) |
||||
return exe.Call(addr, caller) |
||||
} |
||||
|
||||
func (self *VMEnv) Create(caller vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ContextRef) { |
||||
exe := self.vm(addr, data, gas, price, value) |
||||
return exe.Create(caller) |
||||
} |
||||
|
Before Width: | Height: | Size: 13 KiB After Width: | Height: | Size: 5.2 KiB |
@ -0,0 +1,55 @@ |
||||
<!doctype> |
||||
<html> |
||||
<head> |
||||
<title>Hello world</title> |
||||
<script src="../ext/bignumber.min.js"></script> |
||||
<script src="../ext/ethereum.js/dist/ethereum.js"></script> |
||||
<script> |
||||
var web3 = require('web3'); |
||||
web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080')); |
||||
var eth = web3.eth; |
||||
var desc = [{ |
||||
"name": "multiply(uint256)", |
||||
"inputs": [{ |
||||
"name": "a", |
||||
"type": "uint256" |
||||
}], |
||||
"outputs": [{ |
||||
"name": "d", |
||||
"type": "uint256" |
||||
}] |
||||
}]; |
||||
var address = web3.eth.transact({ |
||||
data: "0x603880600c6000396000f3006001600060e060020a600035048063c6888fa114601857005b6021600435602b565b8060005260206000f35b600081600702905091905056", |
||||
gasprice: "1000000000000000", |
||||
gas: "10000", |
||||
}); |
||||
var contract = web3.eth.contract(address, desc); |
||||
|
||||
function calculate() { |
||||
var param = parseInt(document.getElementById('value').value); |
||||
|
||||
var res = contract.call().multiply(param); |
||||
document.getElementById('result').innerText = res.toString(10); |
||||
} |
||||
</script> |
||||
</head> |
||||
<body> |
||||
<h3>Contract content</h3> |
||||
<textarea style="height:100px; width: 300px;" disabled="disabled"> |
||||
contract test { |
||||
function multiply(uint a) returns(uint d) { |
||||
return a * 7; |
||||
} |
||||
} |
||||
</textarea> |
||||
<code><pre> |
||||
603880600c6000396000f3006001600060e060020a600035048063c6888fa1140 |
||||
05b6021600435602b565b8060005260206000f35b600081600702905091905056</pre></code> |
||||
|
||||
<hr> |
||||
<div>7 x <input type="number" id="value" onkeyup='calculate()'></input> = |
||||
<span id="result"></spa> |
||||
|
||||
</body> |
||||
</html> |
||||
@ -0,0 +1,40 @@ |
||||
<!doctype> |
||||
<html> |
||||
|
||||
<head> |
||||
<script src="../ext/bignumber.min.js"></script> |
||||
<script src="../ext/ethereum.js/dist/ethereum.js"></script> |
||||
<script type="text/javascript"> |
||||
|
||||
var web3 = require('web3'); |
||||
web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080')); |
||||
|
||||
function watchBalance() { |
||||
var coinbase = web3.eth.coinbase; |
||||
var originalBalance = 0; |
||||
|
||||
var balance = web3.eth.balanceAt(coinbase); |
||||
var originalBalance = web3.toDecimal(balance); |
||||
document.getElementById('original').innerText = 'original balance: ' + originalBalance + ' watching...'; |
||||
|
||||
web3.eth.watch({altered: coinbase}).changed(function() { |
||||
balance = web3.eth.balanceAt(coinbase) |
||||
var currentBalance = web3.toDecimal(balance); |
||||
document.getElementById("current").innerText = 'current: ' + currentBalance; |
||||
document.getElementById("diff").innerText = 'diff: ' + (currentBalance - originalBalance); |
||||
}); |
||||
} |
||||
|
||||
</script> |
||||
</head> |
||||
<body> |
||||
<h1>coinbase balance</h1> |
||||
<button type="button" onClick="watchBalance();">watch balance</button> |
||||
<div></div> |
||||
<div id="original"></div> |
||||
<div id="current"></div> |
||||
<div id="diff"></div> |
||||
</body> |
||||
</html> |
||||
|
||||
|
||||
@ -0,0 +1,98 @@ |
||||
<!doctype> |
||||
<html> |
||||
<title>JevCoin</title> |
||||
<head> |
||||
<script type="text/javascript" src="../ext/bignumber.min.js"></script> |
||||
<script type="text/javascript" src="../ext/ethereum.js/dist/ethereum.js"></script> |
||||
</head> |
||||
<body> |
||||
|
||||
<h1>JevCoin</h1> |
||||
<div> |
||||
<strong>Balance</strong> |
||||
<span id="balance"></strong> |
||||
</div> |
||||
|
||||
<div> |
||||
<span class="amount">Amount:</span> |
||||
<input type="text" id="address" style="width:200px"> |
||||
<input type="text" id="amount" style="width:200px"> |
||||
<button onclick="transact()">Send</button> |
||||
</div> |
||||
|
||||
<table width="100%" id="table"> |
||||
</table> |
||||
|
||||
</body> |
||||
|
||||
<script type="text/javascript"> |
||||
var web3 = require('web3'); |
||||
var eth = web3.eth; |
||||
|
||||
web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080')); |
||||
var desc = [{ |
||||
"name": "balance(address)", |
||||
"inputs": [{ |
||||
"name": "who", |
||||
"type": "address" |
||||
}], |
||||
"const": true, |
||||
"outputs": [{ |
||||
"name": "value", |
||||
"type": "uint256" |
||||
}] |
||||
}, { |
||||
"name": "send(address,uint256)", |
||||
"inputs": [{ |
||||
"name": "to", |
||||
"type": "address" |
||||
}, { |
||||
"name": "value", |
||||
"type": "uint256" |
||||
}], |
||||
"outputs": [] |
||||
}]; |
||||
|
||||
var address = web3.db.get("jevcoin", "address"); |
||||
if( address.length == 0 ) { |
||||
var code = "0x60056011565b60ae8060356000396000f35b64174876e800600033600160a060020a031660005260205260406000208190555056006001600060e060020a600035048063d0679d34146022578063e3d670d714603457005b602e6004356024356047565b60006000f35b603d600435608d565b8060005260206000f35b80600083600160a060020a0316600052602052604060002090815401908190555080600033600160a060020a031660005260205260406000209081540390819055505050565b6000600082600160a060020a0316600052602052604060002054905091905056"; |
||||
address = web3.eth.transact({ |
||||
data: code, |
||||
gasprice: "1000000000000000", |
||||
gas: "10000", |
||||
}); |
||||
web3.db.put("jevcoin", "address", address); |
||||
} |
||||
|
||||
var contract = web3.eth.contract(address, desc); |
||||
|
||||
function reflesh() { |
||||
document.querySelector("#balance").innerHTML = contract.call().balance(eth.coinbase); |
||||
|
||||
var table = document.querySelector("#table"); |
||||
table.innerHTML = ""; // clear |
||||
|
||||
var storage = eth.storageAt(address); |
||||
for( var item in storage ) { |
||||
table.innerHTML += "<tr><td>"+item+"</td><td>"+web3.toDecimal(storage[item])+"</td></tr>"; |
||||
} |
||||
} |
||||
|
||||
function transact() { |
||||
var to = document.querySelector("#address").value; |
||||
if( to.length == 0 ) { |
||||
to = "0x4205b06c2cfa0e30359edcab94543266cb6fa1d3"; |
||||
} else { |
||||
to = "0x"+to; |
||||
} |
||||
|
||||
var value = parseInt( document.querySelector("#amount").value ); |
||||
|
||||
contract.transact({gas: "10000", gasprice: eth.gasPrice}).send( to, value ); |
||||
} |
||||
|
||||
reflesh(); |
||||
</script> |
||||
|
||||
</html> |
||||
|
||||
@ -0,0 +1,72 @@ |
||||
|
||||
<!doctype> |
||||
<html> |
||||
|
||||
<head> |
||||
<script type="text/javascript" src="../ext/bignumber.min.js"></script> |
||||
<script type="text/javascript" src="../ext/ethereum.js/dist/ethereum.js"></script> |
||||
</head> |
||||
<body> |
||||
<h1>Info</h1> |
||||
|
||||
<table width="100%"> |
||||
<tr> |
||||
<td>Block number</td> |
||||
<td id="number"></td> |
||||
</tr> |
||||
|
||||
<tr> |
||||
<td>Peer count</td> |
||||
<td id="peer_count"></td> |
||||
</tr> |
||||
|
||||
<tr> |
||||
<td>Default block</td> |
||||
<td id="default_block"></td> |
||||
</tr> |
||||
|
||||
<tr> |
||||
<td>Accounts</td> |
||||
<td id="accounts"></td> |
||||
</tr> |
||||
|
||||
<tr> |
||||
<td>Gas price</td> |
||||
<td id="gas_price"></td> |
||||
</tr> |
||||
|
||||
<tr> |
||||
<td>Mining</td> |
||||
<td id="mining"></td> |
||||
</tr> |
||||
|
||||
<tr> |
||||
<td>Listening</td> |
||||
<td id="listening"></td> |
||||
</tr> |
||||
|
||||
<tr> |
||||
<td>Coinbase</td> |
||||
<td id="coinbase"></td> |
||||
</tr> |
||||
</table> |
||||
</body> |
||||
|
||||
<script type="text/javascript"> |
||||
var web3 = require('web3'); |
||||
var eth = web3.eth; |
||||
|
||||
web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080')); |
||||
|
||||
document.querySelector("#number").innerHTML = eth.number; |
||||
document.querySelector("#coinbase").innerHTML = eth.coinbase |
||||
document.querySelector("#peer_count").innerHTML = eth.peerCount; |
||||
document.querySelector("#default_block").innerHTML = eth.defaultBlock; |
||||
document.querySelector("#accounts").innerHTML = eth.accounts; |
||||
document.querySelector("#gas_price").innerHTML = eth.gasPrice; |
||||
document.querySelector("#mining").innerHTML = eth.mining; |
||||
document.querySelector("#listening").innerHTML = eth.listening; |
||||
</script> |
||||
|
||||
</html> |
||||
|
||||
@ -0,0 +1,60 @@ |
||||
<!doctype> |
||||
<html> |
||||
<title>Whisper test</title> |
||||
<head> |
||||
<script type="text/javascript" src="../ext/bignumber.min.js"></script> |
||||
<script type="text/javascript" src="../ext/ethereum.js/dist/ethereum.js"></script> |
||||
</head> |
||||
<body> |
||||
|
||||
<h1>Whisper test</h1> |
||||
|
||||
<button onclick="test()">Send</button> |
||||
|
||||
<table width="100%" id="table"> |
||||
<tr> |
||||
<td>Count</td> |
||||
<td id="count"></td> |
||||
</tr> |
||||
|
||||
<tr> |
||||
<td>ID</td> |
||||
<td id="id"></td> |
||||
</tr> |
||||
|
||||
<tr> |
||||
<td>Has identity</td> |
||||
<td id="known"></td> |
||||
</tr> |
||||
</table> |
||||
</body> |
||||
|
||||
<script type="text/javascript"> |
||||
var web3 = require('web3'); |
||||
web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080')); |
||||
|
||||
var shh = web3.shh; |
||||
|
||||
var id = shh.newIdentity(); |
||||
document.querySelector("#id").innerHTML = id; |
||||
document.querySelector("#known").innerHTML = shh.haveIdentity(id); |
||||
|
||||
var watch = shh.watch({topics: ["test"]}) |
||||
watch.arrived(function(message) { |
||||
document.querySelector("#table").innerHTML += "<tr><td colspan='2'>"+JSON.stringify(message)+"</td></tr>"; |
||||
}); |
||||
|
||||
function test() { |
||||
shh.post({topics: ["test"], payload: web3.fromAscii("test it")}); |
||||
count(); |
||||
|
||||
} |
||||
|
||||
function count() { |
||||
document.querySelector("#count").innerHTML = watch.messages().length; |
||||
} |
||||
</script> |
||||
|
||||
</html> |
||||
|
||||
|
||||
@ -0,0 +1,5 @@ |
||||
{ |
||||
"directory": "example/js/", |
||||
"cwd": "./", |
||||
"analytics": false |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
root = true |
||||
|
||||
[*] |
||||
indent_style = space |
||||
indent_size = 4 |
||||
end_of_line = lf |
||||
charset = utf-8 |
||||
trim_trailing_whitespace = true |
||||
insert_final_newline = true |
||||
|
||||
[*.md] |
||||
trim_trailing_whitespace = false |
||||
@ -0,0 +1,50 @@ |
||||
{ |
||||
"predef": [ |
||||
"console", |
||||
"require", |
||||
"equal", |
||||
"test", |
||||
"testBoth", |
||||
"testWithDefault", |
||||
"raises", |
||||
"deepEqual", |
||||
"start", |
||||
"stop", |
||||
"ok", |
||||
"strictEqual", |
||||
"module", |
||||
"expect", |
||||
"reject", |
||||
"impl" |
||||
], |
||||
|
||||
"esnext": true, |
||||
"proto": true, |
||||
"node" : true, |
||||
"browser" : true, |
||||
"browserify" : true, |
||||
|
||||
"boss" : true, |
||||
"curly": false, |
||||
"debug": true, |
||||
"devel": true, |
||||
"eqeqeq": true, |
||||
"evil": true, |
||||
"forin": false, |
||||
"immed": false, |
||||
"laxbreak": false, |
||||
"newcap": true, |
||||
"noarg": true, |
||||
"noempty": false, |
||||
"nonew": false, |
||||
"nomen": false, |
||||
"onevar": false, |
||||
"plusplus": false, |
||||
"regexp": false, |
||||
"undef": true, |
||||
"sub": true, |
||||
"strict": false, |
||||
"white": false, |
||||
"shadow": true, |
||||
"eqnull": true |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
example/js |
||||
node_modules |
||||
test |
||||
.gitignore |
||||
.editorconfig |
||||
.travis.yml |
||||
.npmignore |
||||
component.json |
||||
testling.html |
||||
@ -0,0 +1,13 @@ |
||||
language: node_js |
||||
node_js: |
||||
- "0.11" |
||||
- "0.10" |
||||
before_script: |
||||
- npm install |
||||
- npm install jshint |
||||
script: |
||||
- "jshint *.js lib" |
||||
after_script: |
||||
- npm run-script build |
||||
- npm test |
||||
|
||||
@ -1,397 +0,0 @@ |
||||
// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2.1 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This 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
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||||
// MA 02110-1301 USA
|
||||
|
||||
var bigInt = (function () { |
||||
var base = 10000000, logBase = 7; |
||||
var sign = { |
||||
positive: false, |
||||
negative: true |
||||
}; |
||||
|
||||
var normalize = function (first, second) { |
||||
var a = first.value, b = second.value; |
||||
var length = a.length > b.length ? a.length : b.length; |
||||
for (var i = 0; i < length; i++) { |
||||
a[i] = a[i] || 0; |
||||
b[i] = b[i] || 0; |
||||
} |
||||
for (var i = length - 1; i >= 0; i--) { |
||||
if (a[i] === 0 && b[i] === 0) { |
||||
a.pop(); |
||||
b.pop(); |
||||
} else break; |
||||
} |
||||
if (!a.length) a = [0], b = [0]; |
||||
first.value = a; |
||||
second.value = b; |
||||
}; |
||||
|
||||
var parse = function (text, first) { |
||||
if (typeof text === "object") return text; |
||||
text += ""; |
||||
var s = sign.positive, value = []; |
||||
if (text[0] === "-") { |
||||
s = sign.negative; |
||||
text = text.slice(1); |
||||
} |
||||
var base = 10; |
||||
if (text.slice(0, 2) == "0x") { |
||||
base = 16; |
||||
text = text.slice(2); |
||||
} |
||||
else { |
||||
var texts = text.split("e"); |
||||
if (texts.length > 2) throw new Error("Invalid integer"); |
||||
if (texts[1]) { |
||||
var exp = texts[1]; |
||||
if (exp[0] === "+") exp = exp.slice(1); |
||||
exp = parse(exp); |
||||
if (exp.lesser(0)) throw new Error("Cannot include negative exponent part for integers"); |
||||
while (exp.notEquals(0)) { |
||||
texts[0] += "0"; |
||||
exp = exp.prev(); |
||||
} |
||||
} |
||||
text = texts[0]; |
||||
} |
||||
if (text === "-0") text = "0"; |
||||
text = text.toUpperCase(); |
||||
var isValid = (base == 16 ? /^[0-9A-F]*$/ : /^[0-9]+$/).test(text); |
||||
if (!isValid) throw new Error("Invalid integer"); |
||||
if (base == 16) { |
||||
var val = bigInt(0); |
||||
while (text.length) { |
||||
v = text.charCodeAt(0) - 48; |
||||
if (v > 9) |
||||
v -= 7; |
||||
text = text.slice(1); |
||||
val = val.times(16).plus(v); |
||||
} |
||||
return val; |
||||
} |
||||
else { |
||||
while (text.length) { |
||||
var divider = text.length > logBase ? text.length - logBase : 0; |
||||
value.push(+text.slice(divider)); |
||||
text = text.slice(0, divider); |
||||
} |
||||
var val = bigInt(value, s); |
||||
if (first) normalize(first, val); |
||||
return val; |
||||
} |
||||
}; |
||||
|
||||
var goesInto = function (a, b) { |
||||
var a = bigInt(a, sign.positive), b = bigInt(b, sign.positive); |
||||
if (a.equals(0)) throw new Error("Cannot divide by 0"); |
||||
var n = 0; |
||||
do { |
||||
var inc = 1; |
||||
var c = bigInt(a.value, sign.positive), t = c.times(10); |
||||
while (t.lesser(b)) { |
||||
c = t; |
||||
inc *= 10; |
||||
t = t.times(10); |
||||
} |
||||
while (c.lesserOrEquals(b)) { |
||||
b = b.minus(c); |
||||
n += inc; |
||||
} |
||||
} while (a.lesserOrEquals(b)); |
||||
|
||||
return { |
||||
remainder: b.value, |
||||
result: n |
||||
}; |
||||
}; |
||||
|
||||
var bigInt = function (value, s) { |
||||
var self = { |
||||
value: value, |
||||
sign: s |
||||
}; |
||||
var o = { |
||||
value: value, |
||||
sign: s, |
||||
negate: function (m) { |
||||
var first = m || self; |
||||
return bigInt(first.value, !first.sign); |
||||
}, |
||||
abs: function (m) { |
||||
var first = m || self; |
||||
return bigInt(first.value, sign.positive); |
||||
}, |
||||
add: function (n, m) { |
||||
var s, first = self, second; |
||||
if (m) (first = parse(n)) && (second = parse(m)); |
||||
else second = parse(n, first); |
||||
s = first.sign; |
||||
if (first.sign !== second.sign) { |
||||
first = bigInt(first.value, sign.positive); |
||||
second = bigInt(second.value, sign.positive); |
||||
return s === sign.positive ? |
||||
o.subtract(first, second) : |
||||
o.subtract(second, first); |
||||
} |
||||
normalize(first, second); |
||||
var a = first.value, b = second.value; |
||||
var result = [], |
||||
carry = 0; |
||||
for (var i = 0; i < a.length || carry > 0; i++) { |
||||
var sum = (a[i] || 0) + (b[i] || 0) + carry; |
||||
carry = sum >= base ? 1 : 0; |
||||
sum -= carry * base; |
||||
result.push(sum); |
||||
} |
||||
return bigInt(result, s); |
||||
}, |
||||
plus: function (n, m) { |
||||
return o.add(n, m); |
||||
}, |
||||
subtract: function (n, m) { |
||||
var first = self, second; |
||||
if (m) (first = parse(n)) && (second = parse(m)); |
||||
else second = parse(n, first); |
||||
if (first.sign !== second.sign) return o.add(first, o.negate(second)); |
||||
if (first.sign === sign.negative) return o.subtract(o.negate(second), o.negate(first)); |
||||
if (o.compare(first, second) === -1) return o.negate(o.subtract(second, first)); |
||||
var a = first.value, b = second.value; |
||||
var result = [], |
||||
borrow = 0; |
||||
for (var i = 0; i < a.length; i++) { |
||||
var tmp = a[i] - borrow; |
||||
borrow = tmp < b[i] ? 1 : 0; |
||||
var minuend = (borrow * base) + tmp - b[i]; |
||||
result.push(minuend); |
||||
} |
||||
return bigInt(result, sign.positive); |
||||
}, |
||||
minus: function (n, m) { |
||||
return o.subtract(n, m); |
||||
}, |
||||
multiply: function (n, m) { |
||||
var s, first = self, second; |
||||
if (m) (first = parse(n)) && (second = parse(m)); |
||||
else second = parse(n, first); |
||||
s = first.sign !== second.sign; |
||||
var a = first.value, b = second.value; |
||||
var resultSum = []; |
||||
for (var i = 0; i < a.length; i++) { |
||||
resultSum[i] = []; |
||||
var j = i; |
||||
while (j--) { |
||||
resultSum[i].push(0); |
||||
} |
||||
} |
||||
var carry = 0; |
||||
for (var i = 0; i < a.length; i++) { |
||||
var x = a[i]; |
||||
for (var j = 0; j < b.length || carry > 0; j++) { |
||||
var y = b[j]; |
||||
var product = y ? (x * y) + carry : carry; |
||||
carry = product > base ? Math.floor(product / base) : 0; |
||||
product -= carry * base; |
||||
resultSum[i].push(product); |
||||
} |
||||
} |
||||
var max = -1; |
||||
for (var i = 0; i < resultSum.length; i++) { |
||||
var len = resultSum[i].length; |
||||
if (len > max) max = len; |
||||
} |
||||
var result = [], carry = 0; |
||||
for (var i = 0; i < max || carry > 0; i++) { |
||||
var sum = carry; |
||||
for (var j = 0; j < resultSum.length; j++) { |
||||
sum += resultSum[j][i] || 0; |
||||
} |
||||
carry = sum > base ? Math.floor(sum / base) : 0; |
||||
sum -= carry * base; |
||||
result.push(sum); |
||||
} |
||||
return bigInt(result, s); |
||||
}, |
||||
times: function (n, m) { |
||||
return o.multiply(n, m); |
||||
}, |
||||
divmod: function (n, m) { |
||||
var s, first = self, second; |
||||
if (m) (first = parse(n)) && (second = parse(m)); |
||||
else second = parse(n, first); |
||||
s = first.sign !== second.sign; |
||||
if (bigInt(first.value, first.sign).equals(0)) return { |
||||
quotient: bigInt([0], sign.positive), |
||||
remainder: bigInt([0], sign.positive) |
||||
}; |
||||
if (second.equals(0)) throw new Error("Cannot divide by zero"); |
||||
var a = first.value, b = second.value; |
||||
var result = [], remainder = []; |
||||
for (var i = a.length - 1; i >= 0; i--) { |
||||
var n = [a[i]].concat(remainder); |
||||
var quotient = goesInto(b, n); |
||||
result.push(quotient.result); |
||||
remainder = quotient.remainder; |
||||
} |
||||
result.reverse(); |
||||
return { |
||||
quotient: bigInt(result, s), |
||||
remainder: bigInt(remainder, first.sign) |
||||
}; |
||||
}, |
||||
divide: function (n, m) { |
||||
return o.divmod(n, m).quotient; |
||||
}, |
||||
over: function (n, m) { |
||||
return o.divide(n, m); |
||||
}, |
||||
mod: function (n, m) { |
||||
return o.divmod(n, m).remainder; |
||||
}, |
||||
pow: function (n, m) { |
||||
var first = self, second; |
||||
if (m) (first = parse(n)) && (second = parse(m)); |
||||
else second = parse(n, first); |
||||
var a = first, b = second; |
||||
if (b.lesser(0)) return ZERO; |
||||
if (b.equals(0)) return ONE; |
||||
var result = bigInt(a.value, a.sign); |
||||
|
||||
if (b.mod(2).equals(0)) { |
||||
var c = result.pow(b.over(2)); |
||||
return c.times(c); |
||||
} else { |
||||
return result.times(result.pow(b.minus(1))); |
||||
} |
||||
}, |
||||
next: function (m) { |
||||
var first = m || self; |
||||
return o.add(first, 1); |
||||
}, |
||||
prev: function (m) { |
||||
var first = m || self; |
||||
return o.subtract(first, 1); |
||||
}, |
||||
compare: function (n, m) { |
||||
var first = self, second; |
||||
if (m) (first = parse(n)) && (second = parse(m, first)); |
||||
else second = parse(n, first); |
||||
normalize(first, second); |
||||
if (first.value.length === 1 && second.value.length === 1 && first.value[0] === 0 && second.value[0] === 0) return 0; |
||||
if (second.sign !== first.sign) return first.sign === sign.positive ? 1 : -1; |
||||
var multiplier = first.sign === sign.positive ? 1 : -1; |
||||
var a = first.value, b = second.value; |
||||
for (var i = a.length - 1; i >= 0; i--) { |
||||
if (a[i] > b[i]) return 1 * multiplier; |
||||
if (b[i] > a[i]) return -1 * multiplier; |
||||
} |
||||
return 0; |
||||
}, |
||||
compareAbs: function (n, m) { |
||||
var first = self, second; |
||||
if (m) (first = parse(n)) && (second = parse(m, first)); |
||||
else second = parse(n, first); |
||||
first.sign = second.sign = sign.positive; |
||||
return o.compare(first, second); |
||||
}, |
||||
equals: function (n, m) { |
||||
return o.compare(n, m) === 0; |
||||
}, |
||||
notEquals: function (n, m) { |
||||
return !o.equals(n, m); |
||||
}, |
||||
lesser: function (n, m) { |
||||
return o.compare(n, m) < 0; |
||||
}, |
||||
greater: function (n, m) { |
||||
return o.compare(n, m) > 0; |
||||
}, |
||||
greaterOrEquals: function (n, m) { |
||||
return o.compare(n, m) >= 0; |
||||
}, |
||||
lesserOrEquals: function (n, m) { |
||||
return o.compare(n, m) <= 0; |
||||
}, |
||||
isPositive: function (m) { |
||||
var first = m || self; |
||||
return first.sign === sign.positive; |
||||
}, |
||||
isNegative: function (m) { |
||||
var first = m || self; |
||||
return first.sign === sign.negative; |
||||
}, |
||||
isEven: function (m) { |
||||
var first = m || self; |
||||
return first.value[0] % 2 === 0; |
||||
}, |
||||
isOdd: function (m) { |
||||
var first = m || self; |
||||
return first.value[0] % 2 === 1; |
||||
}, |
||||
toString: function (m) { |
||||
var first = m || self; |
||||
var str = "", len = first.value.length; |
||||
while (len--) { |
||||
if (first.value[len].toString().length === 8) str += first.value[len]; |
||||
else str += (base.toString() + first.value[len]).slice(-logBase); |
||||
} |
||||
while (str[0] === "0") { |
||||
str = str.slice(1); |
||||
} |
||||
if (!str.length) str = "0"; |
||||
var s = (first.sign === sign.positive || str == "0") ? "" : "-"; |
||||
return s + str; |
||||
}, |
||||
toHex: function (m) { |
||||
var first = m || self; |
||||
var str = ""; |
||||
var l = this.abs(); |
||||
while (l > 0) { |
||||
var qr = l.divmod(256); |
||||
var b = qr.remainder.toJSNumber(); |
||||
str = (b >> 4).toString(16) + (b & 15).toString(16) + str; |
||||
l = qr.quotient; |
||||
} |
||||
return (this.isNegative() ? "-" : "") + "0x" + str; |
||||
}, |
||||
toJSNumber: function (m) { |
||||
return +o.toString(m); |
||||
}, |
||||
valueOf: function (m) { |
||||
return o.toJSNumber(m); |
||||
} |
||||
}; |
||||
return o; |
||||
}; |
||||
|
||||
var ZERO = bigInt([0], sign.positive); |
||||
var ONE = bigInt([1], sign.positive); |
||||
var MINUS_ONE = bigInt([1], sign.negative); |
||||
|
||||
var fnReturn = function (a) { |
||||
if (typeof a === "undefined") return ZERO; |
||||
return parse(a); |
||||
}; |
||||
fnReturn.zero = ZERO; |
||||
fnReturn.one = ONE; |
||||
fnReturn.minusOne = MINUS_ONE; |
||||
return fnReturn; |
||||
})(); |
||||
|
||||
if (typeof module !== "undefined") { |
||||
module.exports = bigInt; |
||||
} |
||||
|
||||
File diff suppressed because one or more lines are too long
@ -1,18 +0,0 @@ |
||||
# Ethereum JavaScript API |
||||
|
||||
This is the Ethereum compatible JavaScript API using `Promise`s |
||||
which implements the [Generic JSON RPC](https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC) spec. |
||||
|
||||
For an example see `index.html`. |
||||
|
||||
**Please note this repo is in it's early stage.** |
||||
|
||||
If you'd like to run a WebSocket ethereum node check out |
||||
[go-ethereum](https://github.com/ethereum/go-ethereum). |
||||
|
||||
To install ethereum and spawn a node: |
||||
|
||||
``` |
||||
go get github.com/ethereum/go-ethereum/ethereum |
||||
ethereum -ws -loglevel=4 |
||||
``` |
||||
@ -1,70 +0,0 @@ |
||||
(function () { |
||||
var HttpRpcProvider = function (host) { |
||||
this.handlers = []; |
||||
this.host = host; |
||||
}; |
||||
|
||||
function formatJsonRpcObject(object) { |
||||
return { |
||||
jsonrpc: '2.0', |
||||
method: object.call, |
||||
params: object.args, |
||||
id: object._id |
||||
} |
||||
}; |
||||
|
||||
function formatJsonRpcMessage(message) {
|
||||
var object = JSON.parse(message); |
||||
|
||||
return { |
||||
_id: object.id, |
||||
data: object.result |
||||
}; |
||||
}; |
||||
|
||||
HttpRpcProvider.prototype.sendRequest = function (payload, cb) { |
||||
var data = formatJsonRpcObject(payload); |
||||
|
||||
var request = new XMLHttpRequest(); |
||||
request.open("POST", this.host, true); |
||||
request.send(JSON.stringify(data)); |
||||
request.onreadystatechange = function () { |
||||
if (request.readyState === 4 && cb) { |
||||
cb(request); |
||||
} |
||||
} |
||||
}; |
||||
|
||||
HttpRpcProvider.prototype.send = function (payload) { |
||||
var self = this; |
||||
this.sendRequest(payload, function (request) { |
||||
self.handlers.forEach(function (handler) { |
||||
handler.call(self, formatJsonRpcMessage(request.responseText)); |
||||
}); |
||||
}); |
||||
}; |
||||
|
||||
HttpRpcProvider.prototype.poll = function (payload, id) { |
||||
var self = this; |
||||
this.sendRequest(payload, function (request) { |
||||
var parsed = JSON.parse(request.responseText); |
||||
if (parsed.result instanceof Array ? parsed.result.length === 0 : !parsed.result) { |
||||
return; |
||||
} |
||||
self.handlers.forEach(function (handler) { |
||||
handler.call(self, {_event: payload.call, _id: id, data: parsed.result}); |
||||
}); |
||||
}); |
||||
}; |
||||
|
||||
Object.defineProperty(HttpRpcProvider.prototype, "onmessage", { |
||||
set: function (handler) { |
||||
this.handlers.push(handler); |
||||
} |
||||
}); |
||||
|
||||
if (typeof(web3) !== "undefined" && web3.providers !== undefined) { |
||||
web3.providers.HttpRpcProvider = HttpRpcProvider; |
||||
} |
||||
})(); |
||||
|
||||
@ -1,33 +0,0 @@ |
||||
<!doctype> |
||||
<html> |
||||
|
||||
<head> |
||||
<script type="text/javascript" src="main.js"></script> |
||||
<script type="text/javascript" src="websocket.js"></script> |
||||
<script type="text/javascript" src="qt.js"></script> |
||||
<script type="text/javascript" src="httprpc.js"></script> |
||||
<script type="text/javascript"> |
||||
function registerName() { |
||||
var name = document.querySelector("#name").value; |
||||
name = web3.fromAscii(name); |
||||
|
||||
var eth = web3.eth; |
||||
eth.transact({to: "NameReg", gas: "10000", gasPrice: eth.gasPrice, data: [web3.fromAscii("register"), name]}).then(function(tx) { |
||||
document.querySelector("#result").innerHTML = "Registered name. Please wait for the next block to come through."; |
||||
}, function(err) { |
||||
console.log(err); |
||||
}); |
||||
} |
||||
</script> |
||||
</head> |
||||
|
||||
<body> |
||||
|
||||
<h1>std::name_reg</h1> |
||||
<input type="text" id="name"></input> |
||||
<input type="submit" onClick="registerName();"></input> |
||||
<div id="result"></div> |
||||
|
||||
</body> |
||||
|
||||
</html> |
||||
@ -1,432 +0,0 @@ |
||||
(function(window) { |
||||
function isPromise(o) { |
||||
return o instanceof Promise |
||||
} |
||||
|
||||
function flattenPromise (obj) { |
||||
if (obj instanceof Promise) { |
||||
return Promise.resolve(obj); |
||||
} |
||||
|
||||
if (obj instanceof Array) { |
||||
return new Promise(function (resolve) { |
||||
var promises = obj.map(function (o) { |
||||
return flattenPromise(o); |
||||
}); |
||||
|
||||
return Promise.all(promises).then(function (res) { |
||||
for (var i = 0; i < obj.length; i++) { |
||||
obj[i] = res[i]; |
||||
} |
||||
resolve(obj); |
||||
}); |
||||
}); |
||||
} |
||||
|
||||
if (obj instanceof Object) { |
||||
return new Promise(function (resolve) { |
||||
var keys = Object.keys(obj); |
||||
var promises = keys.map(function (key) { |
||||
return flattenPromise(obj[key]); |
||||
}); |
||||
|
||||
return Promise.all(promises).then(function (res) { |
||||
for (var i = 0; i < keys.length; i++) { |
||||
obj[keys[i]] = res[i]; |
||||
} |
||||
resolve(obj); |
||||
}); |
||||
}); |
||||
} |
||||
|
||||
return Promise.resolve(obj); |
||||
}; |
||||
|
||||
var ethMethods = function () { |
||||
var blockCall = function (args) { |
||||
return typeof args[0] === "string" ? "blockByHash" : "blockByNumber"; |
||||
}; |
||||
|
||||
var transactionCall = function (args) { |
||||
return typeof args[0] === "string" ? 'transactionByHash' : 'transactionByNumber';
|
||||
}; |
||||
|
||||
var uncleCall = function (args) { |
||||
return typeof args[0] === "string" ? 'uncleByHash' : 'uncleByNumber';
|
||||
}; |
||||
|
||||
var methods = [ |
||||
{ name: 'balanceAt', call: 'balanceAt' }, |
||||
{ name: 'stateAt', call: 'stateAt' }, |
||||
{ name: 'countAt', call: 'countAt'}, |
||||
{ name: 'codeAt', call: 'codeAt' }, |
||||
{ name: 'transact', call: 'transact' }, |
||||
{ name: 'call', call: 'call' }, |
||||
{ name: 'block', call: blockCall }, |
||||
{ name: 'transaction', call: transactionCall }, |
||||
{ name: 'uncle', call: uncleCall }, |
||||
{ name: 'compile', call: 'compile' } |
||||
]; |
||||
return methods; |
||||
}; |
||||
|
||||
var ethProperties = function () { |
||||
return [ |
||||
{ name: 'coinbase', getter: 'coinbase', setter: 'setCoinbase' }, |
||||
{ name: 'listening', getter: 'listening', setter: 'setListening' }, |
||||
{ name: 'mining', getter: 'mining', setter: 'setMining' }, |
||||
{ name: 'gasPrice', getter: 'gasPrice' }, |
||||
{ name: 'account', getter: 'account' }, |
||||
{ name: 'accounts', getter: 'accounts' }, |
||||
{ name: 'peerCount', getter: 'peerCount' }, |
||||
{ name: 'defaultBlock', getter: 'defaultBlock', setter: 'setDefaultBlock' }, |
||||
{ name: 'number', getter: 'number'} |
||||
]; |
||||
}; |
||||
|
||||
var dbMethods = function () { |
||||
return [ |
||||
{ name: 'put', call: 'put' }, |
||||
{ name: 'get', call: 'get' }, |
||||
{ name: 'putString', call: 'putString' }, |
||||
{ name: 'getString', call: 'getString' } |
||||
]; |
||||
}; |
||||
|
||||
var shhMethods = function () { |
||||
return [ |
||||
{ name: 'post', call: 'post' }, |
||||
{ name: 'newIdentity', call: 'newIdentity' }, |
||||
{ name: 'haveIdentity', call: 'haveIdentity' }, |
||||
{ name: 'newGroup', call: 'newGroup' }, |
||||
{ name: 'addToGroup', call: 'addToGroup' } |
||||
]; |
||||
}; |
||||
|
||||
var ethWatchMethods = function () { |
||||
var newFilter = function (args) { |
||||
return typeof args[0] === 'string' ? 'newFilterString' : 'newFilter'; |
||||
}; |
||||
|
||||
return [ |
||||
{ name: 'newFilter', call: newFilter }, |
||||
{ name: 'uninstallFilter', call: 'uninstallFilter' }, |
||||
{ name: 'getMessages', call: 'getMessages' } |
||||
]; |
||||
}; |
||||
|
||||
var shhWatchMethods = function () { |
||||
return [ |
||||
{ name: 'newFilter', call: 'shhNewFilter' }, |
||||
{ name: 'uninstallFilter', call: 'shhUninstallFilter' }, |
||||
{ name: 'getMessage', call: 'shhGetMessages' } |
||||
]; |
||||
}; |
||||
|
||||
var setupMethods = function (obj, methods) { |
||||
methods.forEach(function (method) { |
||||
obj[method.name] = function () { |
||||
return flattenPromise(Array.prototype.slice.call(arguments)).then(function (args) { |
||||
var call = typeof method.call === "function" ? method.call(args) : method.call;
|
||||
return {call: call, args: args}; |
||||
}).then(function (request) { |
||||
return new Promise(function (resolve, reject) { |
||||
web3.provider.send(request, function (result) { |
||||
//if (result || typeof result === "boolean") {
|
||||
resolve(result); |
||||
return; |
||||
//}
|
||||
//reject(result);
|
||||
}); |
||||
}); |
||||
}).catch(function( err) { |
||||
console.error(err); |
||||
}); |
||||
}; |
||||
}); |
||||
}; |
||||
|
||||
var setupProperties = function (obj, properties) { |
||||
properties.forEach(function (property) { |
||||
var proto = {}; |
||||
proto.get = function () { |
||||
return new Promise(function(resolve, reject) { |
||||
web3.provider.send({call: property.getter}, function(result) { |
||||
resolve(result); |
||||
}); |
||||
}); |
||||
}; |
||||
if (property.setter) { |
||||
proto.set = function (val) { |
||||
return flattenPromise([val]).then(function (args) { |
||||
return new Promise(function (resolve) { |
||||
web3.provider.send({call: property.setter, args: args}, function (result) { |
||||
resolve(result); |
||||
}); |
||||
}); |
||||
}).catch(function (err) { |
||||
console.error(err); |
||||
}); |
||||
} |
||||
} |
||||
Object.defineProperty(obj, property.name, proto); |
||||
}); |
||||
}; |
||||
|
||||
var web3 = { |
||||
_callbacks: {}, |
||||
_events: {}, |
||||
providers: {}, |
||||
toHex: function(str) { |
||||
var hex = ""; |
||||
for(var i = 0; i < str.length; i++) { |
||||
var n = str.charCodeAt(i).toString(16); |
||||
hex += n.length < 2 ? '0' + n : n; |
||||
} |
||||
|
||||
return hex; |
||||
}, |
||||
|
||||
toAscii: function(hex) { |
||||
// Find termination
|
||||
var str = ""; |
||||
var i = 0, l = hex.length; |
||||
for(; i < l; i+=2) { |
||||
var code = hex.charCodeAt(i) |
||||
if(code == 0) { |
||||
break; |
||||
} |
||||
|
||||
str += String.fromCharCode(parseInt(hex.substr(i, 2), 16)); |
||||
} |
||||
|
||||
return str; |
||||
}, |
||||
|
||||
toDecimal: function (val) { |
||||
return parseInt(val, 16);
|
||||
}, |
||||
|
||||
fromAscii: function(str, pad) { |
||||
pad = pad === undefined ? 32 : pad; |
||||
var hex = this.toHex(str); |
||||
while(hex.length < pad*2) |
||||
hex += "00"; |
||||
return hex |
||||
}, |
||||
|
||||
eth: { |
||||
prototype: Object(), |
||||
watch: function (params) { |
||||
return new Filter(params, ethWatch); |
||||
}, |
||||
}, |
||||
|
||||
db: { |
||||
prototype: Object() |
||||
}, |
||||
|
||||
shh: { |
||||
prototype: Object(), |
||||
watch: function (params) { |
||||
return new Filter(params, shhWatch); |
||||
} |
||||
}, |
||||
|
||||
on: function(event, id, cb) { |
||||
if(web3._events[event] === undefined) { |
||||
web3._events[event] = {}; |
||||
} |
||||
|
||||
web3._events[event][id] = cb; |
||||
return this |
||||
}, |
||||
|
||||
off: function(event, id) { |
||||
if(web3._events[event] !== undefined) { |
||||
delete web3._events[event][id]; |
||||
} |
||||
|
||||
return this |
||||
}, |
||||
|
||||
trigger: function(event, id, data) { |
||||
var callbacks = web3._events[event]; |
||||
if (!callbacks || !callbacks[id]) { |
||||
return; |
||||
} |
||||
var cb = callbacks[id]; |
||||
cb(data); |
||||
}, |
||||
}; |
||||
|
||||
var eth = web3.eth; |
||||
setupMethods(eth, ethMethods()); |
||||
setupProperties(eth, ethProperties()); |
||||
setupMethods(web3.db, dbMethods()); |
||||
setupMethods(web3.shh, shhMethods()); |
||||
|
||||
var ethWatch = { |
||||
changed: 'changed' |
||||
}; |
||||
setupMethods(ethWatch, ethWatchMethods()); |
||||
var shhWatch = { |
||||
changed: 'shhChanged' |
||||
}; |
||||
setupMethods(shhWatch, shhWatchMethods()); |
||||
|
||||
var ProviderManager = function() { |
||||
this.queued = []; |
||||
this.polls = []; |
||||
this.ready = false; |
||||
this.provider = undefined; |
||||
this.id = 1; |
||||
|
||||
var self = this; |
||||
var poll = function () { |
||||
if (self.provider && self.provider.poll) { |
||||
self.polls.forEach(function (data) { |
||||
data.data._id = self.id;
|
||||
self.id++; |
||||
self.provider.poll(data.data, data.id); |
||||
}); |
||||
} |
||||
setTimeout(poll, 12000); |
||||
}; |
||||
poll(); |
||||
}; |
||||
|
||||
ProviderManager.prototype.send = function(data, cb) { |
||||
data._id = this.id; |
||||
if (cb) { |
||||
web3._callbacks[data._id] = cb; |
||||
} |
||||
|
||||
data.args = data.args || []; |
||||
this.id++; |
||||
|
||||
if(this.provider !== undefined) { |
||||
this.provider.send(data); |
||||
} else { |
||||
console.warn("provider is not set"); |
||||
this.queued.push(data); |
||||
} |
||||
}; |
||||
|
||||
ProviderManager.prototype.set = function(provider) { |
||||
if(this.provider !== undefined && this.provider.unload !== undefined) { |
||||
this.provider.unload(); |
||||
} |
||||
|
||||
this.provider = provider; |
||||
this.ready = true; |
||||
}; |
||||
|
||||
ProviderManager.prototype.sendQueued = function() { |
||||
for(var i = 0; this.queued.length; i++) { |
||||
// Resend
|
||||
this.send(this.queued[i]); |
||||
} |
||||
}; |
||||
|
||||
ProviderManager.prototype.installed = function() { |
||||
return this.provider !== undefined; |
||||
}; |
||||
|
||||
ProviderManager.prototype.startPolling = function (data, pollId) { |
||||
if (!this.provider || !this.provider.poll) { |
||||
return; |
||||
} |
||||
this.polls.push({data: data, id: pollId}); |
||||
}; |
||||
|
||||
ProviderManager.prototype.stopPolling = function (pollId) { |
||||
for (var i = this.polls.length; i--;) { |
||||
var poll = this.polls[i]; |
||||
if (poll.id === pollId) { |
||||
this.polls.splice(i, 1); |
||||
} |
||||
} |
||||
}; |
||||
|
||||
web3.provider = new ProviderManager(); |
||||
|
||||
web3.setProvider = function(provider) { |
||||
provider.onmessage = messageHandler; |
||||
web3.provider.set(provider); |
||||
web3.provider.sendQueued(); |
||||
}; |
||||
|
||||
var Filter = function(options, impl) { |
||||
this.impl = impl; |
||||
this.callbacks = []; |
||||
|
||||
var self = this;
|
||||
this.promise = impl.newFilter(options);
|
||||
this.promise.then(function (id) { |
||||
self.id = id; |
||||
web3.on(impl.changed, id, self.trigger.bind(self)); |
||||
web3.provider.startPolling({call: impl.changed, args: [id]}, id); |
||||
}); |
||||
}; |
||||
|
||||
Filter.prototype.arrived = function(callback) { |
||||
this.changed(callback); |
||||
} |
||||
|
||||
Filter.prototype.changed = function(callback) { |
||||
var self = this; |
||||
this.promise.then(function(id) { |
||||
self.callbacks.push(callback); |
||||
}); |
||||
}; |
||||
|
||||
Filter.prototype.trigger = function(messages) { |
||||
for(var i = 0; i < this.callbacks.length; i++) { |
||||
this.callbacks[i].call(this, messages); |
||||
} |
||||
}; |
||||
|
||||
Filter.prototype.uninstall = function() { |
||||
var self = this; |
||||
this.promise.then(function (id) { |
||||
self.impl.uninstallFilter(id); |
||||
web3.provider.stopPolling(id); |
||||
web3.off(impl.changed, id); |
||||
}); |
||||
}; |
||||
|
||||
Filter.prototype.messages = function() { |
||||
var self = this;
|
||||
return this.promise.then(function (id) { |
||||
return self.impl.getMessages(id); |
||||
}); |
||||
}; |
||||
|
||||
function messageHandler(data) { |
||||
if(data._event !== undefined) { |
||||
web3.trigger(data._event, data._id, data.data); |
||||
return; |
||||
} |
||||
|
||||
if(data._id) { |
||||
var cb = web3._callbacks[data._id]; |
||||
if (cb) { |
||||
cb.call(this, data.data) |
||||
delete web3._callbacks[data._id]; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/* |
||||
// Install default provider
|
||||
if(!web3.provider.installed()) { |
||||
var sock = new web3.WebSocket("ws://localhost:40404/eth"); |
||||
|
||||
web3.setProvider(sock); |
||||
} |
||||
*/ |
||||
|
||||
window.web3 = web3; |
||||
|
||||
})(this); |
||||
@ -1,27 +0,0 @@ |
||||
(function() { |
||||
var QtProvider = function() { |
||||
this.handlers = []; |
||||
|
||||
var self = this; |
||||
navigator.qt.onmessage = function (message) { |
||||
self.handlers.forEach(function (handler) { |
||||
handler.call(self, JSON.parse(message.data)); |
||||
}); |
||||
} |
||||
}; |
||||
|
||||
QtProvider.prototype.send = function(payload) { |
||||
navigator.qt.postMessage(JSON.stringify(payload)); |
||||
}; |
||||
|
||||
Object.defineProperty(QtProvider.prototype, "onmessage", { |
||||
set: function(handler) { |
||||
this.handlers.push(handler); |
||||
}, |
||||
});
|
||||
|
||||
if(typeof(web3) !== "undefined" && web3.providers !== undefined) { |
||||
web3.providers.QtProvider = QtProvider; |
||||
} |
||||
})(); |
||||
|
||||
@ -1,51 +0,0 @@ |
||||
(function() { |
||||
var WebSocketProvider = function(host) { |
||||
// onmessage handlers
|
||||
this.handlers = []; |
||||
// queue will be filled with messages if send is invoked before the ws is ready
|
||||
this.queued = []; |
||||
this.ready = false; |
||||
|
||||
this.ws = new WebSocket(host); |
||||
|
||||
var self = this; |
||||
this.ws.onmessage = function(event) { |
||||
for(var i = 0; i < self.handlers.length; i++) { |
||||
self.handlers[i].call(self, JSON.parse(event.data), event) |
||||
} |
||||
}; |
||||
|
||||
this.ws.onopen = function() { |
||||
self.ready = true; |
||||
|
||||
for(var i = 0; i < self.queued.length; i++) { |
||||
// Resend
|
||||
self.send(self.queued[i]); |
||||
} |
||||
}; |
||||
}; |
||||
WebSocketProvider.prototype.send = function(payload) { |
||||
if(this.ready) { |
||||
var data = JSON.stringify(payload); |
||||
|
||||
this.ws.send(data); |
||||
} else { |
||||
this.queued.push(payload); |
||||
} |
||||
}; |
||||
|
||||
WebSocketProvider.prototype.onMessage = function(handler) { |
||||
this.handlers.push(handler); |
||||
}; |
||||
|
||||
WebSocketProvider.prototype.unload = function() { |
||||
this.ws.close(); |
||||
}; |
||||
Object.defineProperty(WebSocketProvider.prototype, "onmessage", { |
||||
set: function(provider) { this.onMessage(provider); } |
||||
}); |
||||
|
||||
if(typeof(web3) !== "undefined" && web3.providers !== undefined) { |
||||
web3.providers.WebSocketProvider = WebSocketProvider; |
||||
} |
||||
})(); |
||||
@ -1,312 +0,0 @@ |
||||
// Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
|
||||
//
|
||||
// This library is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public
|
||||
// License as published by the Free Software Foundation; either
|
||||
// version 2.1 of the License, or (at your option) any later version.
|
||||
//
|
||||
// This 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
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this library; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||||
// MA 02110-1301 USA
|
||||
|
||||
// Main Ethereum library
|
||||
window.eth = { |
||||
prototype: Object(), |
||||
_callbacks: {}, |
||||
_onCallbacks: {}, |
||||
|
||||
test: function() { |
||||
var t = undefined; |
||||
postData({call: "test"}) |
||||
navigator.qt.onmessage = function(d) {console.log("onmessage called"); t = d; } |
||||
for(;;) { |
||||
if(t !== undefined) { |
||||
return t |
||||
} |
||||
} |
||||
}, |
||||
|
||||
mutan: function(code, cb) { |
||||
postData({call: "mutan", args: [code]}, cb) |
||||
}, |
||||
|
||||
toHex: function(str) { |
||||
var hex = ""; |
||||
for(var i = 0; i < str.length; i++) { |
||||
var n = str.charCodeAt(i).toString(16); |
||||
hex += n.length < 2 ? '0' + n : n; |
||||
} |
||||
|
||||
return hex; |
||||
}, |
||||
|
||||
toAscii: function(hex) { |
||||
// Find termination
|
||||
var str = ""; |
||||
var i = 0, l = hex.length; |
||||
for(; i < l; i+=2) { |
||||
var code = hex.charCodeAt(i) |
||||
if(code == 0) { |
||||
break; |
||||
} |
||||
|
||||
str += String.fromCharCode(parseInt(hex.substr(i, 2), 16)); |
||||
} |
||||
|
||||
return str; |
||||
}, |
||||
|
||||
fromAscii: function(str, pad) { |
||||
if(pad === undefined) { |
||||
pad = 32 |
||||
} |
||||
|
||||
var hex = this.toHex(str); |
||||
|
||||
while(hex.length < pad*2) |
||||
hex += "00"; |
||||
|
||||
return hex |
||||
}, |
||||
|
||||
|
||||
// Retrieve block
|
||||
//
|
||||
// Either supply a number or a string. Type is determent for the lookup method
|
||||
// string - Retrieves the block by looking up the hash
|
||||
// number - Retrieves the block by looking up the block number
|
||||
getBlock: function(numberOrHash, cb) { |
||||
var func; |
||||
if(typeof numberOrHash == "string") { |
||||
func = "getBlockByHash"; |
||||
} else { |
||||
func = "getBlockByNumber"; |
||||
} |
||||
postData({call: func, args: [numberOrHash]}, cb); |
||||
}, |
||||
|
||||
// Create transaction
|
||||
//
|
||||
// Transact between two state objects
|
||||
transact: function(params, cb) { |
||||
if(params === undefined) { |
||||
params = {}; |
||||
} |
||||
|
||||
if(params.endowment !== undefined) |
||||
params.value = params.endowment; |
||||
if(params.code !== undefined) |
||||
params.data = params.code; |
||||
|
||||
// Make sure everything is string
|
||||
var fields = ["to", "from", "value", "gas", "gasPrice"]; |
||||
for(var i = 0; i < fields.length; i++) { |
||||
if(params[fields[i]] === undefined) { |
||||
params[fields[i]] = ""; |
||||
} |
||||
params[fields[i]] = params[fields[i]].toString(); |
||||
} |
||||
|
||||
var data; |
||||
if(typeof params.data === "object") { |
||||
data = ""; |
||||
for(var i = 0; i < params.data.length; i++) { |
||||
data += params.data[i] |
||||
} |
||||
} else { |
||||
data = params.data; |
||||
} |
||||
|
||||
postData({call: "transact", args: [params.from, params.to, params.value, params.gas, params.gasPrice, "0x"+data]}, cb); |
||||
}, |
||||
|
||||
getMessages: function(filter, cb) { |
||||
postData({call: "messages", args: [filter]}, cb); |
||||
}, |
||||
|
||||
getStorageAt: function(address, storageAddress, cb) { |
||||
postData({call: "getStorage", args: [address, storageAddress]}, cb); |
||||
}, |
||||
|
||||
getEachStorageAt: function(address, cb){ |
||||
postData({call: "getEachStorage", args: [address]}, cb); |
||||
}, |
||||
|
||||
getKey: function(cb) { |
||||
postData({call: "getKey"}, cb); |
||||
}, |
||||
|
||||
getTxCountAt: function(address, cb) { |
||||
postData({call: "getTxCountAt", args: [address]}, cb); |
||||
}, |
||||
getIsMining: function(cb){ |
||||
postData({call: "getIsMining"}, cb) |
||||
}, |
||||
getIsListening: function(cb){ |
||||
postData({call: "getIsListening"}, cb) |
||||
}, |
||||
getCoinBase: function(cb){ |
||||
postData({call: "getCoinBase"}, cb); |
||||
}, |
||||
getPeerCount: function(cb){ |
||||
postData({call: "getPeerCount"}, cb); |
||||
}, |
||||
getBalanceAt: function(address, cb) { |
||||
postData({call: "getBalance", args: [address]}, cb); |
||||
}, |
||||
getTransactionsFor: function(address, cb) { |
||||
postData({call: "getTransactionsFor", args: [address]}, cb); |
||||
}, |
||||
|
||||
getSecretToAddress: function(sec, cb) { |
||||
postData({call: "getSecretToAddress", args: [sec]}, cb); |
||||
}, |
||||
|
||||
/* |
||||
watch: function(address, storageAddrOrCb, cb) { |
||||
var ev; |
||||
if(cb === undefined) { |
||||
cb = storageAddrOrCb; |
||||
storageAddrOrCb = ""; |
||||
ev = "object:"+address; |
||||
} else { |
||||
ev = "storage:"+address+":"+storageAddrOrCb; |
||||
} |
||||
|
||||
eth.on(ev, cb) |
||||
|
||||
postData({call: "watch", args: [address, storageAddrOrCb]}); |
||||
}, |
||||
|
||||
disconnect: function(address, storageAddrOrCb, cb) { |
||||
var ev; |
||||
if(cb === undefined) { |
||||
cb = storageAddrOrCb; |
||||
storageAddrOrCb = ""; |
||||
ev = "object:"+address; |
||||
} else { |
||||
ev = "storage:"+address+":"+storageAddrOrCb; |
||||
} |
||||
|
||||
eth.off(ev, cb) |
||||
|
||||
postData({call: "disconnect", args: [address, storageAddrOrCb]}); |
||||
}, |
||||
*/ |
||||
|
||||
watch: function(options) { |
||||
var filter = new Filter(options); |
||||
filter.number = newWatchNum().toString() |
||||
|
||||
postData({call: "watch", args: [options, filter.number]}) |
||||
|
||||
return filter; |
||||
}, |
||||
|
||||
set: function(props) { |
||||
postData({call: "set", args: props}); |
||||
}, |
||||
|
||||
on: function(event, cb) { |
||||
if(eth._onCallbacks[event] === undefined) { |
||||
eth._onCallbacks[event] = []; |
||||
} |
||||
|
||||
eth._onCallbacks[event].push(cb); |
||||
|
||||
return this |
||||
}, |
||||
|
||||
off: function(event, cb) { |
||||
if(eth._onCallbacks[event] !== undefined) { |
||||
var callbacks = eth._onCallbacks[event]; |
||||
for(var i = 0; i < callbacks.length; i++) { |
||||
if(callbacks[i] === cb) { |
||||
delete callbacks[i]; |
||||
} |
||||
} |
||||
} |
||||
|
||||
return this |
||||
}, |
||||
|
||||
trigger: function(event, data) { |
||||
var callbacks = eth._onCallbacks[event]; |
||||
if(callbacks !== undefined) { |
||||
for(var i = 0; i < callbacks.length; i++) { |
||||
// Figure out whether the returned data was an array
|
||||
// array means multiple return arguments (multiple params)
|
||||
if(data instanceof Array) { |
||||
callbacks[i].apply(this, data); |
||||
} else { |
||||
callbacks[i].call(this, data); |
||||
} |
||||
} |
||||
} |
||||
}, |
||||
} |
||||
|
||||
|
||||
var Filter = function(options) { |
||||
this.options = options; |
||||
}; |
||||
Filter.prototype.changed = function(callback) { |
||||
// Register the watched:<number>. Qml will call the appropriate event if anything
|
||||
// interesting happens in the land of Go.
|
||||
eth.on("watched:"+this.number, callback) |
||||
} |
||||
Filter.prototype.getMessages = function(cb) { |
||||
return eth.getMessages(this.options, cb) |
||||
} |
||||
|
||||
var watchNum = 0; |
||||
function newWatchNum() { |
||||
return watchNum++; |
||||
} |
||||
|
||||
function postData(data, cb) { |
||||
data._seed = Math.floor(Math.random() * 1000000) |
||||
if(cb) { |
||||
eth._callbacks[data._seed] = cb; |
||||
} |
||||
|
||||
if(data.args === undefined) { |
||||
data.args = []; |
||||
} |
||||
|
||||
navigator.qt.postMessage(JSON.stringify(data)); |
||||
} |
||||
|
||||
navigator.qt.onmessage = function(ev) { |
||||
var data = JSON.parse(ev.data) |
||||
|
||||
if(data._event !== undefined) { |
||||
eth.trigger(data._event, data.data); |
||||
} else { |
||||
if(data._seed) { |
||||
var cb = eth._callbacks[data._seed]; |
||||
if(cb) { |
||||
cb.call(this, data.data) |
||||
|
||||
// Remove the "trigger" callback
|
||||
delete eth._callbacks[ev._seed]; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
eth.on("chain:changed", function() { |
||||
}) |
||||
|
||||
eth.on("messages", { /* filters */}, function(messages){ |
||||
}) |
||||
|
||||
eth.on("pending:changed", function() { |
||||
}) |
||||
|
||||
@ -0,0 +1,5 @@ |
||||
{ |
||||
"directory": "example/js/", |
||||
"cwd": "./", |
||||
"analytics": false |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
root = true |
||||
|
||||
[*] |
||||
indent_style = space |
||||
indent_size = 4 |
||||
end_of_line = lf |
||||
charset = utf-8 |
||||
trim_trailing_whitespace = true |
||||
insert_final_newline = true |
||||
|
||||
[*.md] |
||||
trim_trailing_whitespace = false |
||||
@ -0,0 +1,18 @@ |
||||
# See http://help.github.com/ignore-files/ for more about ignoring files. |
||||
# |
||||
# If you find yourself ignoring temporary files generated by your text editor |
||||
# or operating system, you probably want to add a global ignore instead: |
||||
# git config --global core.excludesfile ~/.gitignore_global |
||||
|
||||
*.swp |
||||
/tmp |
||||
*/**/*un~ |
||||
*un~ |
||||
.DS_Store |
||||
*/**/.DS_Store |
||||
ethereum/ethereum |
||||
ethereal/ethereal |
||||
example/js |
||||
node_modules |
||||
bower_components |
||||
npm-debug.log |
||||
@ -0,0 +1,50 @@ |
||||
{ |
||||
"predef": [ |
||||
"console", |
||||
"require", |
||||
"equal", |
||||
"test", |
||||
"testBoth", |
||||
"testWithDefault", |
||||
"raises", |
||||
"deepEqual", |
||||
"start", |
||||
"stop", |
||||
"ok", |
||||
"strictEqual", |
||||
"module", |
||||
"expect", |
||||
"reject", |
||||
"impl" |
||||
], |
||||
|
||||
"esnext": true, |
||||
"proto": true, |
||||
"node" : true, |
||||
"browser" : true, |
||||
"browserify" : true, |
||||
|
||||
"boss" : true, |
||||
"curly": false, |
||||
"debug": true, |
||||
"devel": true, |
||||
"eqeqeq": true, |
||||
"evil": true, |
||||
"forin": false, |
||||
"immed": false, |
||||
"laxbreak": false, |
||||
"newcap": true, |
||||
"noarg": true, |
||||
"noempty": false, |
||||
"nonew": false, |
||||
"nomen": false, |
||||
"onevar": false, |
||||
"plusplus": false, |
||||
"regexp": false, |
||||
"undef": true, |
||||
"sub": true, |
||||
"strict": false, |
||||
"white": false, |
||||
"shadow": true, |
||||
"eqnull": true |
||||
} |
||||
@ -0,0 +1,9 @@ |
||||
example/js |
||||
node_modules |
||||
test |
||||
.gitignore |
||||
.editorconfig |
||||
.travis.yml |
||||
.npmignore |
||||
component.json |
||||
testling.html |
||||
@ -0,0 +1,13 @@ |
||||
language: node_js |
||||
node_js: |
||||
- "0.11" |
||||
- "0.10" |
||||
before_script: |
||||
- npm install |
||||
- npm install jshint |
||||
script: |
||||
- "jshint *.js lib" |
||||
after_script: |
||||
- npm run-script build |
||||
- npm test |
||||
|
||||
@ -0,0 +1,14 @@ |
||||
This file is part of ethereum.js. |
||||
|
||||
ethereum.js 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. |
||||
|
||||
ethereum.js 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 ethereum.js. If not, see <http://www.gnu.org/licenses/>. |
||||
@ -0,0 +1,96 @@ |
||||
# Ethereum JavaScript API |
||||
|
||||
This is the Ethereum compatible [JavaScript API](https://github.com/ethereum/wiki/wiki/JavaScript-API) |
||||
which implements the [Generic JSON RPC](https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC) spec. It's available on npm as a node module and also for bower and component as an embeddable js |
||||
|
||||
[![NPM version][npm-image]][npm-url] [![Build Status][travis-image]][travis-url] [![dependency status][dep-image]][dep-url] [![dev dependency status][dep-dev-image]][dep-dev-url] |
||||
|
||||
<!-- [](https://ci.testling.com/ethereum/ethereum.js) --> |
||||
|
||||
## Installation |
||||
|
||||
### Node.js |
||||
|
||||
npm install ethereum.js |
||||
|
||||
### For browser |
||||
Bower |
||||
|
||||
bower install ethereum.js |
||||
|
||||
Component |
||||
|
||||
component install ethereum/ethereum.js |
||||
|
||||
* Include `ethereum.min.js` in your html file. |
||||
* Include [bignumber.js](https://github.com/MikeMcl/bignumber.js/) |
||||
|
||||
## Usage |
||||
Require the library: |
||||
|
||||
var web3 = require('web3'); |
||||
|
||||
Set a provider (QtProvider, WebSocketProvider, HttpRpcProvider) |
||||
|
||||
var web3.setProvider(new web3.providers.WebSocketProvider('ws://localhost:40404/eth')); |
||||
|
||||
There you go, now you can use it: |
||||
|
||||
``` |
||||
var coinbase = web3.eth.coinbase; |
||||
var balance = web3.eth.balanceAt(coinbase); |
||||
``` |
||||
|
||||
|
||||
For another example see `example/index.html`. |
||||
|
||||
## Contribute! |
||||
|
||||
### Requirements |
||||
|
||||
* Node.js |
||||
* npm |
||||
* gulp (build) |
||||
* mocha (tests) |
||||
|
||||
```bash |
||||
sudo apt-get update |
||||
sudo apt-get install nodejs |
||||
sudo apt-get install npm |
||||
sudo apt-get install nodejs-legacy |
||||
``` |
||||
|
||||
### Building (gulp) |
||||
|
||||
```bash |
||||
npm run-script build |
||||
``` |
||||
|
||||
|
||||
### Testing (mocha) |
||||
|
||||
```bash |
||||
npm test |
||||
``` |
||||
|
||||
**Please note this repo is in it's early stage.** |
||||
|
||||
If you'd like to run a WebSocket ethereum node check out |
||||
[go-ethereum](https://github.com/ethereum/go-ethereum). |
||||
|
||||
To install ethereum and spawn a node: |
||||
|
||||
``` |
||||
go get github.com/ethereum/go-ethereum/ethereum |
||||
ethereum -ws -loglevel=4 |
||||
``` |
||||
|
||||
[npm-image]: https://badge.fury.io/js/ethereum.js.png |
||||
[npm-url]: https://npmjs.org/package/ethereum.js |
||||
[travis-image]: https://travis-ci.org/ethereum/ethereum.js.svg |
||||
[travis-url]: https://travis-ci.org/ethereum/ethereum.js |
||||
[dep-image]: https://david-dm.org/ethereum/ethereum.js.svg |
||||
[dep-url]: https://david-dm.org/ethereum/ethereum.js |
||||
[dep-dev-image]: https://david-dm.org/ethereum/ethereum.js/dev-status.svg |
||||
[dep-dev-url]: https://david-dm.org/ethereum/ethereum.js#info=devDependencies |
||||
|
||||
@ -0,0 +1,51 @@ |
||||
{ |
||||
"name": "ethereum.js", |
||||
"namespace": "ethereum", |
||||
"version": "0.0.10", |
||||
"description": "Ethereum Compatible JavaScript API", |
||||
"main": ["./dist/ethereum.js", "./dist/ethereum.min.js"], |
||||
"dependencies": { |
||||
"bignumber.js": ">=2.0.0" |
||||
}, |
||||
"repository": { |
||||
"type": "git", |
||||
"url": "https://github.com/ethereum/ethereum.js.git" |
||||
}, |
||||
"homepage": "https://github.com/ethereum/ethereum.js", |
||||
"bugs": { |
||||
"url": "https://github.com/ethereum/ethereum.js/issues" |
||||
}, |
||||
"keywords": [ |
||||
"ethereum", |
||||
"javascript", |
||||
"API" |
||||
], |
||||
"authors": [ |
||||
{ |
||||
"name": "Marek Kotewicz", |
||||
"email": "marek@ethdev.com", |
||||
"homepage": "https://github.com/debris" |
||||
}, |
||||
{ |
||||
"name": "Marian Oancea", |
||||
"email": "marian@ethdev.com", |
||||
"homepage": "https://github.com/cubedro" |
||||
} |
||||
], |
||||
"license": "LGPL-3.0", |
||||
"ignore": [ |
||||
"example", |
||||
"lib", |
||||
"node_modules", |
||||
"package.json", |
||||
".bowerrc", |
||||
".editorconfig", |
||||
".gitignore", |
||||
".jshintrc", |
||||
".npmignore", |
||||
".travis.yml", |
||||
"gulpfile.js", |
||||
"index.js", |
||||
"**/*.txt" |
||||
] |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -0,0 +1,39 @@ |
||||
<!doctype> |
||||
<html> |
||||
|
||||
<head> |
||||
<script type="text/javascript" src="js/bignumber.js/bignumber.min.js"></script> |
||||
<script type="text/javascript" src="../dist/ethereum.js"></script> |
||||
<script type="text/javascript"> |
||||
|
||||
var web3 = require('web3'); |
||||
web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080')); |
||||
|
||||
function watchBalance() { |
||||
var coinbase = web3.eth.coinbase; |
||||
var originalBalance = 0; |
||||
|
||||
var balance = web3.eth.balanceAt(coinbase); |
||||
var originalBalance = web3.toDecimal(balance); |
||||
document.getElementById('original').innerText = 'original balance: ' + originalBalance + ' watching...'; |
||||
|
||||
var filter = web3.eth.watch({address: coinbase}).changed(function() { |
||||
balance = web3.eth.balanceAt(coinbase) |
||||
var currentBalance = web3.toDecimal(balance); |
||||
document.getElementById("current").innerText = 'current: ' + currentBalance; |
||||
document.getElementById("diff").innerText = 'diff: ' + (currentBalance - originalBalance); |
||||
}); |
||||
} |
||||
|
||||
</script> |
||||
</head> |
||||
<body> |
||||
<h1>coinbase balance</h1> |
||||
<button type="button" onClick="watchBalance();">watch balance</button> |
||||
<div></div> |
||||
<div id="original"></div> |
||||
<div id="current"></div> |
||||
<div id="diff"></div> |
||||
</body> |
||||
</html> |
||||
|
||||
@ -0,0 +1,73 @@ |
||||
<!doctype> |
||||
<html> |
||||
|
||||
<head> |
||||
<script type="text/javascript" src="js/bignumber.js/bignumber.min.js"></script> |
||||
<script type="text/javascript" src="../dist/ethereum.js"></script> |
||||
<script type="text/javascript"> |
||||
|
||||
var web3 = require('web3'); |
||||
web3.setProvider(new web3.providers.HttpSyncProvider()); |
||||
|
||||
// solidity source code |
||||
var source = "" + |
||||
"contract test {\n" + |
||||
" function multiply(uint a) returns(uint d) {\n" + |
||||
" return a * 7;\n" + |
||||
" }\n" + |
||||
"}\n"; |
||||
|
||||
// contract description, this will be autogenerated somehow |
||||
var desc = [{ |
||||
"name": "multiply(uint256)", |
||||
"inputs": [ |
||||
{ |
||||
"name": "a", |
||||
"type": "uint256" |
||||
} |
||||
], |
||||
"outputs": [ |
||||
{ |
||||
"name": "d", |
||||
"type": "uint256" |
||||
} |
||||
] |
||||
}]; |
||||
|
||||
var contract; |
||||
|
||||
function createExampleContract() { |
||||
// hide create button |
||||
document.getElementById('create').style.visibility = 'hidden'; |
||||
document.getElementById('source').innerText = source; |
||||
|
||||
// create contract |
||||
var address = web3.eth.transact({code: web3.eth.solidity(source)}); |
||||
contract = web3.eth.contract(address, desc); |
||||
document.getElementById('call').style.visibility = 'visible'; |
||||
} |
||||
|
||||
function callExampleContract() { |
||||
// this should be generated by ethereum |
||||
var param = parseInt(document.getElementById('value').value); |
||||
|
||||
// call the contract |
||||
var res = contract.call().multiply(param); |
||||
document.getElementById('result').innerText = res.toString(10); |
||||
} |
||||
|
||||
</script> |
||||
</head> |
||||
<body> |
||||
<h1>contract</h1> |
||||
<div id="source"></div> |
||||
<div id='create'> |
||||
<button type="button" onClick="createExampleContract();">create example contract</button> |
||||
</div> |
||||
<div id='call' style='visibility: hidden;'> |
||||
<input type="number" id="value" onkeyup='callExampleContract()'></input> |
||||
</div> |
||||
<div id="result"></div> |
||||
</body> |
||||
</html> |
||||
|
||||
@ -0,0 +1,76 @@ |
||||
<!doctype> |
||||
<html> |
||||
|
||||
<head> |
||||
<script type="text/javascript" src="js/bignumber.js/bignumber.min.js"></script> |
||||
<script type="text/javascript" src="../dist/ethereum.js"></script> |
||||
<script type="text/javascript"> |
||||
|
||||
var web3 = require('web3'); |
||||
web3.setProvider(new web3.providers.QtSyncProvider()); |
||||
|
||||
// solidity source code |
||||
var source = "" + |
||||
"contract test {\n" + |
||||
" /// @notice Will multiply `a` by 7. \n" + |
||||
" function multiply(uint a) returns(uint d) {\n" + |
||||
" return a * 7;\n" + |
||||
" }\n" + |
||||
"}\n"; |
||||
|
||||
// contract description, this will be autogenerated somehow |
||||
var desc = [{ |
||||
"name": "multiply(uint256)", |
||||
"inputs": [ |
||||
{ |
||||
"name": "a", |
||||
"type": "uint256" |
||||
} |
||||
], |
||||
"outputs": [ |
||||
{ |
||||
"name": "d", |
||||
"type": "uint256" |
||||
} |
||||
] |
||||
}]; |
||||
|
||||
var contract; |
||||
|
||||
function createExampleContract() { |
||||
// hide create button |
||||
document.getElementById('create').style.visibility = 'hidden'; |
||||
document.getElementById('source').innerText = source; |
||||
|
||||
// create contract |
||||
var address = web3.eth.transact({code: web3.eth.solidity(source)}); |
||||
contract = web3.eth.contract(address, desc); |
||||
document.getElementById('call').style.visibility = 'visible'; |
||||
} |
||||
|
||||
function callExampleContract() { |
||||
// this should be generated by ethereum |
||||
var param = parseInt(document.getElementById('value').value); |
||||
|
||||
// transaction does not return any result, cause it's not synchronous and we don't know, |
||||
// when it will be processed |
||||
contract.transact().multiply(param); |
||||
document.getElementById('result').innerText = 'transaction made'; |
||||
} |
||||
|
||||
</script> |
||||
</head> |
||||
<body> |
||||
<h1>contract</h1> |
||||
<div id="source"></div> |
||||
<div id='create'> |
||||
<button type="button" onClick="createExampleContract();">create example contract</button> |
||||
</div> |
||||
<div id='call' style='visibility: hidden;'> |
||||
<input type="number" id="value"></input> |
||||
<button type="button" onClick="callExampleContract()">Call Contract</button> |
||||
</div> |
||||
<div id="result"></div> |
||||
</body> |
||||
</html> |
||||
|
||||
@ -0,0 +1,12 @@ |
||||
#!/usr/bin/env node
|
||||
|
||||
var web3 = require("../index.js"); |
||||
|
||||
web3.setProvider(new web3.providers.HttpSyncProvider('http://localhost:8080')); |
||||
|
||||
var coinbase = web3.eth.coinbase; |
||||
console.log(coinbase); |
||||
|
||||
var balance = web3.eth.balanceAt(coinbase); |
||||
console.log(balance); |
||||
|
||||
@ -0,0 +1,104 @@ |
||||
#!/usr/bin/env node
|
||||
|
||||
'use strict'; |
||||
|
||||
var path = require('path'); |
||||
|
||||
var del = require('del'); |
||||
var gulp = require('gulp'); |
||||
var browserify = require('browserify'); |
||||
var jshint = require('gulp-jshint'); |
||||
var uglify = require('gulp-uglify'); |
||||
var rename = require('gulp-rename'); |
||||
var envify = require('envify/custom'); |
||||
var unreach = require('unreachable-branch-transform'); |
||||
var source = require('vinyl-source-stream'); |
||||
var exorcist = require('exorcist'); |
||||
var bower = require('bower'); |
||||
|
||||
var DEST = './dist/'; |
||||
|
||||
var build = function(src, dst, ugly) { |
||||
var result = browserify({ |
||||
debug: true, |
||||
insert_global_vars: false, |
||||
detectGlobals: false, |
||||
bundleExternal: false |
||||
}) |
||||
.require('./' + src + '.js', {expose: 'web3'}) |
||||
.add('./' + src + '.js') |
||||
.transform('envify', { |
||||
NODE_ENV: 'build' |
||||
}) |
||||
.transform('unreachable-branch-transform'); |
||||
|
||||
if (ugly) { |
||||
result = result.transform('uglifyify', { |
||||
mangle: false, |
||||
compress: { |
||||
dead_code: false, |
||||
conditionals: true, |
||||
unused: false, |
||||
hoist_funs: true, |
||||
hoist_vars: true, |
||||
negate_iife: false |
||||
}, |
||||
beautify: true, |
||||
warnings: true |
||||
}); |
||||
} |
||||
|
||||
return result.bundle() |
||||
.pipe(exorcist(path.join( DEST, dst + '.js.map'))) |
||||
.pipe(source(dst + '.js')) |
||||
.pipe(gulp.dest( DEST )); |
||||
}; |
||||
|
||||
var uglifyFile = function(file) { |
||||
return gulp.src( DEST + file + '.js') |
||||
.pipe(uglify()) |
||||
.pipe(rename(file + '.min.js')) |
||||
.pipe(gulp.dest( DEST )); |
||||
}; |
||||
|
||||
gulp.task('bower', function(cb){ |
||||
bower.commands.install().on('end', function (installed){ |
||||
console.log(installed); |
||||
cb(); |
||||
}); |
||||
}); |
||||
|
||||
gulp.task('clean', ['lint'], function(cb) { |
||||
del([ DEST ], cb); |
||||
}); |
||||
|
||||
gulp.task('lint', function(){ |
||||
return gulp.src(['./*.js', './lib/*.js']) |
||||
.pipe(jshint()) |
||||
.pipe(jshint.reporter('default')); |
||||
}); |
||||
|
||||
gulp.task('build', ['clean'], function () { |
||||
return build('index', 'ethereum', true); |
||||
}); |
||||
|
||||
gulp.task('buildDev', ['clean'], function () { |
||||
return build('index', 'ethereum', false); |
||||
}); |
||||
|
||||
gulp.task('uglify', ['build'], function(){ |
||||
return uglifyFile('ethereum'); |
||||
}); |
||||
|
||||
gulp.task('uglifyDev', ['buildDev'], function(){ |
||||
return uglifyFile('ethereum'); |
||||
}); |
||||
|
||||
gulp.task('watch', function() { |
||||
gulp.watch(['./lib/*.js'], ['lint', 'prepare', 'build']); |
||||
}); |
||||
|
||||
gulp.task('release', ['bower', 'lint', 'build', 'uglify']); |
||||
gulp.task('dev', ['bower', 'lint', 'buildDev', 'uglifyDev']); |
||||
gulp.task('default', ['dev']); |
||||
|
||||
@ -0,0 +1,11 @@ |
||||
var web3 = require('./lib/web3'); |
||||
var ProviderManager = require('./lib/providermanager'); |
||||
web3.provider = new ProviderManager(); |
||||
web3.filter = require('./lib/filter'); |
||||
web3.providers.HttpSyncProvider = require('./lib/httpsync'); |
||||
web3.providers.QtSyncProvider = require('./lib/qtsync'); |
||||
web3.eth.contract = require('./lib/contract'); |
||||
web3.abi = require('./lib/abi'); |
||||
|
||||
|
||||
module.exports = web3; |
||||
@ -0,0 +1,410 @@ |
||||
/* |
||||
This file is part of ethereum.js. |
||||
|
||||
ethereum.js 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. |
||||
|
||||
ethereum.js 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 ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
/** @file abi.js |
||||
* @authors: |
||||
* Marek Kotewicz <marek@ethdev.com> |
||||
* Gav Wood <g@ethdev.com> |
||||
* @date 2014 |
||||
*/ |
||||
|
||||
// TODO: is these line is supposed to be here?
|
||||
if (process.env.NODE_ENV !== 'build') { |
||||
var BigNumber = require('bignumber.js'); // jshint ignore:line
|
||||
} |
||||
|
||||
var web3 = require('./web3'); // jshint ignore:line
|
||||
|
||||
BigNumber.config({ ROUNDING_MODE: BigNumber.ROUND_DOWN }); |
||||
|
||||
var ETH_PADDING = 32; |
||||
|
||||
/// method signature length in bytes
|
||||
var ETH_METHOD_SIGNATURE_LENGTH = 4; |
||||
|
||||
/// Finds first index of array element matching pattern
|
||||
/// @param array
|
||||
/// @param callback pattern
|
||||
/// @returns index of element
|
||||
var findIndex = function (array, callback) { |
||||
var end = false; |
||||
var i = 0; |
||||
for (; i < array.length && !end; i++) { |
||||
end = callback(array[i]); |
||||
} |
||||
return end ? i - 1 : -1; |
||||
}; |
||||
|
||||
/// @returns a function that is used as a pattern for 'findIndex'
|
||||
var findMethodIndex = function (json, methodName) { |
||||
return findIndex(json, function (method) { |
||||
return method.name === methodName; |
||||
}); |
||||
}; |
||||
|
||||
/// @returns method with given method name
|
||||
var getMethodWithName = function (json, methodName) { |
||||
var index = findMethodIndex(json, methodName); |
||||
if (index === -1) { |
||||
console.error('method ' + methodName + ' not found in the abi'); |
||||
return undefined; |
||||
} |
||||
return json[index]; |
||||
}; |
||||
|
||||
/// @param string string to be padded
|
||||
/// @param number of characters that result string should have
|
||||
/// @param sign, by default 0
|
||||
/// @returns right aligned string
|
||||
var padLeft = function (string, chars, sign) { |
||||
return new Array(chars - string.length + 1).join(sign ? sign : "0") + string; |
||||
}; |
||||
|
||||
/// @param expected type prefix (string)
|
||||
/// @returns function which checks if type has matching prefix. if yes, returns true, otherwise false
|
||||
var prefixedType = function (prefix) { |
||||
return function (type) { |
||||
return type.indexOf(prefix) === 0; |
||||
}; |
||||
}; |
||||
|
||||
/// @param expected type name (string)
|
||||
/// @returns function which checks if type is matching expected one. if yes, returns true, otherwise false
|
||||
var namedType = function (name) { |
||||
return function (type) { |
||||
return name === type; |
||||
}; |
||||
}; |
||||
|
||||
var arrayType = function (type) { |
||||
return type.slice(-2) === '[]'; |
||||
}; |
||||
|
||||
/// Formats input value to byte representation of int
|
||||
/// If value is negative, return it's two's complement
|
||||
/// If the value is floating point, round it down
|
||||
/// @returns right-aligned byte representation of int
|
||||
var formatInputInt = function (value) { |
||||
var padding = ETH_PADDING * 2; |
||||
if (value instanceof BigNumber || typeof value === 'number') { |
||||
if (typeof value === 'number') |
||||
value = new BigNumber(value); |
||||
value = value.round(); |
||||
|
||||
if (value.lessThan(0))
|
||||
value = new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).plus(value).plus(1); |
||||
value = value.toString(16); |
||||
} |
||||
else if (value.indexOf('0x') === 0) |
||||
value = value.substr(2); |
||||
else if (typeof value === 'string') |
||||
value = formatInputInt(new BigNumber(value)); |
||||
else |
||||
value = (+value).toString(16); |
||||
return padLeft(value, padding); |
||||
}; |
||||
|
||||
/// Formats input value to byte representation of string
|
||||
/// @returns left-algined byte representation of string
|
||||
var formatInputString = function (value) { |
||||
return web3.fromAscii(value, ETH_PADDING).substr(2); |
||||
}; |
||||
|
||||
/// Formats input value to byte representation of bool
|
||||
/// @returns right-aligned byte representation bool
|
||||
var formatInputBool = function (value) { |
||||
return '000000000000000000000000000000000000000000000000000000000000000' + (value ? '1' : '0'); |
||||
}; |
||||
|
||||
/// Formats input value to byte representation of real
|
||||
/// Values are multiplied by 2^m and encoded as integers
|
||||
/// @returns byte representation of real
|
||||
var formatInputReal = function (value) { |
||||
return formatInputInt(new BigNumber(value).times(new BigNumber(2).pow(128)));
|
||||
}; |
||||
|
||||
var dynamicTypeBytes = function (type, value) { |
||||
// TODO: decide what to do with array of strings
|
||||
if (arrayType(type) || type === 'string') // only string itself that is dynamic; stringX is static length.
|
||||
return formatInputInt(value.length);
|
||||
return ""; |
||||
}; |
||||
|
||||
/// Setups input formatters for solidity types
|
||||
/// @returns an array of input formatters
|
||||
var setupInputTypes = function () { |
||||
|
||||
return [ |
||||
{ type: prefixedType('uint'), format: formatInputInt }, |
||||
{ type: prefixedType('int'), format: formatInputInt }, |
||||
{ type: prefixedType('hash'), format: formatInputInt }, |
||||
{ type: prefixedType('string'), format: formatInputString },
|
||||
{ type: prefixedType('real'), format: formatInputReal }, |
||||
{ type: prefixedType('ureal'), format: formatInputReal }, |
||||
{ type: namedType('address'), format: formatInputInt }, |
||||
{ type: namedType('bool'), format: formatInputBool } |
||||
]; |
||||
}; |
||||
|
||||
var inputTypes = setupInputTypes(); |
||||
|
||||
/// Formats input params to bytes
|
||||
/// @param contract json abi
|
||||
/// @param name of the method that we want to use
|
||||
/// @param array of params that will be formatted to bytes
|
||||
/// @returns bytes representation of input params
|
||||
var toAbiInput = function (json, methodName, params) { |
||||
var bytes = ""; |
||||
|
||||
var method = getMethodWithName(json, methodName); |
||||
var padding = ETH_PADDING * 2; |
||||
|
||||
/// first we iterate in search for dynamic
|
||||
method.inputs.forEach(function (input, index) { |
||||
bytes += dynamicTypeBytes(input.type, params[index]); |
||||
}); |
||||
|
||||
method.inputs.forEach(function (input, i) { |
||||
var typeMatch = false; |
||||
for (var j = 0; j < inputTypes.length && !typeMatch; j++) { |
||||
typeMatch = inputTypes[j].type(method.inputs[i].type, params[i]); |
||||
} |
||||
if (!typeMatch) { |
||||
console.error('input parser does not support type: ' + method.inputs[i].type); |
||||
} |
||||
|
||||
var formatter = inputTypes[j - 1].format; |
||||
var toAppend = ""; |
||||
|
||||
if (arrayType(method.inputs[i].type)) |
||||
toAppend = params[i].reduce(function (acc, curr) { |
||||
return acc + formatter(curr); |
||||
}, ""); |
||||
else |
||||
toAppend = formatter(params[i]); |
||||
|
||||
bytes += toAppend;
|
||||
}); |
||||
return bytes; |
||||
}; |
||||
|
||||
/// Check if input value is negative
|
||||
/// @param value is hex format
|
||||
/// @returns true if it is negative, otherwise false
|
||||
var signedIsNegative = function (value) { |
||||
return (new BigNumber(value.substr(0, 1), 16).toString(2).substr(0, 1)) === '1'; |
||||
}; |
||||
|
||||
/// Formats input right-aligned input bytes to int
|
||||
/// @returns right-aligned input bytes formatted to int
|
||||
var formatOutputInt = function (value) { |
||||
value = value || "0"; |
||||
// check if it's negative number
|
||||
// it it is, return two's complement
|
||||
if (signedIsNegative(value)) { |
||||
return new BigNumber(value, 16).minus(new BigNumber('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16)).minus(1); |
||||
} |
||||
return new BigNumber(value, 16); |
||||
}; |
||||
|
||||
/// Formats big right-aligned input bytes to uint
|
||||
/// @returns right-aligned input bytes formatted to uint
|
||||
var formatOutputUInt = function (value) { |
||||
value = value || "0"; |
||||
return new BigNumber(value, 16); |
||||
}; |
||||
|
||||
/// @returns input bytes formatted to real
|
||||
var formatOutputReal = function (value) { |
||||
return formatOutputInt(value).dividedBy(new BigNumber(2).pow(128));
|
||||
}; |
||||
|
||||
/// @returns input bytes formatted to ureal
|
||||
var formatOutputUReal = function (value) { |
||||
return formatOutputUInt(value).dividedBy(new BigNumber(2).pow(128));
|
||||
}; |
||||
|
||||
/// @returns right-aligned input bytes formatted to hex
|
||||
var formatOutputHash = function (value) { |
||||
return "0x" + value; |
||||
}; |
||||
|
||||
/// @returns right-aligned input bytes formatted to bool
|
||||
var formatOutputBool = function (value) { |
||||
return value === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false; |
||||
}; |
||||
|
||||
/// @returns left-aligned input bytes formatted to ascii string
|
||||
var formatOutputString = function (value) { |
||||
return web3.toAscii(value); |
||||
}; |
||||
|
||||
/// @returns right-aligned input bytes formatted to address
|
||||
var formatOutputAddress = function (value) { |
||||
return "0x" + value.slice(value.length - 40, value.length); |
||||
}; |
||||
|
||||
var dynamicBytesLength = function (type) { |
||||
if (arrayType(type) || type === 'string') // only string itself that is dynamic; stringX is static length.
|
||||
return ETH_PADDING * 2; |
||||
return 0; |
||||
}; |
||||
|
||||
/// Setups output formaters for solidity types
|
||||
/// @returns an array of output formatters
|
||||
var setupOutputTypes = function () { |
||||
|
||||
return [ |
||||
{ type: prefixedType('uint'), format: formatOutputUInt }, |
||||
{ type: prefixedType('int'), format: formatOutputInt }, |
||||
{ type: prefixedType('hash'), format: formatOutputHash }, |
||||
{ type: prefixedType('string'), format: formatOutputString }, |
||||
{ type: prefixedType('real'), format: formatOutputReal }, |
||||
{ type: prefixedType('ureal'), format: formatOutputUReal }, |
||||
{ type: namedType('address'), format: formatOutputAddress }, |
||||
{ type: namedType('bool'), format: formatOutputBool } |
||||
]; |
||||
}; |
||||
|
||||
var outputTypes = setupOutputTypes(); |
||||
|
||||
/// Formats output bytes back to param list
|
||||
/// @param contract json abi
|
||||
/// @param name of the method that we want to use
|
||||
/// @param bytes representtion of output
|
||||
/// @returns array of output params
|
||||
var fromAbiOutput = function (json, methodName, output) { |
||||
|
||||
output = output.slice(2); |
||||
var result = []; |
||||
var method = getMethodWithName(json, methodName); |
||||
var padding = ETH_PADDING * 2; |
||||
|
||||
var dynamicPartLength = method.outputs.reduce(function (acc, curr) { |
||||
return acc + dynamicBytesLength(curr.type); |
||||
}, 0); |
||||
|
||||
var dynamicPart = output.slice(0, dynamicPartLength); |
||||
output = output.slice(dynamicPartLength); |
||||
|
||||
method.outputs.forEach(function (out, i) { |
||||
var typeMatch = false; |
||||
for (var j = 0; j < outputTypes.length && !typeMatch; j++) { |
||||
typeMatch = outputTypes[j].type(method.outputs[i].type); |
||||
} |
||||
|
||||
if (!typeMatch) { |
||||
console.error('output parser does not support type: ' + method.outputs[i].type); |
||||
} |
||||
|
||||
var formatter = outputTypes[j - 1].format; |
||||
if (arrayType(method.outputs[i].type)) { |
||||
var size = formatOutputUInt(dynamicPart.slice(0, padding)); |
||||
dynamicPart = dynamicPart.slice(padding); |
||||
var array = []; |
||||
for (var k = 0; k < size; k++) { |
||||
array.push(formatter(output.slice(0, padding)));
|
||||
output = output.slice(padding); |
||||
} |
||||
result.push(array); |
||||
} |
||||
else if (prefixedType('string')(method.outputs[i].type)) { |
||||
dynamicPart = dynamicPart.slice(padding);
|
||||
result.push(formatter(output.slice(0, padding))); |
||||
output = output.slice(padding); |
||||
} else { |
||||
result.push(formatter(output.slice(0, padding))); |
||||
output = output.slice(padding); |
||||
} |
||||
}); |
||||
|
||||
return result; |
||||
}; |
||||
|
||||
/// @returns display name for method eg. multiply(uint256) -> multiply
|
||||
var methodDisplayName = function (method) { |
||||
var length = method.indexOf('(');
|
||||
return length !== -1 ? method.substr(0, length) : method; |
||||
}; |
||||
|
||||
/// @returns overloaded part of method's name
|
||||
var methodTypeName = function (method) { |
||||
/// TODO: make it not vulnerable
|
||||
var length = method.indexOf('('); |
||||
return length !== -1 ? method.substr(length + 1, method.length - 1 - (length + 1)) : ""; |
||||
}; |
||||
|
||||
/// @param json abi for contract
|
||||
/// @returns input parser object for given json abi
|
||||
var inputParser = function (json) { |
||||
var parser = {}; |
||||
json.forEach(function (method) { |
||||
var displayName = methodDisplayName(method.name);
|
||||
var typeName = methodTypeName(method.name); |
||||
|
||||
var impl = function () { |
||||
var params = Array.prototype.slice.call(arguments); |
||||
return toAbiInput(json, method.name, params); |
||||
}; |
||||
|
||||
if (parser[displayName] === undefined) { |
||||
parser[displayName] = impl; |
||||
} |
||||
|
||||
parser[displayName][typeName] = impl; |
||||
}); |
||||
|
||||
return parser; |
||||
}; |
||||
|
||||
/// @param json abi for contract
|
||||
/// @returns output parser for given json abi
|
||||
var outputParser = function (json) { |
||||
var parser = {}; |
||||
json.forEach(function (method) { |
||||
|
||||
var displayName = methodDisplayName(method.name);
|
||||
var typeName = methodTypeName(method.name); |
||||
|
||||
var impl = function (output) { |
||||
return fromAbiOutput(json, method.name, output); |
||||
}; |
||||
|
||||
if (parser[displayName] === undefined) { |
||||
parser[displayName] = impl; |
||||
} |
||||
|
||||
parser[displayName][typeName] = impl; |
||||
}); |
||||
|
||||
return parser; |
||||
}; |
||||
|
||||
/// @param method name for which we want to get method signature
|
||||
/// @returns (promise) contract method signature for method with given name
|
||||
var methodSignature = function (name) { |
||||
return web3.sha3(web3.fromAscii(name)).slice(0, 2 + ETH_METHOD_SIGNATURE_LENGTH * 2); |
||||
}; |
||||
|
||||
module.exports = { |
||||
inputParser: inputParser, |
||||
outputParser: outputParser, |
||||
methodSignature: methodSignature, |
||||
methodDisplayName: methodDisplayName, |
||||
methodTypeName: methodTypeName, |
||||
getMethodWithName: getMethodWithName |
||||
}; |
||||
|
||||
@ -0,0 +1,145 @@ |
||||
/* |
||||
This file is part of ethereum.js. |
||||
|
||||
ethereum.js 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. |
||||
|
||||
ethereum.js 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 ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
/** @file contract.js |
||||
* @authors: |
||||
* Marek Kotewicz <marek@ethdev.com> |
||||
* @date 2014 |
||||
*/ |
||||
|
||||
var web3 = require('./web3'); // jshint ignore:line
|
||||
var abi = require('./abi'); |
||||
|
||||
/** |
||||
* This method should be called when we want to call / transact some solidity method from javascript |
||||
* it returns an object which has same methods available as solidity contract description |
||||
* usage example:
|
||||
* |
||||
* var abi = [{ |
||||
* name: 'myMethod', |
||||
* inputs: [{ name: 'a', type: 'string' }], |
||||
* outputs: [{name: 'd', type: 'string' }] |
||||
* }]; // contract abi
|
||||
* |
||||
* var myContract = web3.eth.contract('0x0123123121', abi); // creation of contract object
|
||||
* |
||||
* myContract.myMethod('this is test string param for call'); // myMethod call (implicit, default)
|
||||
* myContract.call().myMethod('this is test string param for call'); // myMethod call (explicit)
|
||||
* myContract.transact().myMethod('this is test string param for transact'); // myMethod transact
|
||||
* |
||||
* @param address - address of the contract, which should be called |
||||
* @param desc - abi json description of the contract, which is being created |
||||
* @returns contract object |
||||
*/ |
||||
|
||||
var contract = function (address, desc) { |
||||
|
||||
desc.forEach(function (method) { |
||||
// workaround for invalid assumption that method.name is the full anonymous prototype of the method.
|
||||
// it's not. it's just the name. the rest of the code assumes it's actually the anonymous
|
||||
// prototype, so we make it so as a workaround.
|
||||
if (method.name.indexOf('(') === -1) { |
||||
var displayName = method.name; |
||||
var typeName = method.inputs.map(function(i){return i.type; }).join(); |
||||
method.name = displayName + '(' + typeName + ')'; |
||||
} |
||||
}); |
||||
|
||||
var inputParser = abi.inputParser(desc); |
||||
var outputParser = abi.outputParser(desc); |
||||
|
||||
var result = {}; |
||||
|
||||
result.call = function (options) { |
||||
result._isTransact = false; |
||||
result._options = options; |
||||
return result; |
||||
}; |
||||
|
||||
result.transact = function (options) { |
||||
result._isTransact = true; |
||||
result._options = options; |
||||
return result; |
||||
}; |
||||
|
||||
result._options = {}; |
||||
['gas', 'gasPrice', 'value', 'from'].forEach(function(p) { |
||||
result[p] = function (v) { |
||||
result._options[p] = v; |
||||
return result; |
||||
}; |
||||
}); |
||||
|
||||
|
||||
desc.forEach(function (method) { |
||||
|
||||
var displayName = abi.methodDisplayName(method.name); |
||||
var typeName = abi.methodTypeName(method.name); |
||||
|
||||
var impl = function () { |
||||
var params = Array.prototype.slice.call(arguments); |
||||
var signature = abi.methodSignature(method.name); |
||||
var parsed = inputParser[displayName][typeName].apply(null, params); |
||||
|
||||
var options = result._options || {}; |
||||
options.to = address; |
||||
options.data = signature + parsed; |
||||
|
||||
var isTransact = result._isTransact === true || (result._isTransact !== false && !method.constant); |
||||
var collapse = options.collapse !== false; |
||||
|
||||
// reset
|
||||
result._options = {}; |
||||
result._isTransact = null; |
||||
|
||||
if (isTransact) { |
||||
// it's used byt natspec.js
|
||||
// TODO: figure out better way to solve this
|
||||
web3._currentContractAbi = desc; |
||||
web3._currentContractAddress = address; |
||||
web3._currentContractMethodName = method.name; |
||||
web3._currentContractMethodParams = params; |
||||
|
||||
// transactions do not have any output, cause we do not know, when they will be processed
|
||||
web3.eth.transact(options); |
||||
return; |
||||
} |
||||
|
||||
var output = web3.eth.call(options); |
||||
var ret = outputParser[displayName][typeName](output); |
||||
if (collapse) |
||||
{ |
||||
if (ret.length === 1) |
||||
ret = ret[0]; |
||||
else if (ret.length === 0) |
||||
ret = null; |
||||
} |
||||
return ret; |
||||
}; |
||||
|
||||
if (result[displayName] === undefined) { |
||||
result[displayName] = impl; |
||||
} |
||||
|
||||
result[displayName][typeName] = impl; |
||||
|
||||
}); |
||||
|
||||
return result; |
||||
}; |
||||
|
||||
module.exports = contract; |
||||
|
||||
@ -0,0 +1,73 @@ |
||||
/* |
||||
This file is part of ethereum.js. |
||||
|
||||
ethereum.js 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. |
||||
|
||||
ethereum.js 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 ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
/** @file filter.js |
||||
* @authors: |
||||
* Jeffrey Wilcke <jeff@ethdev.com> |
||||
* Marek Kotewicz <marek@ethdev.com> |
||||
* Marian Oancea <marian@ethdev.com> |
||||
* Gav Wood <g@ethdev.com> |
||||
* @date 2014 |
||||
*/ |
||||
|
||||
var web3 = require('./web3'); // jshint ignore:line
|
||||
|
||||
/// should be used when we want to watch something
|
||||
/// it's using inner polling mechanism and is notified about changes
|
||||
var Filter = function(options, impl) { |
||||
this.impl = impl; |
||||
this.callbacks = []; |
||||
|
||||
this.id = impl.newFilter(options); |
||||
web3.provider.startPolling({call: impl.changed, args: [this.id]}, this.id, this.trigger.bind(this)); |
||||
}; |
||||
|
||||
/// alias for changed*
|
||||
Filter.prototype.arrived = function(callback) { |
||||
this.changed(callback); |
||||
}; |
||||
|
||||
/// gets called when there is new eth/shh message
|
||||
Filter.prototype.changed = function(callback) { |
||||
this.callbacks.push(callback); |
||||
}; |
||||
|
||||
/// trigger calling new message from people
|
||||
Filter.prototype.trigger = function(messages) { |
||||
for (var i = 0; i < this.callbacks.length; i++) { |
||||
for (var j = 0; j < messages.length; j++) { |
||||
this.callbacks[i].call(this, messages[j]); |
||||
} |
||||
} |
||||
}; |
||||
|
||||
/// should be called to uninstall current filter
|
||||
Filter.prototype.uninstall = function() { |
||||
this.impl.uninstallFilter(this.id); |
||||
web3.provider.stopPolling(this.id); |
||||
}; |
||||
|
||||
/// should be called to manually trigger getting latest messages from the client
|
||||
Filter.prototype.messages = function() { |
||||
return this.impl.getMessages(this.id); |
||||
}; |
||||
|
||||
/// alias for messages
|
||||
Filter.prototype.logs = function () { |
||||
return this.messages(); |
||||
}; |
||||
|
||||
module.exports = Filter; |
||||
@ -0,0 +1,70 @@ |
||||
/* |
||||
This file is part of ethereum.js. |
||||
|
||||
ethereum.js 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. |
||||
|
||||
ethereum.js 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 ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
/** @file httpsync.js |
||||
* @authors: |
||||
* Marek Kotewicz <marek@ethdev.com> |
||||
* Marian Oancea <marian@ethdev.com> |
||||
* @date 2014 |
||||
*/ |
||||
|
||||
if (process.env.NODE_ENV !== 'build') { |
||||
var XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest; // jshint ignore:line
|
||||
} |
||||
|
||||
var HttpSyncProvider = function (host) { |
||||
this.handlers = []; |
||||
this.host = host || 'http://localhost:8080'; |
||||
}; |
||||
|
||||
/// Transforms inner message to proper jsonrpc object
|
||||
/// @param inner message object
|
||||
/// @returns jsonrpc object
|
||||
function formatJsonRpcObject(object) { |
||||
return { |
||||
jsonrpc: '2.0', |
||||
method: object.call, |
||||
params: object.args, |
||||
id: object._id |
||||
}; |
||||
} |
||||
|
||||
/// Transforms jsonrpc object to inner message
|
||||
/// @param incoming jsonrpc message
|
||||
/// @returns inner message object
|
||||
function formatJsonRpcMessage(message) { |
||||
var object = JSON.parse(message); |
||||
|
||||
return { |
||||
_id: object.id, |
||||
data: object.result, |
||||
error: object.error |
||||
}; |
||||
} |
||||
|
||||
HttpSyncProvider.prototype.send = function (payload) { |
||||
var data = formatJsonRpcObject(payload); |
||||
|
||||
var request = new XMLHttpRequest(); |
||||
request.open('POST', this.host, false); |
||||
request.send(JSON.stringify(data)); |
||||
|
||||
// check request.status
|
||||
return request.responseText; |
||||
}; |
||||
|
||||
module.exports = HttpSyncProvider; |
||||
|
||||
@ -0,0 +1,18 @@ |
||||
var addressName = {"0x12378912345789": "Gav", "0x57835893478594739854": "Jeff"}; |
||||
var nameAddress = {}; |
||||
|
||||
for (var prop in addressName) { |
||||
if (addressName.hasOwnProperty(prop)) { |
||||
nameAddress[addressName[prop]] = prop; |
||||
} |
||||
} |
||||
|
||||
var local = { |
||||
addressBook:{ |
||||
byName: addressName, |
||||
byAddress: nameAddress |
||||
} |
||||
}; |
||||
|
||||
if (typeof(module) !== "undefined") |
||||
module.exports = local; |
||||
@ -0,0 +1,110 @@ |
||||
/* |
||||
This file is part of ethereum.js. |
||||
|
||||
ethereum.js 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. |
||||
|
||||
ethereum.js 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 ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
/** @file providermanager.js |
||||
* @authors: |
||||
* Jeffrey Wilcke <jeff@ethdev.com> |
||||
* Marek Kotewicz <marek@ethdev.com> |
||||
* Marian Oancea <marian@ethdev.com> |
||||
* Gav Wood <g@ethdev.com> |
||||
* @date 2014 |
||||
*/ |
||||
|
||||
var web3 = require('./web3'); // jshint ignore:line
|
||||
|
||||
/** |
||||
* Provider manager object prototype |
||||
* It's responsible for passing messages to providers |
||||
* If no provider is set it's responsible for queuing requests |
||||
* It's also responsible for polling the ethereum node for incoming messages |
||||
* Default poll timeout is 12 seconds |
||||
* If we are running ethereum.js inside ethereum browser, there are backend based tools responsible for polling, |
||||
* and provider manager polling mechanism is not used |
||||
*/ |
||||
var ProviderManager = function() { |
||||
this.polls = []; |
||||
this.provider = undefined; |
||||
this.id = 1; |
||||
|
||||
var self = this; |
||||
var poll = function () { |
||||
if (self.provider) { |
||||
self.polls.forEach(function (data) { |
||||
data.data._id = self.id; |
||||
self.id++; |
||||
var result = self.provider.send(data.data); |
||||
|
||||
result = JSON.parse(result); |
||||
|
||||
// dont call the callback if result is not an array, or empty one
|
||||
if (result.error || !(result.result instanceof Array) || result.result.length === 0) { |
||||
return; |
||||
} |
||||
|
||||
data.callback(result.result); |
||||
}); |
||||
} |
||||
setTimeout(poll, 1000); |
||||
}; |
||||
poll(); |
||||
}; |
||||
|
||||
/// sends outgoing requests
|
||||
ProviderManager.prototype.send = function(data) { |
||||
|
||||
data.args = data.args || []; |
||||
data._id = this.id++; |
||||
|
||||
if (this.provider === undefined) { |
||||
console.error('provider is not set'); |
||||
return null;
|
||||
} |
||||
|
||||
//TODO: handle error here?
|
||||
var result = this.provider.send(data); |
||||
result = JSON.parse(result); |
||||
|
||||
if (result.error) { |
||||
console.log(result.error); |
||||
return null; |
||||
} |
||||
|
||||
return result.result; |
||||
}; |
||||
|
||||
/// setups provider, which will be used for sending messages
|
||||
ProviderManager.prototype.set = function(provider) { |
||||
this.provider = provider; |
||||
}; |
||||
|
||||
/// this method is only used, when we do not have native qt bindings and have to do polling on our own
|
||||
/// should be callled, on start watching for eth/shh changes
|
||||
ProviderManager.prototype.startPolling = function (data, pollId, callback) { |
||||
this.polls.push({data: data, id: pollId, callback: callback}); |
||||
}; |
||||
|
||||
/// should be called to stop polling for certain watch changes
|
||||
ProviderManager.prototype.stopPolling = function (pollId) { |
||||
for (var i = this.polls.length; i--;) { |
||||
var poll = this.polls[i]; |
||||
if (poll.id === pollId) { |
||||
this.polls.splice(i, 1); |
||||
} |
||||
} |
||||
}; |
||||
|
||||
module.exports = ProviderManager; |
||||
|
||||
@ -0,0 +1,32 @@ |
||||
/* |
||||
This file is part of ethereum.js. |
||||
|
||||
ethereum.js 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. |
||||
|
||||
ethereum.js 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 ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
/** @file qtsync.js |
||||
* @authors: |
||||
* Marek Kotewicz <marek@ethdev.com> |
||||
* Marian Oancea <marian@ethdev.com> |
||||
* @date 2014 |
||||
*/ |
||||
|
||||
var QtSyncProvider = function () { |
||||
}; |
||||
|
||||
QtSyncProvider.prototype.send = function (payload) { |
||||
return navigator.qt.callMethod(JSON.stringify(payload)); |
||||
}; |
||||
|
||||
module.exports = QtSyncProvider; |
||||
|
||||
@ -0,0 +1,327 @@ |
||||
/* |
||||
This file is part of ethereum.js. |
||||
|
||||
ethereum.js 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. |
||||
|
||||
ethereum.js 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 ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
/** @file web3.js |
||||
* @authors: |
||||
* Jeffrey Wilcke <jeff@ethdev.com> |
||||
* Marek Kotewicz <marek@ethdev.com> |
||||
* Marian Oancea <marian@ethdev.com> |
||||
* Gav Wood <g@ethdev.com> |
||||
* @date 2014 |
||||
*/ |
||||
|
||||
if (process.env.NODE_ENV !== 'build') { |
||||
var BigNumber = require('bignumber.js'); |
||||
} |
||||
|
||||
var ETH_UNITS = [
|
||||
'wei',
|
||||
'Kwei',
|
||||
'Mwei',
|
||||
'Gwei',
|
||||
'szabo',
|
||||
'finney',
|
||||
'ether',
|
||||
'grand',
|
||||
'Mether',
|
||||
'Gether',
|
||||
'Tether',
|
||||
'Pether',
|
||||
'Eether',
|
||||
'Zether',
|
||||
'Yether',
|
||||
'Nether',
|
||||
'Dether',
|
||||
'Vether',
|
||||
'Uether'
|
||||
]; |
||||
|
||||
/// @returns an array of objects describing web3 api methods
|
||||
var web3Methods = function () { |
||||
return [ |
||||
{ name: 'sha3', call: 'web3_sha3' } |
||||
]; |
||||
}; |
||||
|
||||
/// @returns an array of objects describing web3.eth api methods
|
||||
var ethMethods = function () { |
||||
var blockCall = function (args) { |
||||
return typeof args[0] === "string" ? "eth_blockByHash" : "eth_blockByNumber"; |
||||
}; |
||||
|
||||
var transactionCall = function (args) { |
||||
return typeof args[0] === "string" ? 'eth_transactionByHash' : 'eth_transactionByNumber'; |
||||
}; |
||||
|
||||
var uncleCall = function (args) { |
||||
return typeof args[0] === "string" ? 'eth_uncleByHash' : 'eth_uncleByNumber'; |
||||
}; |
||||
|
||||
var methods = [ |
||||
{ name: 'balanceAt', call: 'eth_balanceAt' }, |
||||
{ name: 'stateAt', call: 'eth_stateAt' }, |
||||
{ name: 'storageAt', call: 'eth_storageAt' }, |
||||
{ name: 'countAt', call: 'eth_countAt'}, |
||||
{ name: 'codeAt', call: 'eth_codeAt' }, |
||||
{ name: 'transact', call: 'eth_transact' }, |
||||
{ name: 'call', call: 'eth_call' }, |
||||
{ name: 'block', call: blockCall }, |
||||
{ name: 'transaction', call: transactionCall }, |
||||
{ name: 'uncle', call: uncleCall }, |
||||
{ name: 'compilers', call: 'eth_compilers' }, |
||||
{ name: 'flush', call: 'eth_flush' }, |
||||
{ name: 'lll', call: 'eth_lll' }, |
||||
{ name: 'solidity', call: 'eth_solidity' }, |
||||
{ name: 'serpent', call: 'eth_serpent' }, |
||||
{ name: 'logs', call: 'eth_logs' } |
||||
]; |
||||
return methods; |
||||
}; |
||||
|
||||
/// @returns an array of objects describing web3.eth api properties
|
||||
var ethProperties = function () { |
||||
return [ |
||||
{ name: 'coinbase', getter: 'eth_coinbase', setter: 'eth_setCoinbase' }, |
||||
{ name: 'listening', getter: 'eth_listening', setter: 'eth_setListening' }, |
||||
{ name: 'mining', getter: 'eth_mining', setter: 'eth_setMining' }, |
||||
{ name: 'gasPrice', getter: 'eth_gasPrice' }, |
||||
{ name: 'accounts', getter: 'eth_accounts' }, |
||||
{ name: 'peerCount', getter: 'eth_peerCount' }, |
||||
{ name: 'defaultBlock', getter: 'eth_defaultBlock', setter: 'eth_setDefaultBlock' }, |
||||
{ name: 'number', getter: 'eth_number'} |
||||
]; |
||||
}; |
||||
|
||||
/// @returns an array of objects describing web3.db api methods
|
||||
var dbMethods = function () { |
||||
return [ |
||||
{ name: 'put', call: 'db_put' }, |
||||
{ name: 'get', call: 'db_get' }, |
||||
{ name: 'putString', call: 'db_putString' }, |
||||
{ name: 'getString', call: 'db_getString' } |
||||
]; |
||||
}; |
||||
|
||||
/// @returns an array of objects describing web3.shh api methods
|
||||
var shhMethods = function () { |
||||
return [ |
||||
{ name: 'post', call: 'shh_post' }, |
||||
{ name: 'newIdentity', call: 'shh_newIdentity' }, |
||||
{ name: 'haveIdentity', call: 'shh_haveIdentity' }, |
||||
{ name: 'newGroup', call: 'shh_newGroup' }, |
||||
{ name: 'addToGroup', call: 'shh_addToGroup' } |
||||
]; |
||||
}; |
||||
|
||||
/// @returns an array of objects describing web3.eth.watch api methods
|
||||
var ethWatchMethods = function () { |
||||
var newFilter = function (args) { |
||||
return typeof args[0] === 'string' ? 'eth_newFilterString' : 'eth_newFilter'; |
||||
}; |
||||
|
||||
return [ |
||||
{ name: 'newFilter', call: newFilter }, |
||||
{ name: 'uninstallFilter', call: 'eth_uninstallFilter' }, |
||||
{ name: 'getMessages', call: 'eth_filterLogs' } |
||||
]; |
||||
}; |
||||
|
||||
/// @returns an array of objects describing web3.shh.watch api methods
|
||||
var shhWatchMethods = function () { |
||||
return [ |
||||
{ name: 'newFilter', call: 'shh_newFilter' }, |
||||
{ name: 'uninstallFilter', call: 'shh_uninstallFilter' }, |
||||
{ name: 'getMessages', call: 'shh_getMessages' } |
||||
]; |
||||
}; |
||||
|
||||
/// creates methods in a given object based on method description on input
|
||||
/// setups api calls for these methods
|
||||
var setupMethods = function (obj, methods) { |
||||
methods.forEach(function (method) { |
||||
obj[method.name] = function () { |
||||
var args = Array.prototype.slice.call(arguments); |
||||
var call = typeof method.call === 'function' ? method.call(args) : method.call; |
||||
return web3.provider.send({ |
||||
call: call, |
||||
args: args |
||||
}); |
||||
}; |
||||
}); |
||||
}; |
||||
|
||||
/// creates properties in a given object based on properties description on input
|
||||
/// setups api calls for these properties
|
||||
var setupProperties = function (obj, properties) { |
||||
properties.forEach(function (property) { |
||||
var proto = {}; |
||||
proto.get = function () { |
||||
return web3.provider.send({ |
||||
call: property.getter |
||||
}); |
||||
}; |
||||
|
||||
if (property.setter) { |
||||
proto.set = function (val) { |
||||
return web3.provider.send({ |
||||
call: property.setter, |
||||
args: [val] |
||||
}); |
||||
}; |
||||
} |
||||
Object.defineProperty(obj, property.name, proto); |
||||
}); |
||||
}; |
||||
|
||||
/// setups web3 object, and it's in-browser executed methods
|
||||
var web3 = { |
||||
_callbacks: {}, |
||||
_events: {}, |
||||
providers: {}, |
||||
|
||||
toHex: function(str) { |
||||
var hex = ""; |
||||
for(var i = 0; i < str.length; i++) { |
||||
var n = str.charCodeAt(i).toString(16); |
||||
hex += n.length < 2 ? '0' + n : n; |
||||
} |
||||
|
||||
return hex; |
||||
}, |
||||
|
||||
/// @returns ascii string representation of hex value prefixed with 0x
|
||||
toAscii: function(hex) { |
||||
// Find termination
|
||||
var str = ""; |
||||
var i = 0, l = hex.length; |
||||
if (hex.substring(0, 2) === '0x') |
||||
i = 2; |
||||
for(; i < l; i+=2) { |
||||
var code = parseInt(hex.substr(i, 2), 16); |
||||
if(code === 0) { |
||||
break; |
||||
} |
||||
|
||||
str += String.fromCharCode(code); |
||||
} |
||||
|
||||
return str; |
||||
}, |
||||
|
||||
/// @returns hex representation (prefixed by 0x) of ascii string
|
||||
fromAscii: function(str, pad) { |
||||
pad = pad === undefined ? 0 : pad; |
||||
var hex = this.toHex(str); |
||||
while(hex.length < pad*2) |
||||
hex += "00"; |
||||
return "0x" + hex; |
||||
}, |
||||
|
||||
/// @returns decimal representaton of hex value prefixed by 0x
|
||||
toDecimal: function (val) { |
||||
// remove 0x and place 0, if it's required
|
||||
val = val.length > 2 ? val.substring(2) : "0"; |
||||
return (new BigNumber(val, 16).toString(10)); |
||||
}, |
||||
|
||||
/// @returns hex representation (prefixed by 0x) of decimal value
|
||||
fromDecimal: function (val) { |
||||
return "0x" + (new BigNumber(val).toString(16)); |
||||
}, |
||||
|
||||
/// used to transform value/string to eth string
|
||||
/// TODO: use BigNumber.js to parse int
|
||||
toEth: function(str) { |
||||
var val = typeof str === "string" ? str.indexOf('0x') === 0 ? parseInt(str.substr(2), 16) : parseInt(str) : str; |
||||
var unit = 0; |
||||
var units = ETH_UNITS; |
||||
while (val > 3000 && unit < units.length - 1) |
||||
{ |
||||
val /= 1000; |
||||
unit++; |
||||
} |
||||
var s = val.toString().length < val.toFixed(2).length ? val.toString() : val.toFixed(2); |
||||
var replaceFunction = function($0, $1, $2) { |
||||
return $1 + ',' + $2; |
||||
}; |
||||
|
||||
while (true) { |
||||
var o = s; |
||||
s = s.replace(/(\d)(\d\d\d[\.\,])/, replaceFunction); |
||||
if (o === s) |
||||
break; |
||||
} |
||||
return s + ' ' + units[unit]; |
||||
}, |
||||
|
||||
/// eth object prototype
|
||||
eth: { |
||||
contractFromAbi: function (abi) { |
||||
return function(addr) { |
||||
// Default to address of Config. TODO: rremove prior to genesis.
|
||||
addr = addr || '0xc6d9d2cd449a754c494264e1809c50e34d64562b'; |
||||
var ret = web3.eth.contract(addr, abi); |
||||
ret.address = addr; |
||||
return ret; |
||||
}; |
||||
}, |
||||
watch: function (params) { |
||||
return new web3.filter(params, ethWatch); |
||||
} |
||||
}, |
||||
|
||||
/// db object prototype
|
||||
db: {}, |
||||
|
||||
/// shh object prototype
|
||||
shh: { |
||||
watch: function (params) { |
||||
return new web3.filter(params, shhWatch); |
||||
} |
||||
}, |
||||
|
||||
/// @returns true if provider is installed
|
||||
haveProvider: function() { |
||||
return !!web3.provider.provider; |
||||
} |
||||
}; |
||||
|
||||
/// setups all api methods
|
||||
setupMethods(web3, web3Methods()); |
||||
setupMethods(web3.eth, ethMethods()); |
||||
setupProperties(web3.eth, ethProperties()); |
||||
setupMethods(web3.db, dbMethods()); |
||||
setupMethods(web3.shh, shhMethods()); |
||||
|
||||
var ethWatch = { |
||||
changed: 'eth_changed' |
||||
}; |
||||
|
||||
setupMethods(ethWatch, ethWatchMethods()); |
||||
|
||||
var shhWatch = { |
||||
changed: 'shh_changed' |
||||
}; |
||||
|
||||
setupMethods(shhWatch, shhWatchMethods()); |
||||
|
||||
web3.setProvider = function(provider) { |
||||
//provider.onmessage = messageHandler; // there will be no async calls, to remove
|
||||
web3.provider.set(provider); |
||||
}; |
||||
|
||||
module.exports = web3; |
||||
|
||||
@ -0,0 +1,69 @@ |
||||
{ |
||||
"name": "ethereum.js", |
||||
"namespace": "ethereum", |
||||
"version": "0.0.10", |
||||
"description": "Ethereum Compatible JavaScript API", |
||||
"main": "./index.js", |
||||
"directories": { |
||||
"lib": "./lib" |
||||
}, |
||||
"dependencies": { |
||||
"ws": "*", |
||||
"xmlhttprequest": "*", |
||||
"bignumber.js": ">=2.0.0" |
||||
}, |
||||
"devDependencies": { |
||||
"bower": ">=1.3.0", |
||||
"browserify": ">=6.0", |
||||
"del": ">=0.1.1", |
||||
"envify": "^3.0.0", |
||||
"exorcist": "^0.1.6", |
||||
"gulp": ">=3.4.0", |
||||
"gulp-jshint": ">=1.5.0", |
||||
"gulp-rename": ">=1.2.0", |
||||
"gulp-uglify": ">=1.0.0", |
||||
"jshint": ">=2.5.0", |
||||
"uglifyify": "^2.6.0", |
||||
"unreachable-branch-transform": "^0.1.0", |
||||
"vinyl-source-stream": "^1.0.0", |
||||
"mocha": ">=2.1.0" |
||||
}, |
||||
"scripts": { |
||||
"build": "gulp", |
||||
"watch": "gulp watch", |
||||
"lint": "gulp lint", |
||||
"test": "mocha" |
||||
}, |
||||
"repository": { |
||||
"type": "git", |
||||
"url": "https://github.com/ethereum/ethereum.js.git" |
||||
}, |
||||
"homepage": "https://github.com/ethereum/ethereum.js", |
||||
"bugs": { |
||||
"url": "https://github.com/ethereum/ethereum.js/issues" |
||||
}, |
||||
"keywords": [ |
||||
"ethereum", |
||||
"javascript", |
||||
"API" |
||||
], |
||||
"author": "ethdev.com", |
||||
"authors": [ |
||||
{ |
||||
"name": "Jeffery Wilcke", |
||||
"email": "jeff@ethdev.com", |
||||
"url": "https://github.com/obscuren" |
||||
}, |
||||
{ |
||||
"name": "Marek Kotewicz", |
||||
"email": "marek@ethdev.com", |
||||
"url": "https://github.com/debris" |
||||
}, |
||||
{ |
||||
"name": "Marian Oancea", |
||||
"email": "marian@ethdev.com", |
||||
"url": "https://github.com/cubedro" |
||||
} |
||||
], |
||||
"license": "LGPL-3.0" |
||||
} |
||||
@ -0,0 +1,860 @@ |
||||
var assert = require('assert'); |
||||
var BigNumber = require('bignumber.js'); |
||||
var abi = require('../lib/abi.js'); |
||||
var clone = function (object) { return JSON.parse(JSON.stringify(object)); }; |
||||
|
||||
var description = [{ |
||||
"name": "test", |
||||
"inputs": [{ |
||||
"name": "a", |
||||
"type": "uint256" |
||||
} |
||||
], |
||||
"outputs": [ |
||||
{ |
||||
"name": "d", |
||||
"type": "uint256" |
||||
} |
||||
] |
||||
}]; |
||||
|
||||
describe('abi', function() { |
||||
describe('inputParser', function() { |
||||
it('should parse input uint', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "uint" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001"); |
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a"); |
||||
assert.equal( |
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal( |
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)), |
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
|
||||
}); |
||||
|
||||
it('should parse input uint128', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "uint128" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001"); |
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a"); |
||||
assert.equal( |
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal( |
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)), |
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
|
||||
}); |
||||
|
||||
it('should parse input uint256', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "uint256" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001"); |
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a"); |
||||
assert.equal( |
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal( |
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)), |
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
|
||||
}); |
||||
|
||||
it('should parse input int', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "int" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001"); |
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a"); |
||||
assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); |
||||
assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"); |
||||
assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0"); |
||||
assert.equal( |
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal( |
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)), |
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
}); |
||||
|
||||
it('should parse input int128', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "int128" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001"); |
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a"); |
||||
assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); |
||||
assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"); |
||||
assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0"); |
||||
assert.equal( |
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal( |
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)), |
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
|
||||
}); |
||||
|
||||
it('should parse input int256', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "int256" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001"); |
||||
assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a"); |
||||
assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); |
||||
assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"); |
||||
assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0"); |
||||
assert.equal( |
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal( |
||||
parser.test(new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16)), |
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" |
||||
); |
||||
assert.equal(parser.test(0.1), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test(3.9), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
assert.equal(parser.test('0.1'), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
assert.equal(parser.test('3.9'), "0000000000000000000000000000000000000000000000000000000000000003"); |
||||
|
||||
}); |
||||
|
||||
it('should parse input bool', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: 'bool' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test(true), "0000000000000000000000000000000000000000000000000000000000000001"); |
||||
assert.equal(parser.test(false), "0000000000000000000000000000000000000000000000000000000000000000"); |
||||
|
||||
}); |
||||
|
||||
it('should parse input hash', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "hash" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"); |
||||
|
||||
});
|
||||
|
||||
it('should parse input hash256', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "hash256" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"); |
||||
|
||||
}); |
||||
|
||||
|
||||
it('should parse input hash160', function() { |
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "hash160" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"); |
||||
}); |
||||
|
||||
it('should parse input address', function () { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "address" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d) |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1"); |
||||
|
||||
}); |
||||
|
||||
it('should parse input string', function () { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "string" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal( |
||||
parser.test('hello'),
|
||||
"000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000" |
||||
); |
||||
assert.equal( |
||||
parser.test('world'), |
||||
"0000000000000000000000000000000000000000000000000000000000000005776f726c64000000000000000000000000000000000000000000000000000000" |
||||
); |
||||
}); |
||||
|
||||
it('should use proper method name', function () { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
d[0].name = 'helloworld(int)'; |
||||
d[0].inputs = [ |
||||
{ type: "int" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.helloworld(1), "0000000000000000000000000000000000000000000000000000000000000001"); |
||||
assert.equal(parser.helloworld['int'](1), "0000000000000000000000000000000000000000000000000000000000000001"); |
||||
|
||||
}); |
||||
|
||||
it('should parse multiple methods', function () { |
||||
|
||||
// given
|
||||
var d = [{ |
||||
name: "test", |
||||
inputs: [{ type: "int" }], |
||||
outputs: [{ type: "int" }] |
||||
},{ |
||||
name: "test2", |
||||
inputs: [{ type: "string" }], |
||||
outputs: [{ type: "string" }] |
||||
}]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
//then
|
||||
assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001"); |
||||
assert.equal( |
||||
parser.test2('hello'),
|
||||
"000000000000000000000000000000000000000000000000000000000000000568656c6c6f000000000000000000000000000000000000000000000000000000" |
||||
); |
||||
|
||||
}); |
||||
|
||||
it('should parse input array of ints', function () { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: "int[]" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal( |
||||
parser.test([5, 6]), |
||||
"0000000000000000000000000000000000000000000000000000000000000002" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000006" |
||||
); |
||||
}); |
||||
|
||||
it('should parse input real', function () { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: 'real' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test([1]), "0000000000000000000000000000000100000000000000000000000000000000");
|
||||
assert.equal(parser.test([2.125]), "0000000000000000000000000000000220000000000000000000000000000000");
|
||||
assert.equal(parser.test([8.5]), "0000000000000000000000000000000880000000000000000000000000000000");
|
||||
assert.equal(parser.test([-1]), "ffffffffffffffffffffffffffffffff00000000000000000000000000000000");
|
||||
|
||||
}); |
||||
|
||||
it('should parse input ureal', function () { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].inputs = [ |
||||
{ type: 'ureal' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.inputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test([1]), "0000000000000000000000000000000100000000000000000000000000000000");
|
||||
assert.equal(parser.test([2.125]), "0000000000000000000000000000000220000000000000000000000000000000");
|
||||
assert.equal(parser.test([8.5]), "0000000000000000000000000000000880000000000000000000000000000000");
|
||||
|
||||
}); |
||||
|
||||
}); |
||||
|
||||
describe('outputParser', function() { |
||||
it('should parse output string', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: "string" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal( |
||||
parser.test("0x" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" + |
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000")[0], |
||||
'hello' |
||||
); |
||||
assert.equal( |
||||
parser.test("0x" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" + |
||||
"776f726c64000000000000000000000000000000000000000000000000000000")[0],
|
||||
'world' |
||||
); |
||||
|
||||
}); |
||||
|
||||
it('should parse output uint', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'uint' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
||||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
||||
assert.equal( |
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10),
|
||||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10) |
||||
); |
||||
assert.equal( |
||||
parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10),
|
||||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10) |
||||
); |
||||
}); |
||||
|
||||
it('should parse output uint256', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'uint256' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
||||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
||||
assert.equal( |
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10),
|
||||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10) |
||||
); |
||||
assert.equal( |
||||
parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10),
|
||||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10) |
||||
); |
||||
}); |
||||
|
||||
it('should parse output uint128', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'uint128' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
||||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
||||
assert.equal( |
||||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10),
|
||||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10) |
||||
); |
||||
assert.equal( |
||||
parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10),
|
||||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10) |
||||
); |
||||
}); |
||||
|
||||
it('should parse output int', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'int' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
||||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
||||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1); |
||||
assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16); |
||||
}); |
||||
|
||||
it('should parse output int256', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'int256' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
||||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
||||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1); |
||||
assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16); |
||||
}); |
||||
|
||||
it('should parse output int128', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'int128' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
||||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
||||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1); |
||||
assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16); |
||||
}); |
||||
|
||||
it('should parse output hash', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'hash' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal( |
||||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
||||
"0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1" |
||||
); |
||||
}); |
||||
|
||||
it('should parse output hash256', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'hash256' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal( |
||||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
||||
"0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1" |
||||
); |
||||
}); |
||||
|
||||
it('should parse output hash160', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'hash160' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal( |
||||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
||||
"0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1" |
||||
); |
||||
// TODO shouldnt' the expected hash be shorter?
|
||||
}); |
||||
|
||||
it('should parse output address', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'address' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal( |
||||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
||||
"0x407d73d8a49eeb85d32cf465507dd71d507100c1" |
||||
); |
||||
}); |
||||
|
||||
it('should parse output bool', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'bool' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], true); |
||||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000000")[0], false); |
||||
|
||||
|
||||
}); |
||||
|
||||
it('should parse output real', function() { |
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'real' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1); |
||||
assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125);
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5);
|
||||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffff00000000000000000000000000000000")[0], -1);
|
||||
|
||||
}); |
||||
|
||||
it('should parse output ureal', function() { |
||||
|
||||
// given
|
||||
var d = clone(description);
|
||||
|
||||
d[0].outputs = [ |
||||
{ type: 'ureal' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1); |
||||
assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125);
|
||||
assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5);
|
||||
|
||||
}); |
||||
|
||||
|
||||
it('should parse multiple output strings', function() { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
|
||||
d[0].outputs = [ |
||||
{ type: "string" }, |
||||
{ type: "string" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal( |
||||
parser.test("0x" + |
||||
"0000000000000000000000000000000000000000000000000000000000000005" + |
||||
"0000000000000000000000000000000000000000000000000000000000000005" + |
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000" +
|
||||
"776f726c64000000000000000000000000000000000000000000000000000000")[0], |
||||
'hello' |
||||
); |
||||
assert.equal( |
||||
parser.test("0x" + |
||||
"0000000000000000000000000000000000000000000000000000000000000005" + |
||||
"0000000000000000000000000000000000000000000000000000000000000005" + |
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000" +
|
||||
"776f726c64000000000000000000000000000000000000000000000000000000")[1], |
||||
'world' |
||||
); |
||||
|
||||
}); |
||||
|
||||
it('should use proper method name', function () { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
d[0].name = 'helloworld(int)'; |
||||
d[0].outputs = [ |
||||
{ type: "int" } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.helloworld("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
||||
assert.equal(parser.helloworld['int']("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
||||
|
||||
}); |
||||
|
||||
|
||||
it('should parse multiple methods', function () { |
||||
|
||||
// given
|
||||
var d = [{ |
||||
name: "test", |
||||
inputs: [{ type: "int" }], |
||||
outputs: [{ type: "int" }] |
||||
},{ |
||||
name: "test2", |
||||
inputs: [{ type: "string" }], |
||||
outputs: [{ type: "string" }] |
||||
}]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
//then
|
||||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
||||
assert.equal(parser.test2("0x" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" + |
||||
"68656c6c6f000000000000000000000000000000000000000000000000000000")[0], |
||||
"hello" |
||||
); |
||||
|
||||
}); |
||||
|
||||
it('should parse output array', function () { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
d[0].outputs = [ |
||||
{ type: 'int[]' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x" + |
||||
"0000000000000000000000000000000000000000000000000000000000000002" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000006")[0][0], |
||||
5 |
||||
); |
||||
assert.equal(parser.test("0x" + |
||||
"0000000000000000000000000000000000000000000000000000000000000002" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000005" +
|
||||
"0000000000000000000000000000000000000000000000000000000000000006")[0][1], |
||||
6 |
||||
); |
||||
|
||||
}); |
||||
|
||||
it('should parse 0x value', function () { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
d[0].outputs = [ |
||||
{ type: 'int' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x")[0], 0); |
||||
|
||||
}); |
||||
|
||||
it('should parse 0x value', function () { |
||||
|
||||
// given
|
||||
var d = clone(description); |
||||
d[0].outputs = [ |
||||
{ type: 'uint' } |
||||
]; |
||||
|
||||
// when
|
||||
var parser = abi.outputParser(d); |
||||
|
||||
// then
|
||||
assert.equal(parser.test("0x")[0], 0); |
||||
|
||||
}); |
||||
|
||||
}); |
||||
}); |
||||
|
||||
@ -0,0 +1,14 @@ |
||||
|
||||
var assert = require('assert'); |
||||
var web3 = require('../index.js'); |
||||
var u = require('./utils.js'); |
||||
|
||||
describe('web3', function() { |
||||
describe('db', function() { |
||||
u.methodExists(web3.db, 'put'); |
||||
u.methodExists(web3.db, 'get'); |
||||
u.methodExists(web3.db, 'putString'); |
||||
u.methodExists(web3.db, 'getString'); |
||||
}); |
||||
}); |
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue