Skip to content

G
Geth-Modification
Commit 21fd31da authored by Taylor Gerring's avatar Taylor Gerring
Browse files
Options

Merge branch 'jsonrpc' of github.com:ethereum/go-ethereum into jsonrpc

parents a88f609b 872b2497
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 697 additions and 701 deletions
.gitignore
View file @ 21fd31da
......@@ -15,3 +15,5 @@
.#*
*#
*~
.project
.settings
README.md
View file @ 21fd31da
[![Bugs](https://badge.waffle.io/ethereum/go-ethereum.png?label=bug&title=Bugs)](https://waffle.io/ethereum/go-ethereum)
[![Stories in Ready](https://badge.waffle.io/ethereum/go-ethereum.png?label=ready&title=Ready)](https://waffle.io/ethereum/go-ethereum)
[![Stories in
Progress](https://badge.waffle.io/ethereum/go-ethereum.svg?label=in%20progress&title=In Progress)](http://waffle.io/ethereum/go-ethereum)
[![Stories in Progress](https://badge.waffle.io/ethereum/go-ethereum.svg?label=in%20progress&title=In Progress)](http://waffle.io/ethereum/go-ethereum)
[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ethereum/go-ethereum?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
Ethereum
Ethereum PoC-8
========
[![Build
Status](http://build.ethdev.com/buildstatusimage?builder=Linux%20Go%20master%20branch)](http://build.ethdev.com:8010/builders/Linux%20Go%20master%20branch/builds/-1) master [![Build
Status](http://build.ethdev.com/buildstatusimage?builder=Linux%20Go%20develop%20branch)](http://build.ethdev.com:8010/builders/Linux%20Go%20develop%20branch/builds/-1) develop
[![Coverage Status](https://coveralls.io/repos/ethereum/go-ethereum/badge.png?branch=tests)](https://coveralls.io/r/ethereum/go-ethereum?branch=tests) tests
* [![Build Status](http://build.ethdev.com/buildstatusimage?builder=Linux%20Go%20master%20branch)](http://build.ethdev.com:8010/builders/Linux%20Go%20master%20branch/builds/-1) master
* [![Build Status](http://build.ethdev.com/buildstatusimage?builder=Linux%20Go%20develop%20branch)](http://build.ethdev.com:8010/builders/Linux%20Go%20develop%20branch/builds/-1) develop
* [![Travis-ci](https://api.travis-ci.org/ethereum/go-ethereum.svg)](https://travis-ci.org/ethereum/go-ethereum) travis-ci
* [![Coverage Status](https://coveralls.io/repos/ethereum/go-ethereum/badge.png?branch=tests)](https://coveralls.io/r/ethereum/go-ethereum?branch=tests)
Ethereum Go Client © 2014 Jeffrey Wilcke.
Current state: Proof of Concept 0.8
Ethereum is currently in its testing phase.
Build
=====
To build Mist (GUI):
Mist (GUI):
`go get github.com/ethereum/go-ethereum/cmd/mist`
To build the node (CLI):
Ethereum (CLI):
`go get github.com/ethereum/go-ethereum/cmd/ethereum`
......@@ -49,6 +46,8 @@ Go Ethereum comes with several binaries found in
`cat file | ethtest`.
* `evm` is a generic Ethereum Virtual Machine: `evm -code 60ff60ff -gas
10000 -price 0 -dump`. See `-h` for a detailed description.
* `rlpdump` converts a rlp stream to `interface{}`.
* `peerserver` simple P2P (noi-ethereum) peer server.
General command line options
============================
......@@ -125,3 +124,4 @@ expect you to write tests for me so I don't have to test your code
manually. (If you want to contribute by just writing tests that's fine
too!)
cmd/mist/assets/qml/main.qml
View file @ 21fd31da
......@@ -56,7 +56,9 @@ ApplicationWindow {
mainSplit.setView(wallet.view, wallet.menuItem);
newBrowserTab("http://etherian.io");
console.log(">>>>>>")
newBrowserTab("http://etherian.io");
console.log("WTF")
// Command setup
gui.sendCommand(0)
......
cmd/mist/assets/qml/views/wallet.qml
View file @ 21fd31da
......@@ -22,7 +22,8 @@ Rectangle {
function setBalance() {
//balance.text = "<b>Balance</b>: " + eth.numberToHuman(eth.balanceAt(eth.key().address))
if(menuItem)
menuItem.secondaryTitle = eth.numberToHuman(eth.balanceAt(eth.key().address))
menuItem.secondaryTitle = eth.numberToHuman("0")
//menuItem.secondaryTitle = eth.numberToHuman(eth.balanceAt(eth.key().address))
}
ListModel {
......@@ -155,14 +156,6 @@ Rectangle {
model: ListModel {
id: txModel
Component.onCompleted: {
var me = eth.key().address;
var filterTo = ethx.watch({latest: -1, to: me});
var filterFrom = ethx.watch({latest: -1, from: me});
filterTo.changed(addTxs)
filterFrom.changed(addTxs)
addTxs(filterTo.messages())
addTxs(filterFrom.messages())
}
function addTxs(messages) {
......
cmd/mist/ext_app.go
View file @ 21fd31da
......@@ -47,7 +47,7 @@ type AppContainer interface {
}
type ExtApplication struct {
*xeth.JSXEth
*xeth.XEth
eth core.EthManager
events event.Subscription
......@@ -61,7 +61,7 @@ type ExtApplication struct {
func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication {
return &ExtApplication{
JSXEth: xeth.NewJSXEth(lib.eth),
XEth: xeth.New(lib.eth),
eth: lib.eth,
watcherQuitChan: make(chan bool),
filters: make(map[string]*core.Filter),
......
cmd/mist/gui.go
View file @ 21fd31da
......@@ -32,7 +32,6 @@ import (
"path"
"runtime"
"strconv"
"strings"
"time"
"github.com/ethereum/go-ethereum/core"
......@@ -76,7 +75,7 @@ type Gui struct {
logLevel logger.LogLevel
open bool
xeth *xeth.JSXEth
xeth *xeth.XEth
Session string
clientIdentity *p2p.SimpleClientIdentity
......@@ -94,7 +93,7 @@ func NewWindow(ethereum *eth.Ethereum, config *ethutil.ConfigManager, clientIden
panic(err)
}
xeth := xeth.NewJSXEth(ethereum)
xeth := xeth.New(ethereum)
gui := &Gui{eth: ethereum,
txDb: db,
xeth: xeth,
......@@ -121,9 +120,9 @@ func (gui *Gui) Start(assetPath string) {
// Register ethereum functions
qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{
Init: func(p *xeth.JSBlock, obj qml.Object) { p.Number = 0; p.Hash = "" },
Init: func(p *xeth.Block, obj qml.Object) { p.Number = 0; p.Hash = "" },
}, {
Init: func(p *xeth.JSTransaction, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" },
Init: func(p *xeth.Transaction, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" },
}, {
Init: func(p *xeth.KeyVal, obj qml.Object) { p.Key = ""; p.Value = "" },
}})
......@@ -229,41 +228,44 @@ func (gui *Gui) setInitialChain(ancientBlocks bool) {
}
func (gui *Gui) loadAddressBook() {
view := gui.getObjectByName("infoView")
nameReg := gui.xeth.World().Config().Get("NameReg")
if nameReg != nil {
it := nameReg.Trie().Iterator()
for it.Next() {
if it.Key[0] != 0 {
view.Call("addAddress", struct{ Name, Address string }{string(it.Key), ethutil.Bytes2Hex(it.Value)})
}
/*
view := gui.getObjectByName("infoView")
nameReg := gui.xeth.World().Config().Get("NameReg")
if nameReg != nil {
it := nameReg.Trie().Iterator()
for it.Next() {
if it.Key[0] != 0 {
view.Call("addAddress", struct{ Name, Address string }{string(it.Key), ethutil.Bytes2Hex(it.Value)})
}
}
}
}
*/
}
func (self *Gui) loadMergedMiningOptions() {
view := self.getObjectByName("mergedMiningModel")
mergeMining := self.xeth.World().Config().Get("MergeMining")
if mergeMining != nil {
i := 0
it := mergeMining.Trie().Iterator()
for it.Next() {
view.Call("addMergedMiningOption", struct {
Checked bool
Name, Address string
Id, ItemId int
}{false, string(it.Key), ethutil.Bytes2Hex(it.Value), 0, i})
i++
/*
view := self.getObjectByName("mergedMiningModel")
mergeMining := self.xeth.World().Config().Get("MergeMining")
if mergeMining != nil {
i := 0
it := mergeMining.Trie().Iterator()
for it.Next() {
view.Call("addMergedMiningOption", struct {
Checked bool
Name, Address string
Id, ItemId int
}{false, string(it.Key), ethutil.Bytes2Hex(it.Value), 0, i})
i++
}
}
}
*/
}
func (gui *Gui) insertTransaction(window string, tx *types.Transaction) {
nameReg := gui.xeth.World().Config().Get("NameReg")
addr := gui.address()
var inout string
......@@ -274,32 +276,12 @@ func (gui *Gui) insertTransaction(window string, tx *types.Transaction) {
}
var (
ptx = xeth.NewJSTx(tx)
send = nameReg.Storage(tx.From())
rec = nameReg.Storage(tx.To())
s, r string
ptx = xeth.NewTx(tx)
send = ethutil.Bytes2Hex(tx.From())
rec = ethutil.Bytes2Hex(tx.To())
)
if core.MessageCreatesContract(tx) {
rec = nameReg.Storage(core.AddressFromMessage(tx))
}
if send.Len() != 0 {
s = strings.Trim(send.Str(), "\x00")
} else {
s = ethutil.Bytes2Hex(tx.From())
}
if rec.Len() != 0 {
r = strings.Trim(rec.Str(), "\x00")
} else {
if core.MessageCreatesContract(tx) {
r = ethutil.Bytes2Hex(core.AddressFromMessage(tx))
} else {
r = ethutil.Bytes2Hex(tx.To())
}
}
ptx.Sender = s
ptx.Address = r
ptx.Sender = send
ptx.Address = rec
if window == "post" {
//gui.getObjectByName("transactionView").Call("addTx", ptx, inout)
......@@ -320,8 +302,8 @@ func (gui *Gui) readPreviousTransactions() {
}
func (gui *Gui) processBlock(block *types.Block, initial bool) {
name := strings.Trim(gui.xeth.World().Config().Get("NameReg").Storage(block.Coinbase()).Str(), "\x00")
b := xeth.NewJSBlock(block)
name := ethutil.Bytes2Hex(block.Coinbase())
b := xeth.NewBlock(block)
b.Name = name
gui.getObjectByName("chainView").Call("addBlock", b, initial)
......@@ -531,9 +513,9 @@ NumGC: %d
func (gui *Gui) setPeerInfo() {
gui.win.Root().Call("setPeers", fmt.Sprintf("%d / %d", gui.eth.PeerCount(), gui.eth.MaxPeers))
gui.win.Root().Call("resetPeers")
for _, peer := range gui.xeth.Peers() {
gui.win.Root().Call("addPeer", peer)
}
//for _, peer := range gui.xeth.Peers() {
//gui.win.Root().Call("addPeer", peer)
//}
}
func (gui *Gui) privateKey() string {
......
cmd/mist/html_container.go
View file @ 21fd31da
......@@ -142,7 +142,7 @@ func (app *HtmlApplication) Window() *qml.Window {
}
func (app *HtmlApplication) NewBlock(block *types.Block) {
b := &xeth.JSBlock{Number: int(block.NumberU64()), Hash: ethutil.Bytes2Hex(block.Hash())}
b := &xeth.Block{Number: int(block.NumberU64()), Hash: ethutil.Bytes2Hex(block.Hash())}
app.webView.Call("onNewBlockCb", b)
}
......
cmd/mist/qml_container.go
View file @ 21fd31da
......@@ -70,7 +70,7 @@ func (app *QmlApplication) NewWatcher(quitChan chan bool) {
// Events
func (app *QmlApplication) NewBlock(block *types.Block) {
pblock := &xeth.JSBlock{Number: int(block.NumberU64()), Hash: ethutil.Bytes2Hex(block.Hash())}
pblock := &xeth.Block{Number: int(block.NumberU64()), Hash: ethutil.Bytes2Hex(block.Hash())}
app.win.Call("onNewBlockCb", pblock)
}
......
cmd/mist/ui_lib.go
View file @ 21fd31da
......@@ -21,15 +21,11 @@
package main
import (
"bytes"
"fmt"
"path"
"strconv"
"strings"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/eth"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/event/filter"
......@@ -48,7 +44,7 @@ type memAddr struct {
// UI Library that has some basic functionality exposed
type UiLib struct {
*xeth.JSXEth
*xeth.XEth
engine *qml.Engine
eth *eth.Ethereum
connected bool
......@@ -67,7 +63,7 @@ type UiLib struct {
}
func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib {
lib := &UiLib{JSXEth: xeth.NewJSXEth(eth), engine: engine, eth: eth, assetPath: assetPath, jsEngine: javascript.NewJSRE(eth), filterCallbacks: make(map[int][]int)} //, filters: make(map[int]*xeth.JSFilter)}
lib := &UiLib{XEth: xeth.New(eth), engine: engine, eth: eth, assetPath: assetPath, jsEngine: javascript.NewJSRE(eth), filterCallbacks: make(map[int][]int)} //, filters: make(map[int]*xeth.JSFilter)}
lib.miner = miner.New(eth.KeyManager().Address(), eth)
lib.filterManager = filter.NewFilterManager(eth.EventMux())
go lib.filterManager.Start()
......@@ -79,56 +75,6 @@ func (self *UiLib) Notef(args []interface{}) {
guilogger.Infoln(args...)
}
func (self *UiLib) LookupDomain(domain string) string {
world := self.World()
if len(domain) > 32 {
domain = string(crypto.Sha3([]byte(domain)))
}
data := world.Config().Get("DnsReg").StorageString(domain).Bytes()
// Left padded = A record, Right padded = CNAME
if len(data) > 0 && data[0] == 0 {
data = bytes.TrimLeft(data, "\x00")
var ipSlice []string
for _, d := range data {
ipSlice = append(ipSlice, strconv.Itoa(int(d)))
}
return strings.Join(ipSlice, ".")
} else {
data = bytes.TrimRight(data, "\x00")
return string(data)
}
}
func (self *UiLib) LookupName(addr string) string {
var (
nameReg = self.World().Config().Get("NameReg")
lookup = nameReg.Storage(ethutil.Hex2Bytes(addr))
)
if lookup.Len() != 0 {
return strings.Trim(lookup.Str(), "\x00")
}
return addr
}
func (self *UiLib) LookupAddress(name string) string {
var (
nameReg = self.World().Config().Get("NameReg")
lookup = nameReg.Storage(ethutil.RightPadBytes([]byte(name), 32))
)
if lookup.Len() != 0 {
return ethutil.Bytes2Hex(lookup.Bytes())
}
return ""
}
func (self *UiLib) PastPeers() *ethutil.List {
return ethutil.NewList([]string{})
//return ethutil.NewList(eth.PastPeers())
......@@ -234,7 +180,7 @@ func (self *UiLib) StartDebugger() {
func (self *UiLib) Transact(params map[string]interface{}) (string, error) {
object := mapToTxParams(params)
return self.JSXEth.Transact(
return self.XEth.Transact(
object["from"],
object["to"],
object["value"],
......@@ -256,7 +202,7 @@ func (self *UiLib) Compile(code string) (string, error) {
func (self *UiLib) Call(params map[string]interface{}) (string, error) {
object := mapToTxParams(params)
return self.JSXEth.Execute(
return self.XEth.Execute(
object["to"],
object["value"],
object["gas"],
......@@ -315,7 +261,7 @@ func (self *UiLib) ToAscii(data string) string {
func (self *UiLib) NewFilter(object map[string]interface{}, view *qml.Common) (id int) {
filter := qt.NewFilterFromMap(object, self.eth)
filter.MessageCallback = func(messages state.Messages) {
view.Call("messages", xeth.ToJSMessages(messages), id)
view.Call("messages", xeth.ToMessages(messages), id)
}
id = self.filterManager.InstallFilter(filter)
return id
......@@ -333,7 +279,7 @@ func (self *UiLib) NewFilterString(typ string, view *qml.Common) (id int) {
func (self *UiLib) Messages(id int) *ethutil.List {
filter := self.filterManager.GetFilter(id)
if filter != nil {
messages := xeth.ToJSMessages(filter.Find())
messages := xeth.ToMessages(filter.Find())
return messages
}
......
cmd/utils/cmd.go
View file @ 21fd31da
......@@ -194,7 +194,7 @@ func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, Secre
func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
var err error
ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.NewJSXEth(ethereum), RpcPort)
ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.New(ethereum), RpcPort)
if err != nil {
clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
} else {
......
core/chain_manager_test.go
View file @ 21fd31da
......@@ -46,6 +46,8 @@ func insertChain(done chan bool, chainMan *ChainManager, chain types.Blocks, t *
}
func TestChainInsertions(t *testing.T) {
t.Skip() // travil fails.
db, _ := ethdb.NewMemDatabase()
chain1, err := loadChain("valid1", t)
......@@ -86,6 +88,8 @@ func TestChainInsertions(t *testing.T) {
}
func TestChainMultipleInsertions(t *testing.T) {
t.Skip() // travil fails.
db, _ := ethdb.NewMemDatabase()
const max = 4
......@@ -130,6 +134,8 @@ func TestChainMultipleInsertions(t *testing.T) {
}
func TestGetAncestors(t *testing.T) {
t.Skip() // travil fails.
db, _ := ethdb.NewMemDatabase()
var eventMux event.TypeMux
chainMan := NewChainManager(db, &eventMux)
......
core/genesis.go
View file @ 21fd31da
......@@ -34,7 +34,7 @@ func GenesisBlock(db ethutil.Database) *types.Block {
statedb := state.New(genesis.Root(), db)
//statedb := state.New(genesis.Trie())
for _, addr := range []string{
"51ba59315b3a95761d0863b05ccc7a7f54703d99",
"dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6",
"e4157b34ea9615cfbde6b4fda419828124b70c78",
"b9c015918bdaba24b4ff057a92a3873d6eb201be",
"6c386a4b26f73c802f34673f7248bb118f97424a",
......
eth/backend.go
View file @ 21fd31da
......@@ -219,6 +219,10 @@ func (s *Ethereum) MaxPeers() int {
return s.net.MaxPeers
}
func (s *Ethereum) Coinbase() []byte {
return nil // TODO
}
// Start the ethereum
func (s *Ethereum) Start(seed bool) error {
err := s.net.Start()
......
javascript/javascript_runtime.go
View file @ 21fd31da
......@@ -24,7 +24,7 @@ var jsrelogger = logger.NewLogger("JSRE")
type JSRE struct {
ethereum *eth.Ethereum
Vm *otto.Otto
pipe *xeth.JSXEth
pipe *xeth.XEth
events event.Subscription
......@@ -49,7 +49,7 @@ func NewJSRE(ethereum *eth.Ethereum) *JSRE {
re := &JSRE{
ethereum,
otto.New(),
xeth.NewJSXEth(ethereum),
xeth.New(ethereum),
nil,
make(map[string][]otto.Value),
}
......
javascript/types.go
View file @ 21fd31da
......@@ -12,14 +12,14 @@ import (
)
type JSStateObject struct {
*xeth.JSObject
*xeth.Object
eth *JSEthereum
}
func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value {
cb := call.Argument(0)
it := self.JSObject.Trie().Iterator()
it := self.Object.Trie().Iterator()
for it.Next() {
cb.Call(self.eth.toVal(self), self.eth.toVal(ethutil.Bytes2Hex(it.Key)), self.eth.toVal(ethutil.Bytes2Hex(it.Value)))
}
......@@ -30,12 +30,12 @@ func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value {
// The JSEthereum object attempts to wrap the PEthereum object and returns
// meaningful javascript objects
type JSBlock struct {
*xeth.JSBlock
*xeth.Block
eth *JSEthereum
}
func (self *JSBlock) GetTransaction(hash string) otto.Value {
return self.eth.toVal(self.JSBlock.GetTransaction(hash))
return self.eth.toVal(self.Block.GetTransaction(hash))
}
type JSMessage struct {
......@@ -67,35 +67,27 @@ func NewJSMessage(message *state.Message) JSMessage {
}
type JSEthereum struct {
*xeth.JSXEth
*xeth.XEth
vm *otto.Otto
ethereum *eth.Ethereum
}
func (self *JSEthereum) Block(v interface{}) otto.Value {
if number, ok := v.(int64); ok {
return self.toVal(&JSBlock{self.JSXEth.BlockByNumber(int32(number)), self})
return self.toVal(&JSBlock{self.XEth.BlockByNumber(int32(number)), self})
} else if hash, ok := v.(string); ok {
return self.toVal(&JSBlock{self.JSXEth.BlockByHash(hash), self})
return self.toVal(&JSBlock{self.XEth.BlockByHash(hash), self})
}
return otto.UndefinedValue()
}
func (self *JSEthereum) Peers() otto.Value {
return self.toVal(self.JSXEth.Peers())
}
func (self *JSEthereum) Key() otto.Value {
return self.toVal(self.JSXEth.Key())
}
func (self *JSEthereum) GetStateObject(addr string) otto.Value {
return self.toVal(&JSStateObject{xeth.NewJSObject(self.JSXEth.World().SafeGet(ethutil.Hex2Bytes(addr))), self})
return self.toVal(&JSStateObject{self.XEth.State().SafeGet(addr), self})
}
func (self *JSEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value {
r, err := self.JSXEth.Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr)
r, err := self.XEth.Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr)
if err != nil {
fmt.Println(err)
......
rpc/http/server.go
View file @ 21fd31da
......@@ -29,7 +29,7 @@ import (
var rpchttplogger = logger.NewLogger("RPC-HTTP")
var JSON rpc.JsonWrapper
func NewRpcHttpServer(pipe *xeth.JSXEth, port int) (*RpcHttpServer, error) {
func NewRpcHttpServer(pipe *xeth.XEth, port int) (*RpcHttpServer, error) {
sport := fmt.Sprintf(":%d", port)
l, err := net.Listen("tcp", sport)
if err != nil {
......@@ -47,7 +47,7 @@ func NewRpcHttpServer(pipe *xeth.JSXEth, port int) (*RpcHttpServer, error) {
type RpcHttpServer struct {
quit chan bool
listener net.Listener
pipe *xeth.JSXEth
pipe *xeth.XEth
port int
}
......@@ -85,6 +85,8 @@ func (s *RpcHttpServer) Start() {
func (s *RpcHttpServer) apiHandler(api *rpc.EthereumApi) http.Handler {
fn := func(w http.ResponseWriter, req *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
rpchttplogger.Debugln("Handling request")
reqParsed, reqerr := JSON.ParseRequestBody(req)
......
rpc/packages.go
View file @ 21fd31da
......@@ -19,8 +19,8 @@
For each request type, define the following:
1. RpcRequest "To" method [message.go], which does basic validation and conversion to "Args" type via json.Decoder()
2. json.Decoder() calls "UnmarshalJSON" defined on each "Args" struct
3. EthereumApi method, taking the "Args" type and replying with an interface to be marshalled to JSON
2. json.Decoder() calls "UnmarshalON" defined on each "Args" struct
3. EthereumApi method, taking the "Args" type and replying with an interface to be marshalled to ON
*/
package rpc
......@@ -38,12 +38,12 @@ type RpcServer interface {
Stop()
}
func NewEthereumApi(xeth *xeth.JSXEth) *EthereumApi {
return &EthereumApi{pipe: xeth}
func NewEthereumApi(xeth *xeth.XEth) *EthereumApi {
return &EthereumApi{xeth: xeth}
}
type EthereumApi struct {
pipe *xeth.JSXEth
xeth *xeth.XEth
}
func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error {
......@@ -53,9 +53,9 @@ func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error {
}
if args.BlockNumber > 0 {
*reply = p.pipe.BlockByNumber(args.BlockNumber)
*reply = p.xeth.BlockByNumber(args.BlockNumber)
} else {
*reply = p.pipe.BlockByHash(args.Hash)
*reply = p.xeth.BlockByHash(args.Hash)
}
return nil
}
......@@ -65,7 +65,7 @@ func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) error {
if err != nil {
return err
}
result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, args.Recipient, args.Value, args.Gas, args.GasPrice, args.Body)
result, _ := p.xeth.Transact( /* TODO specify account */ "", args.Recipient, args.Value, args.Gas, args.GasPrice, args.Body)
*reply = result
return nil
}
......@@ -76,7 +76,7 @@ func (p *EthereumApi) Create(args *NewTxArgs, reply *interface{}) error {
return err
}
result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, "", args.Value, args.Gas, args.GasPrice, args.Body)
result, _ := p.xeth.Transact( /* TODO specify account */ "", "", args.Value, args.Gas, args.GasPrice, args.Body)
*reply = result
return nil
}
......@@ -86,23 +86,18 @@ func (p *EthereumApi) PushTx(args *PushTxArgs, reply *interface{}) error {
if err != nil {
return err
}
result, _ := p.pipe.PushTx(args.Tx)
result, _ := p.xeth.PushTx(args.Tx)
*reply = result
return nil
}
func (p *EthereumApi) GetKey(args interface{}, reply *interface{}) error {
*reply = p.pipe.Key()
return nil
}
func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
state := p.xeth.State().SafeGet(args.Address)
var hx string
if strings.Index(args.Key, "0x") == 0 {
......@@ -119,22 +114,22 @@ func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *interface{}) err
}
func (p *EthereumApi) GetPeerCount(reply *interface{}) error {
*reply = p.pipe.PeerCount()
*reply = p.xeth.PeerCount()
return nil
}
func (p *EthereumApi) GetIsListening(reply *interface{}) error {
*reply = p.pipe.IsListening()
*reply = p.xeth.IsListening()
return nil
}
func (p *EthereumApi) GetCoinbase(reply *interface{}) error {
*reply = p.pipe.CoinBase()
*reply = p.xeth.Coinbase()
return nil
}
func (p *EthereumApi) GetIsMining(reply *interface{}) error {
*reply = p.pipe.IsMining()
*reply = p.xeth.IsMining()
return nil
}
......@@ -143,7 +138,7 @@ func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *interface{}) err
if err != nil {
return err
}
*reply = p.pipe.TxCountAt(args.Address)
*reply = p.xeth.TxCountAt(args.Address)
return nil
}
......@@ -152,7 +147,7 @@ func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *interface{}) err
if err != nil {
return err
}
state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
state := p.xeth.State().SafeGet(args.Address)
*reply = BalanceRes{Balance: state.Balance().String(), Address: args.Address}
return nil
}
......@@ -162,12 +157,12 @@ func (p *EthereumApi) GetCodeAt(args *GetCodeAtArgs, reply *interface{}) error {
if err != nil {
return err
}
*reply = p.pipe.CodeAt(args.Address)
*reply = p.xeth.CodeAt(args.Address)
return nil
}
func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error {
// Spec at https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC
// Spec at https://github.com/ethereum/wiki/wiki/Generic-ON-RPC
rpclogger.DebugDetailf("%T %s", req.Params, req.Params)
switch req.Method {
case "eth_coinbase":
......
rpc/ws/server.go
View file @ 21fd31da
......@@ -76,7 +76,7 @@ func (self *WebSocketServer) Start() {
wslogger.Infof("Starting RPC-WS server on port %d", self.port)
go self.handlerLoop()
api := rpc.NewEthereumApi(xeth.NewJSXEth(self.eth))
api := rpc.NewEthereumApi(xeth.New(self.eth))
h := self.apiHandler(api)
http.Handle("/ws", h)
......
tests/vm/gh_test.go
View file @ 21fd31da
......@@ -172,47 +172,47 @@ func RunVmTest(p string, t *testing.T) {
// I've created a new function for each tests so it's easier to identify where the problem lies if any of them fail.
func TestVMArithmetic(t *testing.T) {
const fn = "../files/vmtests/vmArithmeticTest.json"
const fn = "../files/VMTests/vmArithmeticTest.json"
RunVmTest(fn, t)
}
func TestBitwiseLogicOperation(t *testing.T) {
const fn = "../files/vmtests/vmBitwiseLogicOperationTest.json"
const fn = "../files/VMTests/vmBitwiseLogicOperationTest.json"
RunVmTest(fn, t)
}
func TestBlockInfo(t *testing.T) {
const fn = "../files/vmtests/vmBlockInfoTest.json"
const fn = "../files/VMTests/vmBlockInfoTest.json"
RunVmTest(fn, t)
}
func TestEnvironmentalInfo(t *testing.T) {
const fn = "../files/vmtests/vmEnvironmentalInfoTest.json"
const fn = "../files/VMTests/vmEnvironmentalInfoTest.json"
RunVmTest(fn, t)
}
func TestFlowOperation(t *testing.T) {
const fn = "../files/vmtests/vmIOandFlowOperationsTest.json"
const fn = "../files/VMTests/vmIOandFlowOperationsTest.json"
RunVmTest(fn, t)
}
func TestPushDupSwap(t *testing.T) {
const fn = "../files/vmtests/vmPushDupSwapTest.json"
const fn = "../files/VMTests/vmPushDupSwapTest.json"
RunVmTest(fn, t)
}
func TestVMSha3(t *testing.T) {
const fn = "../files/vmtests/vmSha3Test.json"
const fn = "../files/VMTests/vmSha3Test.json"
RunVmTest(fn, t)
}
func TestVm(t *testing.T) {
const fn = "../files/vmtests/vmtests.json"
const fn = "../files/VMTests/vmtests.json"
RunVmTest(fn, t)
}
func TestVmLog(t *testing.T) {
const fn = "../files/vmtests/vmLogTest.json"
const fn = "../files/VMTests/vmLogTest.json"
RunVmTest(fn, t)
}
......
vm/vm_jit.go
View file @ 21fd31da
This diff is collapsed.
vm/vm_jit_fake.go 0 → 100644
View file @ 21fd31da
// +build !evmjit
package vm
import "fmt"
func NewJitVm(env Environment) VirtualMachine {
fmt.Printf("Warning! EVM JIT not enabled.\n")
return New(env)
}
xeth/config.go deleted 100644 → 0
View file @ a88f609b
package xeth
import "github.com/ethereum/go-ethereum/ethutil"
var cnfCtr = ethutil.Hex2Bytes("661005d2720d855f1d9976f88bb10c1a3398c77f")
type Config struct {
pipe *XEth
}
func (self *Config) Get(name string) *Object {
configCtrl := self.pipe.World().safeGet(cnfCtr)
var addr []byte
switch name {
case "NameReg":
addr = []byte{0}
case "DnsReg":
objectAddr := configCtrl.GetStorage(ethutil.BigD([]byte{0}))
domainAddr := (&Object{self.pipe.World().safeGet(objectAddr.Bytes())}).StorageString("DnsReg").Bytes()
return &Object{self.pipe.World().safeGet(domainAddr)}
case "MergeMining":
addr = []byte{4}
default:
addr = ethutil.RightPadBytes([]byte(name), 32)
}
objectAddr := configCtrl.GetStorage(ethutil.BigD(addr))
return &Object{self.pipe.World().safeGet(objectAddr.Bytes())}
}
func (self *Config) Exist() bool {
return self.pipe.World().Get(cnfCtr) != nil
}
xeth/hexface.go deleted 100644 → 0
View file @ a88f609b
package xeth
import (
"bytes"
"encoding/json"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type JSXEth struct {
*XEth
}
func NewJSXEth(eth core.EthManager) *JSXEth {
return &JSXEth{New(eth)}
}
func (self *JSXEth) BlockByHash(strHash string) *JSBlock {
hash := fromHex(strHash)
block := self.obj.ChainManager().GetBlock(hash)
return NewJSBlock(block)
}
func (self *JSXEth) BlockByNumber(num int32) *JSBlock {
if num == -1 {
return NewJSBlock(self.obj.ChainManager().CurrentBlock())
}
return NewJSBlock(self.obj.ChainManager().GetBlockByNumber(uint64(num)))
}
func (self *JSXEth) Block(v interface{}) *JSBlock {
if n, ok := v.(int32); ok {
return self.BlockByNumber(n)
} else if str, ok := v.(string); ok {
return self.BlockByHash(str)
} else if f, ok := v.(float64); ok { // Don't ask ...
return self.BlockByNumber(int32(f))
}
return nil
}
func (self *JSXEth) Key() *JSKey {
return NewJSKey(self.obj.KeyManager().KeyPair())
}
func (self *JSXEth) Accounts() []string {
return []string{toHex(self.obj.KeyManager().Address())}
}
func (self *JSXEth) StateObject(addr string) *JSObject {
object := &Object{self.World().safeGet(fromHex(addr))}
return NewJSObject(object)
}
func (self *JSXEth) PeerCount() int {
return self.obj.PeerCount()
}
func (self *JSXEth) Peers() []JSPeer {
var peers []JSPeer
for _, peer := range self.obj.Peers() {
peers = append(peers, *NewJSPeer(peer))
}
return peers
}
func (self *JSXEth) IsMining() bool {
return self.obj.IsMining()
}
func (self *JSXEth) IsListening() bool {
return self.obj.IsListening()
}
func (self *JSXEth) CoinBase() string {
return toHex(self.obj.KeyManager().Address())
}
func (self *JSXEth) NumberToHuman(balance string) string {
b := ethutil.Big(balance)
return ethutil.CurrencyToString(b)
}
func (self *JSXEth) StorageAt(addr, storageAddr string) string {
storage := self.World().SafeGet(fromHex(addr)).Storage(fromHex(storageAddr))
return toHex(storage.Bytes())
}
func (self *JSXEth) BalanceAt(addr string) string {
return self.World().SafeGet(fromHex(addr)).Balance().String()
}
func (self *JSXEth) TxCountAt(address string) int {
return int(self.World().SafeGet(fromHex(address)).Nonce)
}
func (self *JSXEth) CodeAt(address string) string {
return toHex(self.World().SafeGet(fromHex(address)).Code)
}
func (self *JSXEth) IsContract(address string) bool {
return len(self.World().SafeGet(fromHex(address)).Code) > 0
}
func (self *JSXEth) SecretToAddress(key string) string {
pair, err := crypto.NewKeyPairFromSec(fromHex(key))
if err != nil {
return ""
}
return toHex(pair.Address())
}
func (self *JSXEth) Execute(addr, value, gas, price, data string) (string, error) {
ret, err := self.ExecuteObject(&Object{
self.World().safeGet(fromHex(addr))},
fromHex(data),
ethutil.NewValue(value),
ethutil.NewValue(gas),
ethutil.NewValue(price),
)
return toHex(ret), err
}
type KeyVal struct {
Key string `json:"key"`
Value string `json:"value"`
}
func (self *JSXEth) EachStorage(addr string) string {
var values []KeyVal
object := self.World().SafeGet(fromHex(addr))
it := object.Trie().Iterator()
for it.Next() {
values = append(values, KeyVal{toHex(it.Key), toHex(it.Value)})
}
valuesJson, err := json.Marshal(values)
if err != nil {
return ""
}
return string(valuesJson)
}
func (self *JSXEth) ToAscii(str string) string {
padded := ethutil.RightPadBytes([]byte(str), 32)
return "0x" + toHex(padded)
}
func (self *JSXEth) FromAscii(str string) string {
if ethutil.IsHex(str) {
str = str[2:]
}
return string(bytes.Trim(fromHex(str), "\x00"))
}
func (self *JSXEth) FromNumber(str string) string {
if ethutil.IsHex(str) {
str = str[2:]
}
return ethutil.BigD(fromHex(str)).String()
}
func (self *JSXEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
var (
to []byte
value = ethutil.NewValue(valueStr)
gas = ethutil.NewValue(gasStr)
gasPrice = ethutil.NewValue(gasPriceStr)
data []byte
)
data = fromHex(codeStr)
to = fromHex(toStr)
keyPair, err := crypto.NewKeyPairFromSec([]byte(fromHex(key)))
if err != nil {
return "", err
}
tx, err := self.XEth.Transact(keyPair, to, value, gas, gasPrice, data)
if err != nil {
return "", err
}
if types.IsContractAddr(to) {
return toHex(core.AddressFromMessage(tx)), nil
}
return toHex(tx.Hash()), nil
}
func (self *JSXEth) PushTx(txStr string) (*JSReceipt, error) {
tx := types.NewTransactionFromBytes(fromHex(txStr))
err := self.obj.TxPool().Add(tx)
if err != nil {
return nil, err
}
return NewJSReciept(core.MessageCreatesContract(tx), core.AddressFromMessage(tx), tx.Hash(), tx.From()), nil
}
func (self *JSXEth) CompileMutan(code string) string {
data, err := self.XEth.CompileMutan(code)
if err != nil {
return err.Error()
}
return toHex(data)
}
func (self *JSXEth) FindInConfig(str string) string {
return toHex(self.World().Config().Get(str).Address())
}
func ToJSMessages(messages state.Messages) *ethutil.List {
var msgs []JSMessage
for _, m := range messages {
msgs = append(msgs, NewJSMessage(m))
}
return ethutil.NewList(msgs)
}
xeth/object.go deleted 100644 → 0
View file @ a88f609b
package xeth
import (
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type Object struct {
*state.StateObject
}
func (self *Object) StorageString(str string) *ethutil.Value {
if ethutil.IsHex(str) {
return self.Storage(ethutil.Hex2Bytes(str[2:]))
} else {
return self.Storage(ethutil.RightPadBytes([]byte(str), 32))
}
}
func (self *Object) StorageValue(addr *ethutil.Value) *ethutil.Value {
return self.Storage(addr.Bytes())
}
func (self *Object) Storage(addr []byte) *ethutil.Value {
return self.StateObject.GetStorage(ethutil.BigD(addr))
}
xeth/js_types.go → xeth/types.go
View file @ 21fd31da
......@@ -25,8 +25,32 @@ func fromHex(s string) []byte {
return nil
}
type Object struct {
*state.StateObject
}
func NewObject(state *state.StateObject) *Object {
return &Object{state}
}
func (self *Object) StorageString(str string) *ethutil.Value {
if ethutil.IsHex(str) {
return self.Storage(ethutil.Hex2Bytes(str[2:]))
} else {
return self.Storage(ethutil.RightPadBytes([]byte(str), 32))
}
}
func (self *Object) StorageValue(addr *ethutil.Value) *ethutil.Value {
return self.Storage(addr.Bytes())
}
func (self *Object) Storage(addr []byte) *ethutil.Value {
return self.StateObject.GetStorage(ethutil.BigD(addr))
}
// Block interface exposed to QML
type JSBlock struct {
type Block struct {
//Transactions string `json:"transactions"`
ref *types.Block
Size string `json:"size"`
......@@ -45,24 +69,24 @@ type JSBlock struct {
}
// Creates a new QML Block from a chain block
func NewJSBlock(block *types.Block) *JSBlock {
func NewBlock(block *types.Block) *Block {
if block == nil {
return &JSBlock{}
return &Block{}
}
ptxs := make([]*JSTransaction, len(block.Transactions()))
ptxs := make([]*Transaction, len(block.Transactions()))
for i, tx := range block.Transactions() {
ptxs[i] = NewJSTx(tx)
ptxs[i] = NewTx(tx)
}
txlist := ethutil.NewList(ptxs)
puncles := make([]*JSBlock, len(block.Uncles()))
puncles := make([]*Block, len(block.Uncles()))
for i, uncle := range block.Uncles() {
puncles[i] = NewJSBlock(types.NewBlockWithHeader(uncle))
puncles[i] = NewBlock(types.NewBlockWithHeader(uncle))
}
ulist := ethutil.NewList(puncles)
return &JSBlock{
return &Block{
ref: block, Size: block.Size().String(),
Number: int(block.NumberU64()), GasUsed: block.GasUsed().String(),
GasLimit: block.GasLimit().String(), Hash: toHex(block.Hash()),
......@@ -75,7 +99,7 @@ func NewJSBlock(block *types.Block) *JSBlock {
}
}
func (self *JSBlock) ToString() string {
func (self *Block) ToString() string {
if self.ref != nil {
return self.ref.String()
}
......@@ -83,16 +107,16 @@ func (self *JSBlock) ToString() string {
return ""
}
func (self *JSBlock) GetTransaction(hash string) *JSTransaction {
func (self *Block) GetTransaction(hash string) *Transaction {
tx := self.ref.Transaction(fromHex(hash))
if tx == nil {
return nil
}
return NewJSTx(tx)
return NewTx(tx)
}
type JSTransaction struct {
type Transaction struct {
ref *types.Transaction
Value string `json:"value"`
......@@ -108,7 +132,7 @@ type JSTransaction struct {
Confirmations int `json:"confirmations"`
}
func NewJSTx(tx *types.Transaction) *JSTransaction {
func NewTx(tx *types.Transaction) *Transaction {
hash := toHex(tx.Hash())
receiver := toHex(tx.To())
if receiver == "0000000000000000000000000000000000000000" {
......@@ -124,29 +148,21 @@ func NewJSTx(tx *types.Transaction) *JSTransaction {
data = toHex(tx.Data())
}
return &JSTransaction{ref: tx, Hash: hash, Value: ethutil.CurrencyToString(tx.Value()), Address: receiver, Contract: createsContract, Gas: tx.Gas().String(), GasPrice: tx.GasPrice().String(), Data: data, Sender: sender, CreatesContract: createsContract, RawData: toHex(tx.Data())}
return &Transaction{ref: tx, Hash: hash, Value: ethutil.CurrencyToString(tx.Value()), Address: receiver, Contract: createsContract, Gas: tx.Gas().String(), GasPrice: tx.GasPrice().String(), Data: data, Sender: sender, CreatesContract: createsContract, RawData: toHex(tx.Data())}
}
func (self *JSTransaction) ToString() string {
func (self *Transaction) ToString() string {
return self.ref.String()
}
type JSKey struct {
type Key struct {
Address string `json:"address"`
PrivateKey string `json:"privateKey"`
PublicKey string `json:"publicKey"`
}
func NewJSKey(key *crypto.KeyPair) *JSKey {
return &JSKey{toHex(key.Address()), toHex(key.PrivateKey), toHex(key.PublicKey)}
}
type JSObject struct {
*Object
}
func NewJSObject(object *Object) *JSObject {
return &JSObject{object}
func NewKey(key *crypto.KeyPair) *Key {
return &Key{toHex(key.Address()), toHex(key.PrivateKey), toHex(key.PublicKey)}
}
type PReceipt struct {
......@@ -167,20 +183,20 @@ func NewPReciept(contractCreation bool, creationAddress, hash, address []byte) *
// Peer interface exposed to QML
type JSPeer struct {
type Peer struct {
ref *p2p.Peer
Ip string `json:"ip"`
Version string `json:"version"`
Caps string `json:"caps"`
}
func NewJSPeer(peer *p2p.Peer) *JSPeer {
func NewPeer(peer *p2p.Peer) *Peer {
var caps []string
for _, cap := range peer.Caps() {
caps = append(caps, fmt.Sprintf("%s/%d", cap.Name, cap.Version))
}
return &JSPeer{
return &Peer{
ref: peer,
Ip: fmt.Sprintf("%v", peer.RemoteAddr()),
Version: fmt.Sprintf("%v", peer.Identity()),
......@@ -188,15 +204,15 @@ func NewJSPeer(peer *p2p.Peer) *JSPeer {
}
}
type JSReceipt struct {
type Receipt struct {
CreatedContract bool `json:"createdContract"`
Address string `json:"address"`
Hash string `json:"hash"`
Sender string `json:"sender"`
}
func NewJSReciept(contractCreation bool, creationAddress, hash, address []byte) *JSReceipt {
return &JSReceipt{
func NewReciept(contractCreation bool, creationAddress, hash, address []byte) *Receipt {
return &Receipt{
contractCreation,
toHex(creationAddress),
toHex(hash),
......@@ -204,7 +220,7 @@ func NewJSReciept(contractCreation bool, creationAddress, hash, address []byte)
}
}
type JSMessage struct {
type Message struct {
To string `json:"to"`
From string `json:"from"`
Input string `json:"input"`
......@@ -218,8 +234,8 @@ type JSMessage struct {
Value string `json:"value"`
}
func NewJSMessage(message *state.Message) JSMessage {
return JSMessage{
func NewMessage(message *state.Message) Message {
return Message{
To: toHex(message.To),
From: toHex(message.From),
Input: toHex(message.Input),
......
xeth/world.go
View file @ 21fd31da
package xeth
import (
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/state"
)
type World struct {
pipe *XEth
cfg *Config
}
func NewWorld(pipe *XEth) *World {
world := &World{pipe, nil}
world.cfg = &Config{pipe}
import "github.com/ethereum/go-ethereum/state"
return world
type State struct {
xeth *XEth
}
func (self *XEth) World() *World {
return self.world
func NewState(xeth *XEth) *State {
return &State{xeth}
}
func (self *World) State() *state.StateDB {
return self.pipe.chainManager.State()
func (self *State) State() *state.StateDB {
return self.xeth.chainManager.State()
}
func (self *World) Get(addr []byte) *Object {
return &Object{self.State().GetStateObject(addr)}
func (self *State) Get(addr string) *Object {
return &Object{self.State().GetStateObject(fromHex(addr))}
}
func (self *World) SafeGet(addr []byte) *Object {
func (self *State) SafeGet(addr string) *Object {
return &Object{self.safeGet(addr)}
}
func (self *World) safeGet(addr []byte) *state.StateObject {
object := self.State().GetStateObject(addr)
func (self *State) safeGet(addr string) *state.StateObject {
object := self.State().GetStateObject(fromHex(addr))
if object == nil {
object = state.NewStateObject(addr, self.pipe.obj.Db())
object = state.NewStateObject(fromHex(addr), self.xeth.eth.Db())
}
return object
}
func (self *World) Coinbase() *state.StateObject {
return nil
}
func (self *World) IsMining() bool {
return self.pipe.obj.IsMining()
}
func (self *World) IsListening() bool {
return self.pipe.obj.IsListening()
}
func (self *World) Peers() []*p2p.Peer {
return self.pipe.obj.Peers()
}
func (self *World) Config() *Config {
return self.cfg
}
xeth/xeth.go
View file @ 21fd31da
......@@ -5,6 +5,9 @@ package xeth
*/
import (
"bytes"
"encoding/json"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
......@@ -15,167 +18,201 @@ import (
var pipelogger = logger.NewLogger("XETH")
type VmVars struct {
State *state.StateDB
// to resolve the import cycle
type Backend interface {
BlockProcessor() *core.BlockProcessor
ChainManager() *core.ChainManager
Coinbase() []byte
KeyManager() *crypto.KeyManager
IsMining() bool
IsListening() bool
PeerCount() int
Db() ethutil.Database
TxPool() *core.TxPool
}
type XEth struct {
obj core.EthManager
eth Backend
blockProcessor *core.BlockProcessor
chainManager *core.ChainManager
world *World
world *State
}
func New(eth Backend) *XEth {
xeth := &XEth{
eth: eth,
blockProcessor: eth.BlockProcessor(),
chainManager: eth.ChainManager(),
}
xeth.world = NewState(xeth)
Vm VmVars
return xeth
}
func New(obj core.EthManager) *XEth {
pipe := &XEth{
obj: obj,
blockProcessor: obj.BlockProcessor(),
chainManager: obj.ChainManager(),
func (self *XEth) State() *State { return self.world }
func (self *XEth) BlockByHash(strHash string) *Block {
hash := fromHex(strHash)
block := self.chainManager.GetBlock(hash)
return NewBlock(block)
}
func (self *XEth) BlockByNumber(num int32) *Block {
if num == -1 {
return NewBlock(self.chainManager.CurrentBlock())
}
return NewBlock(self.chainManager.GetBlockByNumber(uint64(num)))
}
func (self *XEth) Block(v interface{}) *Block {
if n, ok := v.(int32); ok {
return self.BlockByNumber(n)
} else if str, ok := v.(string); ok {
return self.BlockByHash(str)
} else if f, ok := v.(float64); ok { // Don't ask ...
return self.BlockByNumber(int32(f))
}
pipe.world = NewWorld(pipe)
return pipe
return nil
}
func (self *XEth) Accounts() []string {
return []string{toHex(self.eth.KeyManager().Address())}
}
/*
* State / Account accessors
*/
func (self *XEth) Balance(addr []byte) *ethutil.Value {
return ethutil.NewValue(self.World().safeGet(addr).Balance)
func (self *XEth) StateObject(addr string) *Object {
object := &Object{self.State().safeGet(fromHex(addr))}
return NewObject(object)
}
*/
func (self *XEth) Nonce(addr []byte) uint64 {
return self.World().safeGet(addr).Nonce
func (self *XEth) PeerCount() int {
return self.eth.PeerCount()
}
func (self *XEth) Block(hash []byte) *types.Block {
return self.chainManager.GetBlock(hash)
func (self *XEth) IsMining() bool {
return self.eth.IsMining()
}
func (self *XEth) Storage(addr, storageAddr []byte) *ethutil.Value {
return self.World().safeGet(addr).GetStorage(ethutil.BigD(storageAddr))
func (self *XEth) IsListening() bool {
return self.eth.IsListening()
}
func (self *XEth) Exists(addr []byte) bool {
return self.World().Get(addr) != nil
func (self *XEth) Coinbase() string {
return toHex(self.eth.KeyManager().Address())
}
// Converts the given private key to an address
func (self *XEth) ToAddress(priv []byte) []byte {
pair, err := crypto.NewKeyPairFromSec(priv)
if err != nil {
return nil
}
func (self *XEth) NumberToHuman(balance string) string {
b := ethutil.Big(balance)
return pair.Address()
return ethutil.CurrencyToString(b)
}
/*
* Execution helpers
*/
func (self *XEth) Execute(addr []byte, data []byte, value, gas, price *ethutil.Value) ([]byte, error) {
return self.ExecuteObject(&Object{self.World().safeGet(addr)}, data, value, gas, price)
func (self *XEth) StorageAt(addr, storageAddr string) string {
storage := self.State().SafeGet(addr).StorageString(storageAddr)
return toHex(storage.Bytes())
}
func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) {
var (
initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address(), self.obj.Db())
block = self.chainManager.CurrentBlock()
)
func (self *XEth) BalanceAt(addr string) string {
return self.State().SafeGet(addr).Balance().String()
}
self.Vm.State = self.World().State().Copy()
func (self *XEth) TxCountAt(address string) int {
return int(self.State().SafeGet(address).Nonce)
}
vmenv := NewEnv(self.chainManager, self.Vm.State, block, value.BigInt(), initiator.Address())
return vmenv.Call(initiator, object.Address(), data, gas.BigInt(), price.BigInt(), value.BigInt())
func (self *XEth) CodeAt(address string) string {
return toHex(self.State().SafeGet(address).Code)
}
/*
* Transactional methods
*/
func (self *XEth) TransactString(key *crypto.KeyPair, rec string, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) {
// Check if an address is stored by this address
var hash []byte
addr := self.World().Config().Get("NameReg").StorageString(rec).Bytes()
if len(addr) > 0 {
hash = addr
} else if ethutil.IsHex(rec) {
hash = ethutil.Hex2Bytes(rec[2:])
} else {
hash = ethutil.Hex2Bytes(rec)
}
func (self *XEth) IsContract(address string) bool {
return len(self.State().SafeGet(address).Code) > 0
}
return self.Transact(key, hash, value, gas, price, data)
}
func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) {
var hash []byte
var contractCreation bool
if types.IsContractAddr(to) {
contractCreation = true
} else {
// Check if an address is stored by this address
addr := self.World().Config().Get("NameReg").Storage(to).Bytes()
if len(addr) > 0 {
hash = addr
} else {
hash = to
}
func (self *XEth) SecretToAddress(key string) string {
pair, err := crypto.NewKeyPairFromSec(fromHex(key))
if err != nil {
return ""
}
var tx *types.Transaction
if contractCreation {
tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), data)
} else {
tx = types.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data)
}
return toHex(pair.Address())
}
state := self.chainManager.TransState()
nonce := state.GetNonce(key.Address())
func (self *XEth) Execute(addr, value, gas, price, data string) (string, error) {
return "", nil
}
tx.SetNonce(nonce)
tx.Sign(key.PrivateKey)
type KeyVal struct {
Key string `json:"key"`
Value string `json:"value"`
}
// Do some pre processing for our "pre" events and hooks
block := self.chainManager.NewBlock(key.Address())
coinbase := state.GetOrNewStateObject(key.Address())
coinbase.SetGasPool(block.GasLimit())
self.blockProcessor.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true)
func (self *XEth) EachStorage(addr string) string {
var values []KeyVal
object := self.State().SafeGet(addr)
it := object.Trie().Iterator()
for it.Next() {
values = append(values, KeyVal{toHex(it.Key), toHex(it.Value)})
}
err := self.obj.TxPool().Add(tx)
valuesJson, err := json.Marshal(values)
if err != nil {
return nil, err
return ""
}
state.SetNonce(key.Address(), nonce+1)
if contractCreation {
addr := core.AddressFromMessage(tx)
pipelogger.Infof("Contract addr %x\n", addr)
return string(valuesJson)
}
func (self *XEth) ToAscii(str string) string {
padded := ethutil.RightPadBytes([]byte(str), 32)
return "0x" + toHex(padded)
}
func (self *XEth) FromAscii(str string) string {
if ethutil.IsHex(str) {
str = str[2:]
}
return tx, nil
return string(bytes.Trim(fromHex(str), "\x00"))
}
func (self *XEth) PushTx(tx *types.Transaction) ([]byte, error) {
err := self.obj.TxPool().Add(tx)
if err != nil {
return nil, err
func (self *XEth) FromNumber(str string) string {
if ethutil.IsHex(str) {
str = str[2:]
}
if tx.To() == nil {
addr := core.AddressFromMessage(tx)
pipelogger.Infof("Contract addr %x\n", addr)
return addr, nil
return ethutil.BigD(fromHex(str)).String()
}
func (self *XEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
return "", nil
}
func ToMessages(messages state.Messages) *ethutil.List {
var msgs []Message
for _, m := range messages {
msgs = append(msgs, NewMessage(m))
}
return tx.Hash(), nil
return ethutil.NewList(msgs)
}
func (self *XEth) CompileMutan(code string) ([]byte, error) {
data, err := ethutil.Compile(code, false)
func (self *XEth) PushTx(encodedTx string) (string, error) {
tx := types.NewTransactionFromBytes(fromHex(encodedTx))
err := self.eth.TxPool().Add(tx)
if err != nil {
return nil, err
return "", err
}
return data, nil
if tx.To() == nil {
addr := core.AddressFromMessage(tx)
return toHex(addr), nil
}
return toHex(tx.Hash()), nil
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment