From 1146f25015b6d84072b71c490aba246e3010bd87 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 28 Jan 2015 18:25:50 +0100 Subject: clean up of xeth --- xeth/config.go | 37 ---------- xeth/hexface.go | 211 -------------------------------------------------------- xeth/xeth.go | 211 +++++++++++++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 210 insertions(+), 249 deletions(-) delete mode 100644 xeth/config.go delete mode 100644 xeth/hexface.go (limited to 'xeth') diff --git a/xeth/config.go b/xeth/config.go deleted file mode 100644 index db6cce3bd..000000000 --- a/xeth/config.go +++ /dev/null @@ -1,37 +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 -} -*/ diff --git a/xeth/hexface.go b/xeth/hexface.go deleted file mode 100644 index 3eb535724..000000000 --- a/xeth/hexface.go +++ /dev/null @@ -1,211 +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" -) - -// 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 JSXEth struct { - eth Backend - blockProcessor *core.BlockProcessor - chainManager *core.ChainManager - world *State -} - -func NewJSXEth(eth Backend) *JSXEth { - xeth := &JSXEth{ - eth: eth, - blockProcessor: eth.BlockProcessor(), - chainManager: eth.ChainManager(), - } - xeth.world = NewState(xeth) - - return xeth -} - -func (self *JSXEth) State() *State { return self.world } - -func (self *JSXEth) BlockByHash(strHash string) *JSBlock { - hash := fromHex(strHash) - block := self.chainManager.GetBlock(hash) - - return NewJSBlock(block) -} - -func (self *JSXEth) BlockByNumber(num int32) *JSBlock { - if num == -1 { - return NewJSBlock(self.chainManager.CurrentBlock()) - } - - return NewJSBlock(self.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) Accounts() []string { - return []string{toHex(self.eth.KeyManager().Address())} -} - -/* -func (self *JSXEth) StateObject(addr string) *JSObject { - object := &Object{self.State().safeGet(fromHex(addr))} - - return NewJSObject(object) -} -*/ - -func (self *JSXEth) PeerCount() int { - return self.eth.PeerCount() -} - -func (self *JSXEth) IsMining() bool { - return self.eth.IsMining() -} - -func (self *JSXEth) IsListening() bool { - return self.eth.IsListening() -} - -func (self *JSXEth) Coinbase() string { - return toHex(self.eth.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.State().SafeGet(addr).StorageString(storageAddr) - - return toHex(storage.Bytes()) -} - -func (self *JSXEth) BalanceAt(addr string) string { - return self.State().SafeGet(addr).Balance().String() -} - -func (self *JSXEth) TxCountAt(address string) int { - return int(self.State().SafeGet(address).Nonce) -} - -func (self *JSXEth) CodeAt(address string) string { - return toHex(self.State().SafeGet(address).Code) -} - -func (self *JSXEth) IsContract(address string) bool { - return len(self.State().SafeGet(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) { - return "", nil -} - -type KeyVal struct { - Key string `json:"key"` - Value string `json:"value"` -} - -func (self *JSXEth) 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 { - 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) { - return "", nil -} - -func ToJSMessages(messages state.Messages) *ethutil.List { - var msgs []JSMessage - for _, m := range messages { - msgs = append(msgs, NewJSMessage(m)) - } - - return ethutil.NewList(msgs) -} - -func (self *JSXEth) 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 { - addr := core.AddressFromMessage(tx) - return toHex(addr), nil - } - return toHex(tx.Hash()), nil -} diff --git a/xeth/xeth.go b/xeth/xeth.go index 92b9bc995..6b491b0fe 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -4,6 +4,215 @@ package xeth * eXtended ETHereum */ -import "github.com/ethereum/go-ethereum/logger" +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/logger" + "github.com/ethereum/go-ethereum/state" +) var pipelogger = logger.NewLogger("XETH") + +// 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 JSXEth struct { + eth Backend + blockProcessor *core.BlockProcessor + chainManager *core.ChainManager + world *State +} + +func NewJSXEth(eth Backend) *JSXEth { + xeth := &JSXEth{ + eth: eth, + blockProcessor: eth.BlockProcessor(), + chainManager: eth.ChainManager(), + } + xeth.world = NewState(xeth) + + return xeth +} + +func (self *JSXEth) State() *State { return self.world } + +func (self *JSXEth) BlockByHash(strHash string) *JSBlock { + hash := fromHex(strHash) + block := self.chainManager.GetBlock(hash) + + return NewJSBlock(block) +} + +func (self *JSXEth) BlockByNumber(num int32) *JSBlock { + if num == -1 { + return NewJSBlock(self.chainManager.CurrentBlock()) + } + + return NewJSBlock(self.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) Accounts() []string { + return []string{toHex(self.eth.KeyManager().Address())} +} + +/* +func (self *JSXEth) StateObject(addr string) *JSObject { + object := &Object{self.State().safeGet(fromHex(addr))} + + return NewJSObject(object) +} +*/ + +func (self *JSXEth) PeerCount() int { + return self.eth.PeerCount() +} + +func (self *JSXEth) IsMining() bool { + return self.eth.IsMining() +} + +func (self *JSXEth) IsListening() bool { + return self.eth.IsListening() +} + +func (self *JSXEth) Coinbase() string { + return toHex(self.eth.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.State().SafeGet(addr).StorageString(storageAddr) + + return toHex(storage.Bytes()) +} + +func (self *JSXEth) BalanceAt(addr string) string { + return self.State().SafeGet(addr).Balance().String() +} + +func (self *JSXEth) TxCountAt(address string) int { + return int(self.State().SafeGet(address).Nonce) +} + +func (self *JSXEth) CodeAt(address string) string { + return toHex(self.State().SafeGet(address).Code) +} + +func (self *JSXEth) IsContract(address string) bool { + return len(self.State().SafeGet(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) { + return "", nil +} + +type KeyVal struct { + Key string `json:"key"` + Value string `json:"value"` +} + +func (self *JSXEth) 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 { + 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) { + return "", nil +} + +func ToJSMessages(messages state.Messages) *ethutil.List { + var msgs []JSMessage + for _, m := range messages { + msgs = append(msgs, NewJSMessage(m)) + } + + return ethutil.NewList(msgs) +} + +func (self *JSXEth) 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 { + addr := core.AddressFromMessage(tx) + return toHex(addr), nil + } + return toHex(tx.Hash()), nil +} -- cgit