status-im
/
op-geth
mirror of https://github.com/status-im/op-geth.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

further cleaned up xeth interface

This commit is contained in:
obscuren 2015-01-28 18:35:49 +01:00
parent 1146f25015
commit 872b249711
15 changed files with 123 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/mist/ext_app.go
View File

@ -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),

12
cmd/mist/gui.go
View File

@ -75,7 +75,7 @@ type Gui struct {
logLevel logger.LogLevel
open bool
xeth *xeth.JSXEth
xeth *xeth.XEth
Session string
clientIdentity *p2p.SimpleClientIdentity
@ -93,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,
@ -120,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 = "" },
}})
@ -276,7 +276,7 @@ func (gui *Gui) insertTransaction(window string, tx *types.Transaction) {
}
var (
ptx = xeth.NewJSTx(tx)
ptx = xeth.NewTx(tx)
send = ethutil.Bytes2Hex(tx.From())
rec = ethutil.Bytes2Hex(tx.To())
)
@ -303,7 +303,7 @@ func (gui *Gui) readPreviousTransactions() {
func (gui *Gui) processBlock(block *types.Block, initial bool) {
name := ethutil.Bytes2Hex(block.Coinbase())
b := xeth.NewJSBlock(block)
b := xeth.NewBlock(block)
b.Name = name
gui.getObjectByName("chainView").Call("addBlock", b, initial)

2
cmd/mist/html_container.go
View File

@ -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)
}

2
cmd/mist/qml_container.go
View File

@ -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)
}

12
cmd/mist/ui_lib.go
View File

@ -44,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
@ -63,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()
@ -180,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"],
@ -202,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"],
@ -261,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
@ -279,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
}

2
cmd/utils/cmd.go
View File

@ -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 {

4
javascript/javascript_runtime.go
View File

@ -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),
}

18
javascript/types.go
View File

@ -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,27 +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) GetStateObject(addr string) otto.Value {
return self.toVal(&JSStateObject{xeth.NewJSObject(self.JSXEth.State().SafeGet(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)

4
rpc/http/server.go
View File

@ -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
}

10
rpc/packages.go
View File

@ -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 {
func NewEthereumApi(xeth *xeth.XEth) *EthereumApi {
return &EthereumApi{xeth: xeth}
}
type EthereumApi struct {
xeth *xeth.JSXEth
xeth *xeth.XEth
}
func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error {
@ -162,7 +162,7 @@ func (p *EthereumApi) GetCodeAt(args *GetCodeAtArgs, 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)
switch req.Method {
case "eth_coinbase":

2
rpc/ws/server.go
View File

@ -75,7 +75,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)

26
xeth/object.go
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))
}

86
xeth/js_types.go → xeth/types.go
View File

@ -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),

4
xeth/world.go
View File

@ -3,10 +3,10 @@ package xeth
import "github.com/ethereum/go-ethereum/state"
type State struct {
xeth *JSXEth
xeth *XEth
}
func NewState(xeth *JSXEth) *State {
func NewState(xeth *XEth) *State {
return &State{xeth}
}

68
xeth/xeth.go
View File

@ -31,15 +31,15 @@ type Backend interface {
TxPool() *core.TxPool
}
type JSXEth struct {
type XEth struct {
eth Backend
blockProcessor *core.BlockProcessor
chainManager *core.ChainManager
world *State
}
func NewJSXEth(eth Backend) *JSXEth {
xeth := &JSXEth{
func New(eth Backend) *XEth {
xeth := &XEth{
eth: eth,
blockProcessor: eth.BlockProcessor(),
chainManager: eth.ChainManager(),
@ -49,24 +49,24 @@ func NewJSXEth(eth Backend) *JSXEth {
return xeth
}
func (self *JSXEth) State() *State { return self.world }
func (self *XEth) State() *State { return self.world }
func (self *JSXEth) BlockByHash(strHash string) *JSBlock {
func (self *XEth) BlockByHash(strHash string) *Block {
hash := fromHex(strHash)
block := self.chainManager.GetBlock(hash)
return NewJSBlock(block)
return NewBlock(block)
}
func (self *JSXEth) BlockByNumber(num int32) *JSBlock {
func (self *XEth) BlockByNumber(num int32) *Block {
if num == -1 {
return NewJSBlock(self.chainManager.CurrentBlock())
return NewBlock(self.chainManager.CurrentBlock())
}
return NewJSBlock(self.chainManager.GetBlockByNumber(uint64(num)))
return NewBlock(self.chainManager.GetBlockByNumber(uint64(num)))
}
func (self *JSXEth) Block(v interface{}) *JSBlock {
func (self *XEth) Block(v interface{}) *Block {
if n, ok := v.(int32); ok {
return self.BlockByNumber(n)
} else if str, ok := v.(string); ok {
@ -78,63 +78,63 @@ func (self *JSXEth) Block(v interface{}) *JSBlock {
return nil
}
func (self *JSXEth) Accounts() []string {
func (self *XEth) Accounts() []string {
return []string{toHex(self.eth.KeyManager().Address())}
}
/*
func (self *JSXEth) StateObject(addr string) *JSObject {
func (self *XEth) StateObject(addr string) *Object {
object := &Object{self.State().safeGet(fromHex(addr))}
return NewJSObject(object)
return NewObject(object)
}
*/
func (self *JSXEth) PeerCount() int {
func (self *XEth) PeerCount() int {
return self.eth.PeerCount()
}
func (self *JSXEth) IsMining() bool {
func (self *XEth) IsMining() bool {
return self.eth.IsMining()
}
func (self *JSXEth) IsListening() bool {
func (self *XEth) IsListening() bool {
return self.eth.IsListening()
}
func (self *JSXEth) Coinbase() string {
func (self *XEth) Coinbase() string {
return toHex(self.eth.KeyManager().Address())
}
func (self *JSXEth) NumberToHuman(balance string) string {
func (self *XEth) NumberToHuman(balance string) string {
b := ethutil.Big(balance)
return ethutil.CurrencyToString(b)
}
func (self *JSXEth) StorageAt(addr, storageAddr string) string {
func (self *XEth) StorageAt(addr, storageAddr string) string {
storage := self.State().SafeGet(addr).StorageString(storageAddr)
return toHex(storage.Bytes())
}
func (self *JSXEth) BalanceAt(addr string) string {
func (self *XEth) BalanceAt(addr string) string {
return self.State().SafeGet(addr).Balance().String()
}
func (self *JSXEth) TxCountAt(address string) int {
func (self *XEth) TxCountAt(address string) int {
return int(self.State().SafeGet(address).Nonce)
}
func (self *JSXEth) CodeAt(address string) string {
func (self *XEth) CodeAt(address string) string {
return toHex(self.State().SafeGet(address).Code)
}
func (self *JSXEth) IsContract(address string) bool {
func (self *XEth) IsContract(address string) bool {
return len(self.State().SafeGet(address).Code) > 0
}
func (self *JSXEth) SecretToAddress(key string) string {
func (self *XEth) SecretToAddress(key string) string {
pair, err := crypto.NewKeyPairFromSec(fromHex(key))
if err != nil {
return ""
@ -143,7 +143,7 @@ func (self *JSXEth) SecretToAddress(key string) string {
return toHex(pair.Address())
}
func (self *JSXEth) Execute(addr, value, gas, price, data string) (string, error) {
func (self *XEth) Execute(addr, value, gas, price, data string) (string, error) {
return "", nil
}
@ -152,7 +152,7 @@ type KeyVal struct {
Value string `json:"value"`
}
func (self *JSXEth) EachStorage(addr string) string {
func (self *XEth) EachStorage(addr string) string {
var values []KeyVal
object := self.State().SafeGet(addr)
it := object.Trie().Iterator()
@ -168,13 +168,13 @@ func (self *JSXEth) EachStorage(addr string) string {
return string(valuesJson)
}
func (self *JSXEth) ToAscii(str string) string {
func (self *XEth) ToAscii(str string) string {
padded := ethutil.RightPadBytes([]byte(str), 32)
return "0x" + toHex(padded)
}
func (self *JSXEth) FromAscii(str string) string {
func (self *XEth) FromAscii(str string) string {
if ethutil.IsHex(str) {
str = str[2:]
}
@ -182,7 +182,7 @@ func (self *JSXEth) FromAscii(str string) string {
return string(bytes.Trim(fromHex(str), "\x00"))
}
func (self *JSXEth) FromNumber(str string) string {
func (self *XEth) FromNumber(str string) string {
if ethutil.IsHex(str) {
str = str[2:]
}
@ -190,20 +190,20 @@ func (self *JSXEth) FromNumber(str string) string {
return ethutil.BigD(fromHex(str)).String()
}
func (self *JSXEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
func (self *XEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
return "", nil
}
func ToJSMessages(messages state.Messages) *ethutil.List {
var msgs []JSMessage
func ToMessages(messages state.Messages) *ethutil.List {
var msgs []Message
for _, m := range messages {
msgs = append(msgs, NewJSMessage(m))
msgs = append(msgs, NewMessage(m))
}
return ethutil.NewList(msgs)
}
func (self *JSXEth) PushTx(encodedTx string) (string, error) {
func (self *XEth) PushTx(encodedTx string) (string, error) {
tx := types.NewTransactionFromBytes(fromHex(encodedTx))
err := self.eth.TxPool().Add(tx)
if err != nil {