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

This commit is contained in:
Taylor Gerring 2015-01-28 12:01:15 -06:00
commit 21fd31dad8
27 changed files with 705 additions and 709 deletions

2
.gitignore vendored
View File

@ -15,3 +15,5 @@
.#* .#*
*# *#
*~ *~
.project
.settings

View File

@ -1,30 +1,27 @@
[![Bugs](https://badge.waffle.io/ethereum/go-ethereum.png?label=bug&title=Bugs)](https://waffle.io/ethereum/go-ethereum) [![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 Ready](https://badge.waffle.io/ethereum/go-ethereum.png?label=ready&title=Ready)](https://waffle.io/ethereum/go-ethereum)
[![Stories in [![Stories in Progress](https://badge.waffle.io/ethereum/go-ethereum.svg?label=in%20progress&title=In Progress)](http://waffle.io/ethereum/go-ethereum)
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 * [![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
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 * [![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
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) tests * [![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. Ethereum Go Client © 2014 Jeffrey Wilcke.
Current state: Proof of Concept 0.8
Ethereum is currently in its testing phase.
Build Build
===== =====
To build Mist (GUI): Mist (GUI):
`go get github.com/ethereum/go-ethereum/cmd/mist` `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` `go get github.com/ethereum/go-ethereum/cmd/ethereum`
@ -49,6 +46,8 @@ Go Ethereum comes with several binaries found in
`cat file | ethtest`. `cat file | ethtest`.
* `evm` is a generic Ethereum Virtual Machine: `evm -code 60ff60ff -gas * `evm` is a generic Ethereum Virtual Machine: `evm -code 60ff60ff -gas
10000 -price 0 -dump`. See `-h` for a detailed description. 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 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 manually. (If you want to contribute by just writing tests that's fine
too!) too!)

View File

@ -56,7 +56,9 @@ ApplicationWindow {
mainSplit.setView(wallet.view, wallet.menuItem); mainSplit.setView(wallet.view, wallet.menuItem);
console.log(">>>>>>")
newBrowserTab("http://etherian.io"); newBrowserTab("http://etherian.io");
console.log("WTF")
// Command setup // Command setup
gui.sendCommand(0) gui.sendCommand(0)

View File

@ -22,7 +22,8 @@ Rectangle {
function setBalance() { function setBalance() {
//balance.text = "<b>Balance</b>: " + eth.numberToHuman(eth.balanceAt(eth.key().address)) //balance.text = "<b>Balance</b>: " + eth.numberToHuman(eth.balanceAt(eth.key().address))
if(menuItem) 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 { ListModel {
@ -155,14 +156,6 @@ Rectangle {
model: ListModel { model: ListModel {
id: txModel id: txModel
Component.onCompleted: { 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) { function addTxs(messages) {

View File

@ -47,7 +47,7 @@ type AppContainer interface {
} }
type ExtApplication struct { type ExtApplication struct {
*xeth.JSXEth *xeth.XEth
eth core.EthManager eth core.EthManager
events event.Subscription events event.Subscription
@ -61,7 +61,7 @@ type ExtApplication struct {
func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication { func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication {
return &ExtApplication{ return &ExtApplication{
JSXEth: xeth.NewJSXEth(lib.eth), XEth: xeth.New(lib.eth),
eth: lib.eth, eth: lib.eth,
watcherQuitChan: make(chan bool), watcherQuitChan: make(chan bool),
filters: make(map[string]*core.Filter), filters: make(map[string]*core.Filter),

View File

@ -32,7 +32,6 @@ import (
"path" "path"
"runtime" "runtime"
"strconv" "strconv"
"strings"
"time" "time"
"github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core"
@ -76,7 +75,7 @@ type Gui struct {
logLevel logger.LogLevel logLevel logger.LogLevel
open bool open bool
xeth *xeth.JSXEth xeth *xeth.XEth
Session string Session string
clientIdentity *p2p.SimpleClientIdentity clientIdentity *p2p.SimpleClientIdentity
@ -94,7 +93,7 @@ func NewWindow(ethereum *eth.Ethereum, config *ethutil.ConfigManager, clientIden
panic(err) panic(err)
} }
xeth := xeth.NewJSXEth(ethereum) xeth := xeth.New(ethereum)
gui := &Gui{eth: ethereum, gui := &Gui{eth: ethereum,
txDb: db, txDb: db,
xeth: xeth, xeth: xeth,
@ -121,9 +120,9 @@ func (gui *Gui) Start(assetPath string) {
// Register ethereum functions // Register ethereum functions
qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{ 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 = "" }, Init: func(p *xeth.KeyVal, obj qml.Object) { p.Key = ""; p.Value = "" },
}}) }})
@ -229,6 +228,7 @@ func (gui *Gui) setInitialChain(ancientBlocks bool) {
} }
func (gui *Gui) loadAddressBook() { func (gui *Gui) loadAddressBook() {
/*
view := gui.getObjectByName("infoView") view := gui.getObjectByName("infoView")
nameReg := gui.xeth.World().Config().Get("NameReg") nameReg := gui.xeth.World().Config().Get("NameReg")
if nameReg != nil { if nameReg != nil {
@ -240,9 +240,11 @@ func (gui *Gui) loadAddressBook() {
} }
} }
*/
} }
func (self *Gui) loadMergedMiningOptions() { func (self *Gui) loadMergedMiningOptions() {
/*
view := self.getObjectByName("mergedMiningModel") view := self.getObjectByName("mergedMiningModel")
mergeMining := self.xeth.World().Config().Get("MergeMining") mergeMining := self.xeth.World().Config().Get("MergeMining")
@ -260,10 +262,10 @@ func (self *Gui) loadMergedMiningOptions() {
} }
} }
*/
} }
func (gui *Gui) insertTransaction(window string, tx *types.Transaction) { func (gui *Gui) insertTransaction(window string, tx *types.Transaction) {
nameReg := gui.xeth.World().Config().Get("NameReg")
addr := gui.address() addr := gui.address()
var inout string var inout string
@ -274,32 +276,12 @@ func (gui *Gui) insertTransaction(window string, tx *types.Transaction) {
} }
var ( var (
ptx = xeth.NewJSTx(tx) ptx = xeth.NewTx(tx)
send = nameReg.Storage(tx.From()) send = ethutil.Bytes2Hex(tx.From())
rec = nameReg.Storage(tx.To()) rec = ethutil.Bytes2Hex(tx.To())
s, r string
) )
ptx.Sender = send
if core.MessageCreatesContract(tx) { ptx.Address = rec
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
if window == "post" { if window == "post" {
//gui.getObjectByName("transactionView").Call("addTx", ptx, inout) //gui.getObjectByName("transactionView").Call("addTx", ptx, inout)
@ -320,8 +302,8 @@ func (gui *Gui) readPreviousTransactions() {
} }
func (gui *Gui) processBlock(block *types.Block, initial bool) { func (gui *Gui) processBlock(block *types.Block, initial bool) {
name := strings.Trim(gui.xeth.World().Config().Get("NameReg").Storage(block.Coinbase()).Str(), "\x00") name := ethutil.Bytes2Hex(block.Coinbase())
b := xeth.NewJSBlock(block) b := xeth.NewBlock(block)
b.Name = name b.Name = name
gui.getObjectByName("chainView").Call("addBlock", b, initial) gui.getObjectByName("chainView").Call("addBlock", b, initial)
@ -531,9 +513,9 @@ NumGC: %d
func (gui *Gui) setPeerInfo() { func (gui *Gui) setPeerInfo() {
gui.win.Root().Call("setPeers", fmt.Sprintf("%d / %d", gui.eth.PeerCount(), gui.eth.MaxPeers)) gui.win.Root().Call("setPeers", fmt.Sprintf("%d / %d", gui.eth.PeerCount(), gui.eth.MaxPeers))
gui.win.Root().Call("resetPeers") gui.win.Root().Call("resetPeers")
for _, peer := range gui.xeth.Peers() { //for _, peer := range gui.xeth.Peers() {
gui.win.Root().Call("addPeer", peer) //gui.win.Root().Call("addPeer", peer)
} //}
} }
func (gui *Gui) privateKey() string { func (gui *Gui) privateKey() string {

View File

@ -142,7 +142,7 @@ func (app *HtmlApplication) Window() *qml.Window {
} }
func (app *HtmlApplication) NewBlock(block *types.Block) { 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) app.webView.Call("onNewBlockCb", b)
} }

View File

@ -70,7 +70,7 @@ func (app *QmlApplication) NewWatcher(quitChan chan bool) {
// Events // Events
func (app *QmlApplication) NewBlock(block *types.Block) { 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) app.win.Call("onNewBlockCb", pblock)
} }

View File

@ -21,15 +21,11 @@
package main package main
import ( import (
"bytes"
"fmt" "fmt"
"path" "path"
"strconv"
"strings"
"github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/eth"
"github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/event/filter" "github.com/ethereum/go-ethereum/event/filter"
@ -48,7 +44,7 @@ type memAddr struct {
// UI Library that has some basic functionality exposed // UI Library that has some basic functionality exposed
type UiLib struct { type UiLib struct {
*xeth.JSXEth *xeth.XEth
engine *qml.Engine engine *qml.Engine
eth *eth.Ethereum eth *eth.Ethereum
connected bool connected bool
@ -67,7 +63,7 @@ type UiLib struct {
} }
func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib { 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.miner = miner.New(eth.KeyManager().Address(), eth)
lib.filterManager = filter.NewFilterManager(eth.EventMux()) lib.filterManager = filter.NewFilterManager(eth.EventMux())
go lib.filterManager.Start() go lib.filterManager.Start()
@ -79,56 +75,6 @@ func (self *UiLib) Notef(args []interface{}) {
guilogger.Infoln(args...) 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 { func (self *UiLib) PastPeers() *ethutil.List {
return ethutil.NewList([]string{}) return ethutil.NewList([]string{})
//return ethutil.NewList(eth.PastPeers()) //return ethutil.NewList(eth.PastPeers())
@ -234,7 +180,7 @@ func (self *UiLib) StartDebugger() {
func (self *UiLib) Transact(params map[string]interface{}) (string, error) { func (self *UiLib) Transact(params map[string]interface{}) (string, error) {
object := mapToTxParams(params) object := mapToTxParams(params)
return self.JSXEth.Transact( return self.XEth.Transact(
object["from"], object["from"],
object["to"], object["to"],
object["value"], object["value"],
@ -256,7 +202,7 @@ func (self *UiLib) Compile(code string) (string, error) {
func (self *UiLib) Call(params map[string]interface{}) (string, error) { func (self *UiLib) Call(params map[string]interface{}) (string, error) {
object := mapToTxParams(params) object := mapToTxParams(params)
return self.JSXEth.Execute( return self.XEth.Execute(
object["to"], object["to"],
object["value"], object["value"],
object["gas"], 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) { func (self *UiLib) NewFilter(object map[string]interface{}, view *qml.Common) (id int) {
filter := qt.NewFilterFromMap(object, self.eth) filter := qt.NewFilterFromMap(object, self.eth)
filter.MessageCallback = func(messages state.Messages) { 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) id = self.filterManager.InstallFilter(filter)
return id 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 { func (self *UiLib) Messages(id int) *ethutil.List {
filter := self.filterManager.GetFilter(id) filter := self.filterManager.GetFilter(id)
if filter != nil { if filter != nil {
messages := xeth.ToJSMessages(filter.Find()) messages := xeth.ToMessages(filter.Find())
return messages return messages
} }

View File

@ -194,7 +194,7 @@ func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, Secre
func StartRpc(ethereum *eth.Ethereum, RpcPort int) { func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
var err error var err error
ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.NewJSXEth(ethereum), RpcPort) ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.New(ethereum), RpcPort)
if err != nil { if err != nil {
clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err) clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
} else { } else {

View File

@ -46,6 +46,8 @@ func insertChain(done chan bool, chainMan *ChainManager, chain types.Blocks, t *
} }
func TestChainInsertions(t *testing.T) { func TestChainInsertions(t *testing.T) {
t.Skip() // travil fails.
db, _ := ethdb.NewMemDatabase() db, _ := ethdb.NewMemDatabase()
chain1, err := loadChain("valid1", t) chain1, err := loadChain("valid1", t)
@ -86,6 +88,8 @@ func TestChainInsertions(t *testing.T) {
} }
func TestChainMultipleInsertions(t *testing.T) { func TestChainMultipleInsertions(t *testing.T) {
t.Skip() // travil fails.
db, _ := ethdb.NewMemDatabase() db, _ := ethdb.NewMemDatabase()
const max = 4 const max = 4
@ -130,6 +134,8 @@ func TestChainMultipleInsertions(t *testing.T) {
} }
func TestGetAncestors(t *testing.T) { func TestGetAncestors(t *testing.T) {
t.Skip() // travil fails.
db, _ := ethdb.NewMemDatabase() db, _ := ethdb.NewMemDatabase()
var eventMux event.TypeMux var eventMux event.TypeMux
chainMan := NewChainManager(db, &eventMux) chainMan := NewChainManager(db, &eventMux)

View File

@ -34,7 +34,7 @@ func GenesisBlock(db ethutil.Database) *types.Block {
statedb := state.New(genesis.Root(), db) statedb := state.New(genesis.Root(), db)
//statedb := state.New(genesis.Trie()) //statedb := state.New(genesis.Trie())
for _, addr := range []string{ for _, addr := range []string{
"51ba59315b3a95761d0863b05ccc7a7f54703d99", "dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6",
"e4157b34ea9615cfbde6b4fda419828124b70c78", "e4157b34ea9615cfbde6b4fda419828124b70c78",
"b9c015918bdaba24b4ff057a92a3873d6eb201be", "b9c015918bdaba24b4ff057a92a3873d6eb201be",
"6c386a4b26f73c802f34673f7248bb118f97424a", "6c386a4b26f73c802f34673f7248bb118f97424a",

View File

@ -219,6 +219,10 @@ func (s *Ethereum) MaxPeers() int {
return s.net.MaxPeers return s.net.MaxPeers
} }
func (s *Ethereum) Coinbase() []byte {
return nil // TODO
}
// Start the ethereum // Start the ethereum
func (s *Ethereum) Start(seed bool) error { func (s *Ethereum) Start(seed bool) error {
err := s.net.Start() err := s.net.Start()

View File

@ -24,7 +24,7 @@ var jsrelogger = logger.NewLogger("JSRE")
type JSRE struct { type JSRE struct {
ethereum *eth.Ethereum ethereum *eth.Ethereum
Vm *otto.Otto Vm *otto.Otto
pipe *xeth.JSXEth pipe *xeth.XEth
events event.Subscription events event.Subscription
@ -49,7 +49,7 @@ func NewJSRE(ethereum *eth.Ethereum) *JSRE {
re := &JSRE{ re := &JSRE{
ethereum, ethereum,
otto.New(), otto.New(),
xeth.NewJSXEth(ethereum), xeth.New(ethereum),
nil, nil,
make(map[string][]otto.Value), make(map[string][]otto.Value),
} }

View File

@ -12,14 +12,14 @@ import (
) )
type JSStateObject struct { type JSStateObject struct {
*xeth.JSObject *xeth.Object
eth *JSEthereum eth *JSEthereum
} }
func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value { func (self *JSStateObject) EachStorage(call otto.FunctionCall) otto.Value {
cb := call.Argument(0) cb := call.Argument(0)
it := self.JSObject.Trie().Iterator() it := self.Object.Trie().Iterator()
for it.Next() { for it.Next() {
cb.Call(self.eth.toVal(self), self.eth.toVal(ethutil.Bytes2Hex(it.Key)), self.eth.toVal(ethutil.Bytes2Hex(it.Value))) 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 // The JSEthereum object attempts to wrap the PEthereum object and returns
// meaningful javascript objects // meaningful javascript objects
type JSBlock struct { type JSBlock struct {
*xeth.JSBlock *xeth.Block
eth *JSEthereum eth *JSEthereum
} }
func (self *JSBlock) GetTransaction(hash string) otto.Value { 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 { type JSMessage struct {
@ -67,35 +67,27 @@ func NewJSMessage(message *state.Message) JSMessage {
} }
type JSEthereum struct { type JSEthereum struct {
*xeth.JSXEth *xeth.XEth
vm *otto.Otto vm *otto.Otto
ethereum *eth.Ethereum ethereum *eth.Ethereum
} }
func (self *JSEthereum) Block(v interface{}) otto.Value { func (self *JSEthereum) Block(v interface{}) otto.Value {
if number, ok := v.(int64); ok { 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 { } 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() 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 { 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 { 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 { if err != nil {
fmt.Println(err) fmt.Println(err)

View File

@ -29,7 +29,7 @@ import (
var rpchttplogger = logger.NewLogger("RPC-HTTP") var rpchttplogger = logger.NewLogger("RPC-HTTP")
var JSON rpc.JsonWrapper 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) sport := fmt.Sprintf(":%d", port)
l, err := net.Listen("tcp", sport) l, err := net.Listen("tcp", sport)
if err != nil { if err != nil {
@ -47,7 +47,7 @@ func NewRpcHttpServer(pipe *xeth.JSXEth, port int) (*RpcHttpServer, error) {
type RpcHttpServer struct { type RpcHttpServer struct {
quit chan bool quit chan bool
listener net.Listener listener net.Listener
pipe *xeth.JSXEth pipe *xeth.XEth
port int port int
} }
@ -85,6 +85,8 @@ func (s *RpcHttpServer) Start() {
func (s *RpcHttpServer) apiHandler(api *rpc.EthereumApi) http.Handler { func (s *RpcHttpServer) apiHandler(api *rpc.EthereumApi) http.Handler {
fn := func(w http.ResponseWriter, req *http.Request) { fn := func(w http.ResponseWriter, req *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
rpchttplogger.Debugln("Handling request") rpchttplogger.Debugln("Handling request")
reqParsed, reqerr := JSON.ParseRequestBody(req) reqParsed, reqerr := JSON.ParseRequestBody(req)

View File

@ -19,8 +19,8 @@
For each request type, define the following: 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() 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 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 JSON 3. EthereumApi method, taking the "Args" type and replying with an interface to be marshalled to ON
*/ */
package rpc package rpc
@ -38,12 +38,12 @@ type RpcServer interface {
Stop() Stop()
} }
func NewEthereumApi(xeth *xeth.JSXEth) *EthereumApi { func NewEthereumApi(xeth *xeth.XEth) *EthereumApi {
return &EthereumApi{pipe: xeth} return &EthereumApi{xeth: xeth}
} }
type EthereumApi struct { type EthereumApi struct {
pipe *xeth.JSXEth xeth *xeth.XEth
} }
func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error { 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 { if args.BlockNumber > 0 {
*reply = p.pipe.BlockByNumber(args.BlockNumber) *reply = p.xeth.BlockByNumber(args.BlockNumber)
} else { } else {
*reply = p.pipe.BlockByHash(args.Hash) *reply = p.xeth.BlockByHash(args.Hash)
} }
return nil return nil
} }
@ -65,7 +65,7 @@ func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) error {
if err != nil { if err != nil {
return err 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 *reply = result
return nil return nil
} }
@ -76,7 +76,7 @@ func (p *EthereumApi) Create(args *NewTxArgs, reply *interface{}) error {
return err 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 *reply = result
return nil return nil
} }
@ -86,23 +86,18 @@ func (p *EthereumApi) PushTx(args *PushTxArgs, reply *interface{}) error {
if err != nil { if err != nil {
return err return err
} }
result, _ := p.pipe.PushTx(args.Tx) result, _ := p.xeth.PushTx(args.Tx)
*reply = result *reply = result
return nil 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 { func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *interface{}) error {
err := args.requirements() err := args.requirements()
if err != nil { if err != nil {
return err return err
} }
state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address)) state := p.xeth.State().SafeGet(args.Address)
var hx string var hx string
if strings.Index(args.Key, "0x") == 0 { 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 { func (p *EthereumApi) GetPeerCount(reply *interface{}) error {
*reply = p.pipe.PeerCount() *reply = p.xeth.PeerCount()
return nil return nil
} }
func (p *EthereumApi) GetIsListening(reply *interface{}) error { func (p *EthereumApi) GetIsListening(reply *interface{}) error {
*reply = p.pipe.IsListening() *reply = p.xeth.IsListening()
return nil return nil
} }
func (p *EthereumApi) GetCoinbase(reply *interface{}) error { func (p *EthereumApi) GetCoinbase(reply *interface{}) error {
*reply = p.pipe.CoinBase() *reply = p.xeth.Coinbase()
return nil return nil
} }
func (p *EthereumApi) GetIsMining(reply *interface{}) error { func (p *EthereumApi) GetIsMining(reply *interface{}) error {
*reply = p.pipe.IsMining() *reply = p.xeth.IsMining()
return nil return nil
} }
@ -143,7 +138,7 @@ func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *interface{}) err
if err != nil { if err != nil {
return err return err
} }
*reply = p.pipe.TxCountAt(args.Address) *reply = p.xeth.TxCountAt(args.Address)
return nil return nil
} }
@ -152,7 +147,7 @@ func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *interface{}) err
if err != nil { if err != nil {
return err 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} *reply = BalanceRes{Balance: state.Balance().String(), Address: args.Address}
return nil return nil
} }
@ -162,12 +157,12 @@ func (p *EthereumApi) GetCodeAt(args *GetCodeAtArgs, reply *interface{}) error {
if err != nil { if err != nil {
return err return err
} }
*reply = p.pipe.CodeAt(args.Address) *reply = p.xeth.CodeAt(args.Address)
return nil return nil
} }
func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error { 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) rpclogger.DebugDetailf("%T %s", req.Params, req.Params)
switch req.Method { switch req.Method {
case "eth_coinbase": case "eth_coinbase":

View File

@ -76,7 +76,7 @@ func (self *WebSocketServer) Start() {
wslogger.Infof("Starting RPC-WS server on port %d", self.port) wslogger.Infof("Starting RPC-WS server on port %d", self.port)
go self.handlerLoop() go self.handlerLoop()
api := rpc.NewEthereumApi(xeth.NewJSXEth(self.eth)) api := rpc.NewEthereumApi(xeth.New(self.eth))
h := self.apiHandler(api) h := self.apiHandler(api)
http.Handle("/ws", h) http.Handle("/ws", h)

View File

@ -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. // 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) { func TestVMArithmetic(t *testing.T) {
const fn = "../files/vmtests/vmArithmeticTest.json" const fn = "../files/VMTests/vmArithmeticTest.json"
RunVmTest(fn, t) RunVmTest(fn, t)
} }
func TestBitwiseLogicOperation(t *testing.T) { func TestBitwiseLogicOperation(t *testing.T) {
const fn = "../files/vmtests/vmBitwiseLogicOperationTest.json" const fn = "../files/VMTests/vmBitwiseLogicOperationTest.json"
RunVmTest(fn, t) RunVmTest(fn, t)
} }
func TestBlockInfo(t *testing.T) { func TestBlockInfo(t *testing.T) {
const fn = "../files/vmtests/vmBlockInfoTest.json" const fn = "../files/VMTests/vmBlockInfoTest.json"
RunVmTest(fn, t) RunVmTest(fn, t)
} }
func TestEnvironmentalInfo(t *testing.T) { func TestEnvironmentalInfo(t *testing.T) {
const fn = "../files/vmtests/vmEnvironmentalInfoTest.json" const fn = "../files/VMTests/vmEnvironmentalInfoTest.json"
RunVmTest(fn, t) RunVmTest(fn, t)
} }
func TestFlowOperation(t *testing.T) { func TestFlowOperation(t *testing.T) {
const fn = "../files/vmtests/vmIOandFlowOperationsTest.json" const fn = "../files/VMTests/vmIOandFlowOperationsTest.json"
RunVmTest(fn, t) RunVmTest(fn, t)
} }
func TestPushDupSwap(t *testing.T) { func TestPushDupSwap(t *testing.T) {
const fn = "../files/vmtests/vmPushDupSwapTest.json" const fn = "../files/VMTests/vmPushDupSwapTest.json"
RunVmTest(fn, t) RunVmTest(fn, t)
} }
func TestVMSha3(t *testing.T) { func TestVMSha3(t *testing.T) {
const fn = "../files/vmtests/vmSha3Test.json" const fn = "../files/VMTests/vmSha3Test.json"
RunVmTest(fn, t) RunVmTest(fn, t)
} }
func TestVm(t *testing.T) { func TestVm(t *testing.T) {
const fn = "../files/vmtests/vmtests.json" const fn = "../files/VMTests/vmtests.json"
RunVmTest(fn, t) RunVmTest(fn, t)
} }
func TestVmLog(t *testing.T) { func TestVmLog(t *testing.T) {
const fn = "../files/vmtests/vmLogTest.json" const fn = "../files/VMTests/vmLogTest.json"
RunVmTest(fn, t) RunVmTest(fn, t)
} }

View File

@ -1,31 +1,371 @@
// +build evmjit
package vm package vm
import "math/big" /*
void* evmjit_create();
int evmjit_run(void* _jit, void* _data, void* _env);
void evmjit_destroy(void* _jit);
// Shared library evmjit (e.g. libevmjit.so) is expected to be installed in /usr/local/lib
// More: https://github.com/ethereum/evmjit
#cgo LDFLAGS: -levmjit
*/
import "C"
import (
"bytes"
"errors"
"fmt"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/state"
"math/big"
"unsafe"
)
type JitVm struct { type JitVm struct {
env Environment env Environment
backup *Vm me ContextRef
callerAddr []byte
price *big.Int
data RuntimeData
}
type i256 [32]byte
type RuntimeData struct {
gas int64
gasPrice int64
callData *byte
callDataSize uint64
address i256
caller i256
origin i256
callValue i256
coinBase i256
difficulty i256
gasLimit i256
number uint64
timestamp int64
code *byte
codeSize uint64
}
func hash2llvm(h []byte) i256 {
var m i256
copy(m[len(m)-len(h):], h) // right aligned copy
return m
}
func llvm2hash(m *i256) []byte {
return C.GoBytes(unsafe.Pointer(m), C.int(len(m)))
}
func llvm2hashRef(m *i256) []byte {
return (*[1 << 30]byte)(unsafe.Pointer(m))[:len(m):len(m)]
}
func address2llvm(addr []byte) i256 {
n := hash2llvm(addr)
bswap(&n)
return n
}
// bswap swap bytes of the 256-bit integer on LLVM side
// TODO: Do not change memory on LLVM side, that can conflict with memory access optimizations
func bswap(m *i256) *i256 {
for i, l := 0, len(m); i < l/2; i++ {
m[i], m[l-i-1] = m[l-i-1], m[i]
}
return m
}
func trim(m []byte) []byte {
skip := 0
for i := 0; i < len(m); i++ {
if m[i] == 0 {
skip++
} else {
break
}
}
return m[skip:]
}
func getDataPtr(m []byte) *byte {
var p *byte
if len(m) > 0 {
p = &m[0]
}
return p
}
func big2llvm(n *big.Int) i256 {
m := hash2llvm(n.Bytes())
bswap(&m)
return m
}
func llvm2big(m *i256) *big.Int {
n := big.NewInt(0)
for i := 0; i < len(m); i++ {
b := big.NewInt(int64(m[i]))
b.Lsh(b, uint(i)*8)
n.Add(n, b)
}
return n
}
// llvm2bytesRef creates a []byte slice that references byte buffer on LLVM side (as of that not controller by GC)
// User must asure that referenced memory is available to Go until the data is copied or not needed any more
func llvm2bytesRef(data *byte, length uint64) []byte {
if length == 0 {
return nil
}
if data == nil {
panic("Unexpected nil data pointer")
}
return (*[1 << 30]byte)(unsafe.Pointer(data))[:length:length]
}
func untested(condition bool, message string) {
if condition {
panic("Condition `" + message + "` tested. Remove assert.")
}
}
func assert(condition bool, message string) {
if !condition {
panic("Assert `" + message + "` failed!")
}
} }
func NewJitVm(env Environment) *JitVm { func NewJitVm(env Environment) *JitVm {
backupVm := New(env) return &JitVm{env: env}
return &JitVm{env: env, backup: backupVm}
} }
func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) { func (self *JitVm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) {
return self.backup.Run(me, caller, code, value, gas, price, callData) // TODO: depth is increased but never checked by VM. VM should not know about it at all.
self.env.SetDepth(self.env.Depth() + 1)
// TODO: Move it to Env.Call() or sth
if Precompiled[string(me.Address())] != nil {
// if it's address of precopiled contract
// fallback to standard VM
stdVm := New(self.env)
return stdVm.Run(me, caller, code, value, gas, price, callData)
}
if self.me != nil {
panic("JitVm.Run() can be called only once per JitVm instance")
}
self.me = me
self.callerAddr = caller.Address()
self.price = price
self.data.gas = gas.Int64()
self.data.gasPrice = price.Int64()
self.data.callData = getDataPtr(callData)
self.data.callDataSize = uint64(len(callData))
self.data.address = address2llvm(self.me.Address())
self.data.caller = address2llvm(caller.Address())
self.data.origin = address2llvm(self.env.Origin())
self.data.callValue = big2llvm(value)
self.data.coinBase = address2llvm(self.env.Coinbase())
self.data.difficulty = big2llvm(self.env.Difficulty())
self.data.gasLimit = big2llvm(self.env.GasLimit())
self.data.number = self.env.BlockNumber().Uint64()
self.data.timestamp = self.env.Time()
self.data.code = getDataPtr(code)
self.data.codeSize = uint64(len(code))
jit := C.evmjit_create()
retCode := C.evmjit_run(jit, unsafe.Pointer(&self.data), unsafe.Pointer(self))
if retCode < 0 {
err = errors.New("OOG from JIT")
gas.SetInt64(0) // Set gas to 0, JIT does not bother
} else {
gas.SetInt64(self.data.gas)
if retCode == 1 { // RETURN
ret = C.GoBytes(unsafe.Pointer(self.data.callData), C.int(self.data.callDataSize))
} else if retCode == 2 { // SUICIDE
// TODO: Suicide support logic should be moved to Env to be shared by VM implementations
state := self.Env().State()
receiverAddr := llvm2hashRef(bswap(&self.data.address))
receiver := state.GetOrNewStateObject(receiverAddr)
balance := state.GetBalance(me.Address())
receiver.AddAmount(balance)
state.Delete(me.Address())
}
}
C.evmjit_destroy(jit);
return
} }
func (self *JitVm) Printf(format string, v ...interface{}) VirtualMachine { func (self *JitVm) Printf(format string, v ...interface{}) VirtualMachine {
return self.backup.Printf(format, v) return self
} }
func (self *JitVm) Endl() VirtualMachine { func (self *JitVm) Endl() VirtualMachine {
return self.backup.Endl() return self
} }
func (self *JitVm) Env() Environment { func (self *JitVm) Env() Environment {
return self.env return self.env
} }
//go is nice //export env_sha3
func env_sha3(dataPtr *byte, length uint64, resultPtr unsafe.Pointer) {
data := llvm2bytesRef(dataPtr, length)
hash := crypto.Sha3(data)
result := (*i256)(resultPtr)
*result = hash2llvm(hash)
}
//export env_sstore
func env_sstore(vmPtr unsafe.Pointer, indexPtr unsafe.Pointer, valuePtr unsafe.Pointer) {
vm := (*JitVm)(vmPtr)
index := llvm2hash(bswap((*i256)(indexPtr)))
value := llvm2hash(bswap((*i256)(valuePtr)))
value = trim(value)
if len(value) == 0 {
prevValue := vm.env.State().GetState(vm.me.Address(), index)
if len(prevValue) != 0 {
vm.Env().State().Refund(vm.callerAddr, GasSStoreRefund)
}
}
vm.env.State().SetState(vm.me.Address(), index, value)
}
//export env_sload
func env_sload(vmPtr unsafe.Pointer, indexPtr unsafe.Pointer, resultPtr unsafe.Pointer) {
vm := (*JitVm)(vmPtr)
index := llvm2hash(bswap((*i256)(indexPtr)))
value := vm.env.State().GetState(vm.me.Address(), index)
result := (*i256)(resultPtr)
*result = hash2llvm(value)
bswap(result)
}
//export env_balance
func env_balance(_vm unsafe.Pointer, _addr unsafe.Pointer, _result unsafe.Pointer) {
vm := (*JitVm)(_vm)
addr := llvm2hash((*i256)(_addr))
balance := vm.Env().State().GetBalance(addr)
result := (*i256)(_result)
*result = big2llvm(balance)
}
//export env_blockhash
func env_blockhash(_vm unsafe.Pointer, _number unsafe.Pointer, _result unsafe.Pointer) {
vm := (*JitVm)(_vm)
number := llvm2big((*i256)(_number))
result := (*i256)(_result)
currNumber := vm.Env().BlockNumber()
limit := big.NewInt(0).Sub(currNumber, big.NewInt(256))
if number.Cmp(limit) >= 0 && number.Cmp(currNumber) < 0 {
hash := vm.Env().GetHash(uint64(number.Int64()))
*result = hash2llvm(hash)
} else {
*result = i256{}
}
}
//export env_call
func env_call(_vm unsafe.Pointer, _gas unsafe.Pointer, _receiveAddr unsafe.Pointer, _value unsafe.Pointer, inDataPtr unsafe.Pointer, inDataLen uint64, outDataPtr *byte, outDataLen uint64, _codeAddr unsafe.Pointer) bool {
vm := (*JitVm)(_vm)
//fmt.Printf("env_call (depth %d)\n", vm.Env().Depth())
defer func() {
if r := recover(); r != nil {
fmt.Printf("Recovered in env_call (depth %d, out %p %d): %s\n", vm.Env().Depth(), outDataPtr, outDataLen, r)
}
}()
balance := vm.Env().State().GetBalance(vm.me.Address())
value := llvm2big((*i256)(_value))
if balance.Cmp(value) >= 0 {
receiveAddr := llvm2hash((*i256)(_receiveAddr))
inData := C.GoBytes(inDataPtr, C.int(inDataLen))
outData := llvm2bytesRef(outDataPtr, outDataLen)
codeAddr := llvm2hash((*i256)(_codeAddr))
llvmGas := (*i256)(_gas)
gas := llvm2big(llvmGas)
var out []byte
var err error
if bytes.Equal(codeAddr, receiveAddr) {
out, err = vm.env.Call(vm.me, codeAddr, inData, gas, vm.price, value)
} else {
out, err = vm.env.CallCode(vm.me, codeAddr, inData, gas, vm.price, value)
}
*llvmGas = big2llvm(gas)
if err == nil {
copy(outData, out)
return true
}
}
return false
}
//export env_create
func env_create(_vm unsafe.Pointer, _gas unsafe.Pointer, _value unsafe.Pointer, initDataPtr unsafe.Pointer, initDataLen uint64, _result unsafe.Pointer) {
vm := (*JitVm)(_vm)
value := llvm2big((*i256)(_value))
initData := C.GoBytes(initDataPtr, C.int(initDataLen)) // TODO: Unnecessary if low balance
result := (*i256)(_result)
*result = i256{}
llvmGas := (*i256)(_gas)
gas := llvm2big(llvmGas)
ret, suberr, ref := vm.env.Create(vm.me, nil, initData, gas, vm.price, value)
if suberr == nil {
dataGas := big.NewInt(int64(len(ret))) // TODO: Nto the best design. env.Create can do it, it has the reference to gas counter
dataGas.Mul(dataGas, GasCreateByte)
gas.Sub(gas, dataGas)
*result = hash2llvm(ref.Address())
}
*llvmGas = big2llvm(gas)
}
//export env_log
func env_log(_vm unsafe.Pointer, dataPtr unsafe.Pointer, dataLen uint64, _topic1 unsafe.Pointer, _topic2 unsafe.Pointer, _topic3 unsafe.Pointer, _topic4 unsafe.Pointer) {
vm := (*JitVm)(_vm)
data := C.GoBytes(dataPtr, C.int(dataLen))
topics := make([][]byte, 0, 4)
if _topic1 != nil {
topics = append(topics, llvm2hash((*i256)(_topic1)))
}
if _topic2 != nil {
topics = append(topics, llvm2hash((*i256)(_topic2)))
}
if _topic3 != nil {
topics = append(topics, llvm2hash((*i256)(_topic3)))
}
if _topic4 != nil {
topics = append(topics, llvm2hash((*i256)(_topic4)))
}
vm.Env().AddLog(state.NewLog(vm.me.Address(), topics, data))
}
//export env_extcode
func env_extcode(_vm unsafe.Pointer, _addr unsafe.Pointer, o_size *uint64) *byte {
vm := (*JitVm)(_vm)
addr := llvm2hash((*i256)(_addr))
code := vm.Env().State().GetCode(addr)
*o_size = uint64(len(code))
return getDataPtr(code)
}

10
vm/vm_jit_fake.go Normal file
View File

@ -0,0 +1,10 @@
// +build !evmjit
package vm
import "fmt"
func NewJitVm(env Environment) VirtualMachine {
fmt.Printf("Warning! EVM JIT not enabled.\n")
return New(env)
}

View File

@ -1,35 +0,0 @@
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
}

View File

@ -1,239 +0,0 @@
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)
}

View File

@ -1,26 +0,0 @@
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))
}

View File

@ -25,8 +25,32 @@ func fromHex(s string) []byte {
return nil 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 // Block interface exposed to QML
type JSBlock struct { type Block struct {
//Transactions string `json:"transactions"` //Transactions string `json:"transactions"`
ref *types.Block ref *types.Block
Size string `json:"size"` Size string `json:"size"`
@ -45,24 +69,24 @@ type JSBlock struct {
} }
// Creates a new QML Block from a chain block // Creates a new QML Block from a chain block
func NewJSBlock(block *types.Block) *JSBlock { func NewBlock(block *types.Block) *Block {
if block == nil { 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() { for i, tx := range block.Transactions() {
ptxs[i] = NewJSTx(tx) ptxs[i] = NewTx(tx)
} }
txlist := ethutil.NewList(ptxs) txlist := ethutil.NewList(ptxs)
puncles := make([]*JSBlock, len(block.Uncles())) puncles := make([]*Block, len(block.Uncles()))
for i, uncle := range block.Uncles() { for i, uncle := range block.Uncles() {
puncles[i] = NewJSBlock(types.NewBlockWithHeader(uncle)) puncles[i] = NewBlock(types.NewBlockWithHeader(uncle))
} }
ulist := ethutil.NewList(puncles) ulist := ethutil.NewList(puncles)
return &JSBlock{ return &Block{
ref: block, Size: block.Size().String(), ref: block, Size: block.Size().String(),
Number: int(block.NumberU64()), GasUsed: block.GasUsed().String(), Number: int(block.NumberU64()), GasUsed: block.GasUsed().String(),
GasLimit: block.GasLimit().String(), Hash: toHex(block.Hash()), 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 { if self.ref != nil {
return self.ref.String() return self.ref.String()
} }
@ -83,16 +107,16 @@ func (self *JSBlock) ToString() string {
return "" return ""
} }
func (self *JSBlock) GetTransaction(hash string) *JSTransaction { func (self *Block) GetTransaction(hash string) *Transaction {
tx := self.ref.Transaction(fromHex(hash)) tx := self.ref.Transaction(fromHex(hash))
if tx == nil { if tx == nil {
return nil return nil
} }
return NewJSTx(tx) return NewTx(tx)
} }
type JSTransaction struct { type Transaction struct {
ref *types.Transaction ref *types.Transaction
Value string `json:"value"` Value string `json:"value"`
@ -108,7 +132,7 @@ type JSTransaction struct {
Confirmations int `json:"confirmations"` Confirmations int `json:"confirmations"`
} }
func NewJSTx(tx *types.Transaction) *JSTransaction { func NewTx(tx *types.Transaction) *Transaction {
hash := toHex(tx.Hash()) hash := toHex(tx.Hash())
receiver := toHex(tx.To()) receiver := toHex(tx.To())
if receiver == "0000000000000000000000000000000000000000" { if receiver == "0000000000000000000000000000000000000000" {
@ -124,29 +148,21 @@ func NewJSTx(tx *types.Transaction) *JSTransaction {
data = toHex(tx.Data()) 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() return self.ref.String()
} }
type JSKey struct { type Key struct {
Address string `json:"address"` Address string `json:"address"`
PrivateKey string `json:"privateKey"` PrivateKey string `json:"privateKey"`
PublicKey string `json:"publicKey"` PublicKey string `json:"publicKey"`
} }
func NewJSKey(key *crypto.KeyPair) *JSKey { func NewKey(key *crypto.KeyPair) *Key {
return &JSKey{toHex(key.Address()), toHex(key.PrivateKey), toHex(key.PublicKey)} return &Key{toHex(key.Address()), toHex(key.PrivateKey), toHex(key.PublicKey)}
}
type JSObject struct {
*Object
}
func NewJSObject(object *Object) *JSObject {
return &JSObject{object}
} }
type PReceipt struct { type PReceipt struct {
@ -167,20 +183,20 @@ func NewPReciept(contractCreation bool, creationAddress, hash, address []byte) *
// Peer interface exposed to QML // Peer interface exposed to QML
type JSPeer struct { type Peer struct {
ref *p2p.Peer ref *p2p.Peer
Ip string `json:"ip"` Ip string `json:"ip"`
Version string `json:"version"` Version string `json:"version"`
Caps string `json:"caps"` Caps string `json:"caps"`
} }
func NewJSPeer(peer *p2p.Peer) *JSPeer { func NewPeer(peer *p2p.Peer) *Peer {
var caps []string var caps []string
for _, cap := range peer.Caps() { for _, cap := range peer.Caps() {
caps = append(caps, fmt.Sprintf("%s/%d", cap.Name, cap.Version)) caps = append(caps, fmt.Sprintf("%s/%d", cap.Name, cap.Version))
} }
return &JSPeer{ return &Peer{
ref: peer, ref: peer,
Ip: fmt.Sprintf("%v", peer.RemoteAddr()), Ip: fmt.Sprintf("%v", peer.RemoteAddr()),
Version: fmt.Sprintf("%v", peer.Identity()), 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"` CreatedContract bool `json:"createdContract"`
Address string `json:"address"` Address string `json:"address"`
Hash string `json:"hash"` Hash string `json:"hash"`
Sender string `json:"sender"` Sender string `json:"sender"`
} }
func NewJSReciept(contractCreation bool, creationAddress, hash, address []byte) *JSReceipt { func NewReciept(contractCreation bool, creationAddress, hash, address []byte) *Receipt {
return &JSReceipt{ return &Receipt{
contractCreation, contractCreation,
toHex(creationAddress), toHex(creationAddress),
toHex(hash), toHex(hash),
@ -204,7 +220,7 @@ func NewJSReciept(contractCreation bool, creationAddress, hash, address []byte)
} }
} }
type JSMessage struct { type Message struct {
To string `json:"to"` To string `json:"to"`
From string `json:"from"` From string `json:"from"`
Input string `json:"input"` Input string `json:"input"`
@ -218,8 +234,8 @@ type JSMessage struct {
Value string `json:"value"` Value string `json:"value"`
} }
func NewJSMessage(message *state.Message) JSMessage { func NewMessage(message *state.Message) Message {
return JSMessage{ return Message{
To: toHex(message.To), To: toHex(message.To),
From: toHex(message.From), From: toHex(message.From),
Input: toHex(message.Input), Input: toHex(message.Input),

View File

@ -1,63 +1,32 @@
package xeth package xeth
import ( import "github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/state"
)
type World struct { type State struct {
pipe *XEth xeth *XEth
cfg *Config
} }
func NewWorld(pipe *XEth) *World { func NewState(xeth *XEth) *State {
world := &World{pipe, nil} return &State{xeth}
world.cfg = &Config{pipe}
return world
} }
func (self *XEth) World() *World { func (self *State) State() *state.StateDB {
return self.world return self.xeth.chainManager.State()
} }
func (self *World) State() *state.StateDB { func (self *State) Get(addr string) *Object {
return self.pipe.chainManager.State() return &Object{self.State().GetStateObject(fromHex(addr))}
} }
func (self *World) Get(addr []byte) *Object { func (self *State) SafeGet(addr string) *Object {
return &Object{self.State().GetStateObject(addr)}
}
func (self *World) SafeGet(addr []byte) *Object {
return &Object{self.safeGet(addr)} return &Object{self.safeGet(addr)}
} }
func (self *World) safeGet(addr []byte) *state.StateObject { func (self *State) safeGet(addr string) *state.StateObject {
object := self.State().GetStateObject(addr) object := self.State().GetStateObject(fromHex(addr))
if object == nil { if object == nil {
object = state.NewStateObject(addr, self.pipe.obj.Db()) object = state.NewStateObject(fromHex(addr), self.xeth.eth.Db())
} }
return object 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
}

View File

@ -5,6 +5,9 @@ package xeth
*/ */
import ( import (
"bytes"
"encoding/json"
"github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
@ -15,167 +18,201 @@ import (
var pipelogger = logger.NewLogger("XETH") var pipelogger = logger.NewLogger("XETH")
type VmVars struct { // to resolve the import cycle
State *state.StateDB 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 { type XEth struct {
obj core.EthManager eth Backend
blockProcessor *core.BlockProcessor blockProcessor *core.BlockProcessor
chainManager *core.ChainManager chainManager *core.ChainManager
world *World world *State
Vm VmVars
} }
func New(obj core.EthManager) *XEth { func New(eth Backend) *XEth {
pipe := &XEth{ xeth := &XEth{
obj: obj, eth: eth,
blockProcessor: obj.BlockProcessor(), blockProcessor: eth.BlockProcessor(),
chainManager: obj.ChainManager(), chainManager: eth.ChainManager(),
} }
pipe.world = NewWorld(pipe) xeth.world = NewState(xeth)
return pipe return xeth
} }
/* func (self *XEth) State() *State { return self.world }
* State / Account accessors
*/ func (self *XEth) BlockByHash(strHash string) *Block {
func (self *XEth) Balance(addr []byte) *ethutil.Value { hash := fromHex(strHash)
return ethutil.NewValue(self.World().safeGet(addr).Balance) block := self.chainManager.GetBlock(hash)
return NewBlock(block)
} }
func (self *XEth) Nonce(addr []byte) uint64 { func (self *XEth) BlockByNumber(num int32) *Block {
return self.World().safeGet(addr).Nonce if num == -1 {
return NewBlock(self.chainManager.CurrentBlock())
} }
func (self *XEth) Block(hash []byte) *types.Block { return NewBlock(self.chainManager.GetBlockByNumber(uint64(num)))
return self.chainManager.GetBlock(hash)
} }
func (self *XEth) Storage(addr, storageAddr []byte) *ethutil.Value { func (self *XEth) Block(v interface{}) *Block {
return self.World().safeGet(addr).GetStorage(ethutil.BigD(storageAddr)) 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))
} }
func (self *XEth) Exists(addr []byte) bool {
return self.World().Get(addr) != nil
}
// 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 return nil
} }
return pair.Address() func (self *XEth) Accounts() []string {
return []string{toHex(self.eth.KeyManager().Address())}
} }
/* /*
* Execution helpers func (self *XEth) StateObject(addr string) *Object {
object := &Object{self.State().safeGet(fromHex(addr))}
return NewObject(object)
}
*/ */
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) PeerCount() int {
return self.eth.PeerCount()
} }
func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) { func (self *XEth) IsMining() bool {
var ( return self.eth.IsMining()
initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address(), self.obj.Db())
block = self.chainManager.CurrentBlock()
)
self.Vm.State = self.World().State().Copy()
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) IsListening() bool {
* Transactional methods return self.eth.IsListening()
*/
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)
} }
return self.Transact(key, hash, value, gas, price, data) func (self *XEth) Coinbase() string {
return toHex(self.eth.KeyManager().Address())
} }
func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) { func (self *XEth) NumberToHuman(balance string) string {
var hash []byte b := ethutil.Big(balance)
var contractCreation bool
if types.IsContractAddr(to) { return ethutil.CurrencyToString(b)
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
}
} }
var tx *types.Transaction func (self *XEth) StorageAt(addr, storageAddr string) string {
if contractCreation { storage := self.State().SafeGet(addr).StorageString(storageAddr)
tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), data)
} else { return toHex(storage.Bytes())
tx = types.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data)
} }
state := self.chainManager.TransState() func (self *XEth) BalanceAt(addr string) string {
nonce := state.GetNonce(key.Address()) return self.State().SafeGet(addr).Balance().String()
}
tx.SetNonce(nonce) func (self *XEth) TxCountAt(address string) int {
tx.Sign(key.PrivateKey) return int(self.State().SafeGet(address).Nonce)
}
// Do some pre processing for our "pre" events and hooks func (self *XEth) CodeAt(address string) string {
block := self.chainManager.NewBlock(key.Address()) return toHex(self.State().SafeGet(address).Code)
coinbase := state.GetOrNewStateObject(key.Address()) }
coinbase.SetGasPool(block.GasLimit())
self.blockProcessor.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true)
err := self.obj.TxPool().Add(tx) func (self *XEth) IsContract(address string) bool {
return len(self.State().SafeGet(address).Code) > 0
}
func (self *XEth) SecretToAddress(key string) string {
pair, err := crypto.NewKeyPairFromSec(fromHex(key))
if err != nil { 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 tx, nil return toHex(pair.Address())
} }
func (self *XEth) PushTx(tx *types.Transaction) ([]byte, error) { func (self *XEth) Execute(addr, value, gas, price, data string) (string, error) {
err := self.obj.TxPool().Add(tx) return "", nil
}
type KeyVal struct {
Key string `json:"key"`
Value string `json:"value"`
}
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)})
}
valuesJson, err := json.Marshal(values)
if err != nil { if err != nil {
return nil, err return ""
}
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 string(bytes.Trim(fromHex(str), "\x00"))
}
func (self *XEth) FromNumber(str string) string {
if ethutil.IsHex(str) {
str = str[2:]
}
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 ethutil.NewList(msgs)
}
func (self *XEth) PushTx(encodedTx string) (string, error) {
tx := types.NewTransactionFromBytes(fromHex(encodedTx))
err := self.eth.TxPool().Add(tx)
if err != nil {
return "", err
} }
if tx.To() == nil { if tx.To() == nil {
addr := core.AddressFromMessage(tx) addr := core.AddressFromMessage(tx)
pipelogger.Infof("Contract addr %x\n", addr) return toHex(addr), nil
return addr, nil
} }
return tx.Hash(), nil return toHex(tx.Hash()), nil
}
func (self *XEth) CompileMutan(code string) ([]byte, error) {
data, err := ethutil.Compile(code, false)
if err != nil {
return nil, err
}
return data, nil
} }