From 7f638f0b2d8d989be25e660178d79df3278e4c84 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 28 Jan 2015 18:14:28 +0100 Subject: moving to a better xeth --- xeth/config.go | 2 + xeth/hexface.go | 150 ++++++++++++++++++++---------------------------- xeth/world.go | 57 +++++-------------- xeth/xeth.go | 174 +------------------------------------------------------- 4 files changed, 77 insertions(+), 306 deletions(-) (limited to 'xeth') diff --git a/xeth/config.go b/xeth/config.go index ad0660d75..db6cce3bd 100644 --- a/xeth/config.go +++ b/xeth/config.go @@ -1,5 +1,6 @@ package xeth +/* import "github.com/ethereum/go-ethereum/ethutil" var cnfCtr = ethutil.Hex2Bytes("661005d2720d855f1d9976f88bb10c1a3398c77f") @@ -33,3 +34,4 @@ func (self *Config) Get(name string) *Object { func (self *Config) Exist() bool { return self.pipe.World().Get(cnfCtr) != nil } +*/ diff --git a/xeth/hexface.go b/xeth/hexface.go index 808ae7d39..3eb535724 100644 --- a/xeth/hexface.go +++ b/xeth/hexface.go @@ -11,27 +11,52 @@ import ( "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 { - *XEth + eth Backend + blockProcessor *core.BlockProcessor + chainManager *core.ChainManager + world *State } -func NewJSXEth(eth core.EthManager) *JSXEth { - return &JSXEth{New(eth)} +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.obj.ChainManager().GetBlock(hash) + block := self.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.chainManager.CurrentBlock()) } - return NewJSBlock(self.obj.ChainManager().GetBlockByNumber(uint64(num))) + return NewJSBlock(self.chainManager.GetBlockByNumber(uint64(num))) } func (self *JSXEth) Block(v interface{}) *JSBlock { @@ -46,43 +71,32 @@ func (self *JSXEth) Block(v interface{}) *JSBlock { 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())} + return []string{toHex(self.eth.KeyManager().Address())} } +/* func (self *JSXEth) StateObject(addr string) *JSObject { - object := &Object{self.World().safeGet(fromHex(addr))} + object := &Object{self.State().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 + return self.eth.PeerCount() } func (self *JSXEth) IsMining() bool { - return self.obj.IsMining() + return self.eth.IsMining() } func (self *JSXEth) IsListening() bool { - return self.obj.IsListening() + return self.eth.IsListening() } -func (self *JSXEth) CoinBase() string { - return toHex(self.obj.KeyManager().Address()) +func (self *JSXEth) Coinbase() string { + return toHex(self.eth.KeyManager().Address()) } func (self *JSXEth) NumberToHuman(balance string) string { @@ -92,25 +106,25 @@ func (self *JSXEth) NumberToHuman(balance string) string { } func (self *JSXEth) StorageAt(addr, storageAddr string) string { - storage := self.World().SafeGet(fromHex(addr)).Storage(fromHex(storageAddr)) + storage := self.State().SafeGet(addr).StorageString(storageAddr) return toHex(storage.Bytes()) } func (self *JSXEth) BalanceAt(addr string) string { - return self.World().SafeGet(fromHex(addr)).Balance().String() + return self.State().SafeGet(addr).Balance().String() } func (self *JSXEth) TxCountAt(address string) int { - return int(self.World().SafeGet(fromHex(address)).Nonce) + return int(self.State().SafeGet(address).Nonce) } func (self *JSXEth) CodeAt(address string) string { - return toHex(self.World().SafeGet(fromHex(address)).Code) + return toHex(self.State().SafeGet(address).Code) } func (self *JSXEth) IsContract(address string) bool { - return len(self.World().SafeGet(fromHex(address)).Code) > 0 + return len(self.State().SafeGet(address).Code) > 0 } func (self *JSXEth) SecretToAddress(key string) string { @@ -123,15 +137,7 @@ func (self *JSXEth) SecretToAddress(key string) string { } 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 + return "", nil } type KeyVal struct { @@ -141,7 +147,7 @@ type KeyVal struct { func (self *JSXEth) EachStorage(addr string) string { var values []KeyVal - object := self.World().SafeGet(fromHex(addr)) + object := self.State().SafeGet(addr) it := object.Trie().Iterator() for it.Next() { values = append(values, KeyVal{toHex(it.Key), toHex(it.Value)}) @@ -178,62 +184,28 @@ func (self *JSXEth) FromNumber(str string) 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 + return "", 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 +func ToJSMessages(messages state.Messages) *ethutil.List { + var msgs []JSMessage + for _, m := range messages { + msgs = append(msgs, NewJSMessage(m)) } - return NewJSReciept(core.MessageCreatesContract(tx), core.AddressFromMessage(tx), tx.Hash(), tx.From()), nil + return ethutil.NewList(msgs) } -func (self *JSXEth) CompileMutan(code string) string { - data, err := self.XEth.CompileMutan(code) +func (self *JSXEth) PushTx(encodedTx string) (string, error) { + tx := types.NewTransactionFromBytes(fromHex(encodedTx)) + err := self.eth.TxPool().Add(tx) if err != nil { - return err.Error() + return "", err } - 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)) + if tx.To() == nil { + addr := core.AddressFromMessage(tx) + return toHex(addr), nil } - - return ethutil.NewList(msgs) + return toHex(tx.Hash()), nil } diff --git a/xeth/world.go b/xeth/world.go index 25c2f3eb8..60d4bbb57 100644 --- a/xeth/world.go +++ b/xeth/world.go @@ -1,63 +1,32 @@ package xeth -import ( - "github.com/ethereum/go-ethereum/p2p" - "github.com/ethereum/go-ethereum/state" -) - -type World struct { - pipe *XEth - cfg *Config -} - -func NewWorld(pipe *XEth) *World { - world := &World{pipe, nil} - world.cfg = &Config{pipe} +import "github.com/ethereum/go-ethereum/state" - return world +type State struct { + xeth *JSXEth } -func (self *XEth) World() *World { - return self.world +func NewState(xeth *JSXEth) *State { + return &State{xeth} } -func (self *World) State() *state.StateDB { - return self.pipe.chainManager.State() +func (self *State) State() *state.StateDB { + return self.xeth.chainManager.State() } -func (self *World) Get(addr []byte) *Object { - return &Object{self.State().GetStateObject(addr)} +func (self *State) Get(addr string) *Object { + return &Object{self.State().GetStateObject(fromHex(addr))} } -func (self *World) SafeGet(addr []byte) *Object { +func (self *State) SafeGet(addr string) *Object { return &Object{self.safeGet(addr)} } -func (self *World) safeGet(addr []byte) *state.StateObject { - object := self.State().GetStateObject(addr) +func (self *State) safeGet(addr string) *state.StateObject { + object := self.State().GetStateObject(fromHex(addr)) if object == nil { - object = state.NewStateObject(addr, self.pipe.obj.Db()) + object = state.NewStateObject(fromHex(addr), self.xeth.eth.Db()) } return object } - -func (self *World) Coinbase() *state.StateObject { - return nil -} - -func (self *World) IsMining() bool { - return self.pipe.obj.IsMining() -} - -func (self *World) IsListening() bool { - return self.pipe.obj.IsListening() -} - -func (self *World) Peers() []*p2p.Peer { - return self.pipe.obj.Peers() -} - -func (self *World) Config() *Config { - return self.cfg -} diff --git a/xeth/xeth.go b/xeth/xeth.go index 34d8ffd0a..92b9bc995 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -4,178 +4,6 @@ package xeth * eXtended ETHereum */ -import ( - "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" -) +import "github.com/ethereum/go-ethereum/logger" var pipelogger = logger.NewLogger("XETH") - -type VmVars struct { - State *state.StateDB -} - -type XEth struct { - obj core.EthManager - blockProcessor *core.BlockProcessor - chainManager *core.ChainManager - world *World - - Vm VmVars -} - -func New(obj core.EthManager) *XEth { - pipe := &XEth{ - obj: obj, - blockProcessor: obj.BlockProcessor(), - chainManager: obj.ChainManager(), - } - pipe.world = NewWorld(pipe) - - return pipe -} - -/* - * State / Account accessors - */ -func (self *XEth) Balance(addr []byte) *ethutil.Value { - return ethutil.NewValue(self.World().safeGet(addr).Balance) -} - -func (self *XEth) Nonce(addr []byte) uint64 { - return self.World().safeGet(addr).Nonce -} - -func (self *XEth) Block(hash []byte) *types.Block { - return self.chainManager.GetBlock(hash) -} - -func (self *XEth) Storage(addr, storageAddr []byte) *ethutil.Value { - return self.World().safeGet(addr).GetStorage(ethutil.BigD(storageAddr)) -} - -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 pair.Address() -} - -/* - * Execution helpers - */ -func (self *XEth) Execute(addr []byte, data []byte, value, gas, price *ethutil.Value) ([]byte, error) { - return self.ExecuteObject(&Object{self.World().safeGet(addr)}, data, value, gas, price) -} - -func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) { - var ( - initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address(), self.obj.Db()) - block = self.chainManager.CurrentBlock() - ) - - 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()) -} - -/* - * Transactional methods - */ -func (self *XEth) TransactString(key *crypto.KeyPair, rec string, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) { - // Check if an address is stored by this address - var hash []byte - addr := self.World().Config().Get("NameReg").StorageString(rec).Bytes() - if len(addr) > 0 { - hash = addr - } else if ethutil.IsHex(rec) { - hash = ethutil.Hex2Bytes(rec[2:]) - } else { - hash = ethutil.Hex2Bytes(rec) - } - - return self.Transact(key, hash, value, gas, price, data) -} - -func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) { - var hash []byte - var contractCreation bool - if types.IsContractAddr(to) { - contractCreation = true - } else { - // Check if an address is stored by this address - addr := self.World().Config().Get("NameReg").Storage(to).Bytes() - if len(addr) > 0 { - hash = addr - } else { - hash = to - } - } - - var tx *types.Transaction - if contractCreation { - tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), data) - } else { - tx = types.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data) - } - - state := self.chainManager.TransState() - nonce := state.GetNonce(key.Address()) - - tx.SetNonce(nonce) - tx.Sign(key.PrivateKey) - - // Do some pre processing for our "pre" events and hooks - block := self.chainManager.NewBlock(key.Address()) - coinbase := state.GetOrNewStateObject(key.Address()) - coinbase.SetGasPool(block.GasLimit()) - self.blockProcessor.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true) - - err := self.obj.TxPool().Add(tx) - if err != nil { - return nil, err - } - state.SetNonce(key.Address(), nonce+1) - - if contractCreation { - addr := core.AddressFromMessage(tx) - pipelogger.Infof("Contract addr %x\n", addr) - } - - return tx, nil -} - -func (self *XEth) PushTx(tx *types.Transaction) ([]byte, error) { - err := self.obj.TxPool().Add(tx) - if err != nil { - return nil, err - } - - if tx.To() == nil { - addr := core.AddressFromMessage(tx) - pipelogger.Infof("Contract addr %x\n", addr) - return addr, nil - } - return 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 -} -- cgit v1.2.3 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 v1.2.3 From 872b2497114209119becf2e8a4d4a5818e2084ee Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 28 Jan 2015 18:35:49 +0100 Subject: further cleaned up xeth interface --- xeth/js_types.go | 235 --------------------------------------------------- xeth/object.go | 26 ------ xeth/types.go | 251 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ xeth/world.go | 4 +- xeth/xeth.go | 68 +++++++-------- 5 files changed, 287 insertions(+), 297 deletions(-) delete mode 100644 xeth/js_types.go delete mode 100644 xeth/object.go create mode 100644 xeth/types.go (limited to 'xeth') diff --git a/xeth/js_types.go b/xeth/js_types.go deleted file mode 100644 index a0be996ff..000000000 --- a/xeth/js_types.go +++ /dev/null @@ -1,235 +0,0 @@ -package xeth - -import ( - "fmt" - "strings" - - "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" - "github.com/ethereum/go-ethereum/p2p" - "github.com/ethereum/go-ethereum/state" -) - -func toHex(b []byte) string { - return "0x" + ethutil.Bytes2Hex(b) -} -func fromHex(s string) []byte { - if len(s) > 1 { - if s[0:2] == "0x" { - s = s[2:] - } - return ethutil.Hex2Bytes(s) - } - return nil -} - -// Block interface exposed to QML -type JSBlock struct { - //Transactions string `json:"transactions"` - ref *types.Block - Size string `json:"size"` - Number int `json:"number"` - Hash string `json:"hash"` - Transactions *ethutil.List `json:"transactions"` - Uncles *ethutil.List `json:"uncles"` - Time int64 `json:"time"` - Coinbase string `json:"coinbase"` - Name string `json:"name"` - GasLimit string `json:"gasLimit"` - GasUsed string `json:"gasUsed"` - PrevHash string `json:"prevHash"` - Bloom string `json:"bloom"` - Raw string `json:"raw"` -} - -// Creates a new QML Block from a chain block -func NewJSBlock(block *types.Block) *JSBlock { - if block == nil { - return &JSBlock{} - } - - ptxs := make([]*JSTransaction, len(block.Transactions())) - for i, tx := range block.Transactions() { - ptxs[i] = NewJSTx(tx) - } - txlist := ethutil.NewList(ptxs) - - puncles := make([]*JSBlock, len(block.Uncles())) - for i, uncle := range block.Uncles() { - puncles[i] = NewJSBlock(types.NewBlockWithHeader(uncle)) - } - ulist := ethutil.NewList(puncles) - - return &JSBlock{ - ref: block, Size: block.Size().String(), - Number: int(block.NumberU64()), GasUsed: block.GasUsed().String(), - GasLimit: block.GasLimit().String(), Hash: toHex(block.Hash()), - Transactions: txlist, Uncles: ulist, - Time: block.Time(), - Coinbase: toHex(block.Coinbase()), - PrevHash: toHex(block.ParentHash()), - Bloom: toHex(block.Bloom()), - Raw: block.String(), - } -} - -func (self *JSBlock) ToString() string { - if self.ref != nil { - return self.ref.String() - } - - return "" -} - -func (self *JSBlock) GetTransaction(hash string) *JSTransaction { - tx := self.ref.Transaction(fromHex(hash)) - if tx == nil { - return nil - } - - return NewJSTx(tx) -} - -type JSTransaction struct { - ref *types.Transaction - - Value string `json:"value"` - Gas string `json:"gas"` - GasPrice string `json:"gasPrice"` - Hash string `json:"hash"` - Address string `json:"address"` - Sender string `json:"sender"` - RawData string `json:"rawData"` - Data string `json:"data"` - Contract bool `json:"isContract"` - CreatesContract bool `json:"createsContract"` - Confirmations int `json:"confirmations"` -} - -func NewJSTx(tx *types.Transaction) *JSTransaction { - hash := toHex(tx.Hash()) - receiver := toHex(tx.To()) - if receiver == "0000000000000000000000000000000000000000" { - receiver = toHex(core.AddressFromMessage(tx)) - } - sender := toHex(tx.From()) - createsContract := core.MessageCreatesContract(tx) - - var data string - if createsContract { - data = strings.Join(core.Disassemble(tx.Data()), "\n") - } else { - 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())} -} - -func (self *JSTransaction) ToString() string { - return self.ref.String() -} - -type JSKey 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} -} - -type PReceipt struct { - CreatedContract bool `json:"createdContract"` - Address string `json:"address"` - Hash string `json:"hash"` - Sender string `json:"sender"` -} - -func NewPReciept(contractCreation bool, creationAddress, hash, address []byte) *PReceipt { - return &PReceipt{ - contractCreation, - toHex(creationAddress), - toHex(hash), - toHex(address), - } -} - -// Peer interface exposed to QML - -type JSPeer struct { - ref *p2p.Peer - Ip string `json:"ip"` - Version string `json:"version"` - Caps string `json:"caps"` -} - -func NewJSPeer(peer *p2p.Peer) *JSPeer { - var caps []string - for _, cap := range peer.Caps() { - caps = append(caps, fmt.Sprintf("%s/%d", cap.Name, cap.Version)) - } - - return &JSPeer{ - ref: peer, - Ip: fmt.Sprintf("%v", peer.RemoteAddr()), - Version: fmt.Sprintf("%v", peer.Identity()), - Caps: fmt.Sprintf("%v", caps), - } -} - -type JSReceipt 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{ - contractCreation, - toHex(creationAddress), - toHex(hash), - toHex(address), - } -} - -type JSMessage struct { - To string `json:"to"` - From string `json:"from"` - Input string `json:"input"` - Output string `json:"output"` - Path int32 `json:"path"` - Origin string `json:"origin"` - Timestamp int32 `json:"timestamp"` - Coinbase string `json:"coinbase"` - Block string `json:"block"` - Number int32 `json:"number"` - Value string `json:"value"` -} - -func NewJSMessage(message *state.Message) JSMessage { - return JSMessage{ - To: toHex(message.To), - From: toHex(message.From), - Input: toHex(message.Input), - Output: toHex(message.Output), - Path: int32(message.Path), - Origin: toHex(message.Origin), - Timestamp: int32(message.Timestamp), - Coinbase: toHex(message.Origin), - Block: toHex(message.Block), - Number: int32(message.Number.Int64()), - Value: message.Value.String(), - } -} diff --git a/xeth/object.go b/xeth/object.go deleted file mode 100644 index a4ac41e89..000000000 --- a/xeth/object.go +++ /dev/null @@ -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)) -} diff --git a/xeth/types.go b/xeth/types.go new file mode 100644 index 000000000..4d8543eb1 --- /dev/null +++ b/xeth/types.go @@ -0,0 +1,251 @@ +package xeth + +import ( + "fmt" + "strings" + + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/p2p" + "github.com/ethereum/go-ethereum/state" +) + +func toHex(b []byte) string { + return "0x" + ethutil.Bytes2Hex(b) +} +func fromHex(s string) []byte { + if len(s) > 1 { + if s[0:2] == "0x" { + s = s[2:] + } + return ethutil.Hex2Bytes(s) + } + 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 Block struct { + //Transactions string `json:"transactions"` + ref *types.Block + Size string `json:"size"` + Number int `json:"number"` + Hash string `json:"hash"` + Transactions *ethutil.List `json:"transactions"` + Uncles *ethutil.List `json:"uncles"` + Time int64 `json:"time"` + Coinbase string `json:"coinbase"` + Name string `json:"name"` + GasLimit string `json:"gasLimit"` + GasUsed string `json:"gasUsed"` + PrevHash string `json:"prevHash"` + Bloom string `json:"bloom"` + Raw string `json:"raw"` +} + +// Creates a new QML Block from a chain block +func NewBlock(block *types.Block) *Block { + if block == nil { + return &Block{} + } + + ptxs := make([]*Transaction, len(block.Transactions())) + for i, tx := range block.Transactions() { + ptxs[i] = NewTx(tx) + } + txlist := ethutil.NewList(ptxs) + + puncles := make([]*Block, len(block.Uncles())) + for i, uncle := range block.Uncles() { + puncles[i] = NewBlock(types.NewBlockWithHeader(uncle)) + } + ulist := ethutil.NewList(puncles) + + return &Block{ + ref: block, Size: block.Size().String(), + Number: int(block.NumberU64()), GasUsed: block.GasUsed().String(), + GasLimit: block.GasLimit().String(), Hash: toHex(block.Hash()), + Transactions: txlist, Uncles: ulist, + Time: block.Time(), + Coinbase: toHex(block.Coinbase()), + PrevHash: toHex(block.ParentHash()), + Bloom: toHex(block.Bloom()), + Raw: block.String(), + } +} + +func (self *Block) ToString() string { + if self.ref != nil { + return self.ref.String() + } + + return "" +} + +func (self *Block) GetTransaction(hash string) *Transaction { + tx := self.ref.Transaction(fromHex(hash)) + if tx == nil { + return nil + } + + return NewTx(tx) +} + +type Transaction struct { + ref *types.Transaction + + Value string `json:"value"` + Gas string `json:"gas"` + GasPrice string `json:"gasPrice"` + Hash string `json:"hash"` + Address string `json:"address"` + Sender string `json:"sender"` + RawData string `json:"rawData"` + Data string `json:"data"` + Contract bool `json:"isContract"` + CreatesContract bool `json:"createsContract"` + Confirmations int `json:"confirmations"` +} + +func NewTx(tx *types.Transaction) *Transaction { + hash := toHex(tx.Hash()) + receiver := toHex(tx.To()) + if receiver == "0000000000000000000000000000000000000000" { + receiver = toHex(core.AddressFromMessage(tx)) + } + sender := toHex(tx.From()) + createsContract := core.MessageCreatesContract(tx) + + var data string + if createsContract { + data = strings.Join(core.Disassemble(tx.Data()), "\n") + } else { + data = 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 *Transaction) ToString() string { + return self.ref.String() +} + +type Key struct { + Address string `json:"address"` + PrivateKey string `json:"privateKey"` + PublicKey string `json:"publicKey"` +} + +func NewKey(key *crypto.KeyPair) *Key { + return &Key{toHex(key.Address()), toHex(key.PrivateKey), toHex(key.PublicKey)} +} + +type PReceipt struct { + CreatedContract bool `json:"createdContract"` + Address string `json:"address"` + Hash string `json:"hash"` + Sender string `json:"sender"` +} + +func NewPReciept(contractCreation bool, creationAddress, hash, address []byte) *PReceipt { + return &PReceipt{ + contractCreation, + toHex(creationAddress), + toHex(hash), + toHex(address), + } +} + +// Peer interface exposed to QML + +type Peer struct { + ref *p2p.Peer + Ip string `json:"ip"` + Version string `json:"version"` + Caps string `json:"caps"` +} + +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 &Peer{ + ref: peer, + Ip: fmt.Sprintf("%v", peer.RemoteAddr()), + Version: fmt.Sprintf("%v", peer.Identity()), + Caps: fmt.Sprintf("%v", caps), + } +} + +type Receipt struct { + CreatedContract bool `json:"createdContract"` + Address string `json:"address"` + Hash string `json:"hash"` + Sender string `json:"sender"` +} + +func NewReciept(contractCreation bool, creationAddress, hash, address []byte) *Receipt { + return &Receipt{ + contractCreation, + toHex(creationAddress), + toHex(hash), + toHex(address), + } +} + +type Message struct { + To string `json:"to"` + From string `json:"from"` + Input string `json:"input"` + Output string `json:"output"` + Path int32 `json:"path"` + Origin string `json:"origin"` + Timestamp int32 `json:"timestamp"` + Coinbase string `json:"coinbase"` + Block string `json:"block"` + Number int32 `json:"number"` + Value string `json:"value"` +} + +func NewMessage(message *state.Message) Message { + return Message{ + To: toHex(message.To), + From: toHex(message.From), + Input: toHex(message.Input), + Output: toHex(message.Output), + Path: int32(message.Path), + Origin: toHex(message.Origin), + Timestamp: int32(message.Timestamp), + Coinbase: toHex(message.Origin), + Block: toHex(message.Block), + Number: int32(message.Number.Int64()), + Value: message.Value.String(), + } +} diff --git a/xeth/world.go b/xeth/world.go index 60d4bbb57..cdceec50d 100644 --- a/xeth/world.go +++ b/xeth/world.go @@ -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} } diff --git a/xeth/xeth.go b/xeth/xeth.go index 6b491b0fe..96e545b35 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -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 { -- cgit v1.2.3 From cebb149f5cfaf008240d7069fd220401950cc7ee Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 28 Jan 2015 20:50:09 +0100 Subject: removed key while in the process of moving to the new key storage --- xeth/xeth.go | 68 ++++++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 55 insertions(+), 13 deletions(-) (limited to 'xeth') diff --git a/xeth/xeth.go b/xeth/xeth.go index 96e545b35..89b2459b0 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -22,7 +22,6 @@ var pipelogger = logger.NewLogger("XETH") type Backend interface { BlockProcessor() *core.BlockProcessor ChainManager() *core.ChainManager - Coinbase() []byte KeyManager() *crypto.KeyManager IsMining() bool IsListening() bool @@ -82,14 +81,6 @@ func (self *XEth) Accounts() []string { return []string{toHex(self.eth.KeyManager().Address())} } -/* -func (self *XEth) StateObject(addr string) *Object { - object := &Object{self.State().safeGet(fromHex(addr))} - - return NewObject(object) -} -*/ - func (self *XEth) PeerCount() int { return self.eth.PeerCount() } @@ -190,10 +181,6 @@ func (self *XEth) FromNumber(str string) string { 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 { @@ -216,3 +203,58 @@ func (self *XEth) PushTx(encodedTx string) (string, error) { } return toHex(tx.Hash()), nil } + +func (self *XEth) Transact(toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { + + var ( + to []byte + value = ethutil.NewValue(valueStr) + gas = ethutil.NewValue(gasStr) + price = ethutil.NewValue(gasPriceStr) + data []byte + key = self.eth.KeyManager().KeyPair() + contractCreation bool + ) + + data = fromHex(codeStr) + to = fromHex(toStr) + if len(to) == 0 { + contractCreation = true + } + + var tx *types.Transaction + if contractCreation { + tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), data) + } else { + tx = types.NewTransactionMessage(to, value.BigInt(), gas.BigInt(), price.BigInt(), data) + } + + state := self.chainManager.TransState() + nonce := state.GetNonce(key.Address()) + + tx.SetNonce(nonce) + tx.Sign(key.PrivateKey) + + // Do some pre processing for our "pre" events and hooks + block := self.chainManager.NewBlock(key.Address()) + coinbase := state.GetOrNewStateObject(key.Address()) + coinbase.SetGasPool(block.GasLimit()) + self.blockProcessor.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true) + + err := self.eth.TxPool().Add(tx) + if err != nil { + return "", err + } + state.SetNonce(key.Address(), nonce+1) + + if contractCreation { + addr := core.AddressFromMessage(tx) + pipelogger.Infof("Contract addr %x\n", addr) + } + + if types.IsContractAddr(to) { + return toHex(core.AddressFromMessage(tx)), nil + } + + return toHex(tx.Hash()), nil +} -- cgit v1.2.3 From 84adf77bf3492351de82f0ec820a1d280e85a5cd Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 29 Jan 2015 13:10:34 +0100 Subject: Added RPC "Call" for JS calls to contracts --- xeth/xeth.go | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) (limited to 'xeth') diff --git a/xeth/xeth.go b/xeth/xeth.go index 89b2459b0..382a1f285 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -204,6 +204,34 @@ func (self *XEth) PushTx(encodedTx string) (string, error) { return toHex(tx.Hash()), nil } +func (self *XEth) Call(toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { + if len(gasStr) == 0 { + gasStr = "100000" + } + if len(gasPriceStr) == 0 { + gasPriceStr = "1" + } + + var ( + statedb = self.chainManager.TransState() + initiator = state.NewStateObject(self.eth.KeyManager().KeyPair().Address(), self.eth.Db()) + block = self.chainManager.CurrentBlock() + to = statedb.GetOrNewStateObject(fromHex(toStr)) + data = fromHex(dataStr) + gas = ethutil.Big(gasStr) + price = ethutil.Big(gasPriceStr) + value = ethutil.Big(valueStr) + ) + + vmenv := NewEnv(self.chainManager, statedb, block, value, initiator.Address()) + res, err := vmenv.Call(initiator, to.Address(), data, gas, price, value) + if err != nil { + return "", err + } + + return toHex(res), nil +} + func (self *XEth) Transact(toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { var ( -- cgit v1.2.3 From 6488a392a347d0d47212fdc78386e3e0e5841d7d Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 29 Jan 2015 16:52:00 +0100 Subject: Reimplemented message filters for rpc calls --- xeth/xeth.go | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) (limited to 'xeth') diff --git a/xeth/xeth.go b/xeth/xeth.go index 382a1f285..4cfa104d0 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -12,7 +12,9 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/state" ) @@ -22,19 +24,22 @@ var pipelogger = logger.NewLogger("XETH") type Backend interface { BlockProcessor() *core.BlockProcessor ChainManager() *core.ChainManager - KeyManager() *crypto.KeyManager + TxPool() *core.TxPool + PeerCount() int IsMining() bool IsListening() bool - PeerCount() int + Peers() []*p2p.Peer + KeyManager() *crypto.KeyManager + ClientIdentity() p2p.ClientIdentity Db() ethutil.Database - TxPool() *core.TxPool + EventMux() *event.TypeMux } type XEth struct { eth Backend blockProcessor *core.BlockProcessor chainManager *core.ChainManager - world *State + state *State } func New(eth Backend) *XEth { @@ -43,12 +48,16 @@ func New(eth Backend) *XEth { blockProcessor: eth.BlockProcessor(), chainManager: eth.ChainManager(), } - xeth.world = NewState(xeth) + xeth.state = NewState(xeth) return xeth } -func (self *XEth) State() *State { return self.world } +func (self *XEth) Backend() Backend { + return self.eth +} + +func (self *XEth) State() *State { return self.state } func (self *XEth) BlockByHash(strHash string) *Block { hash := fromHex(strHash) -- cgit v1.2.3 From 0031f388ac1f6f4a23c5c75e5eeb4a007f0b2f31 Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 29 Jan 2015 20:39:26 +0100 Subject: More dapp samples * Info DApp, coin DApp * Additional rpc methods --- xeth/types.go | 19 +++++++++++++++---- xeth/world.go | 2 +- 2 files changed, 16 insertions(+), 5 deletions(-) (limited to 'xeth') diff --git a/xeth/types.go b/xeth/types.go index 4d8543eb1..bee730ba1 100644 --- a/xeth/types.go +++ b/xeth/types.go @@ -35,20 +35,31 @@ func NewObject(state *state.StateObject) *Object { func (self *Object) StorageString(str string) *ethutil.Value { if ethutil.IsHex(str) { - return self.Storage(ethutil.Hex2Bytes(str[2:])) + return self.storage(ethutil.Hex2Bytes(str[2:])) } else { - return self.Storage(ethutil.RightPadBytes([]byte(str), 32)) + return self.storage(ethutil.RightPadBytes([]byte(str), 32)) } } func (self *Object) StorageValue(addr *ethutil.Value) *ethutil.Value { - return self.Storage(addr.Bytes()) + return self.storage(addr.Bytes()) } -func (self *Object) Storage(addr []byte) *ethutil.Value { +func (self *Object) storage(addr []byte) *ethutil.Value { return self.StateObject.GetStorage(ethutil.BigD(addr)) } +func (self *Object) Storage() (storage map[string]string) { + storage = make(map[string]string) + + it := self.StateObject.Trie().Iterator() + for it.Next() { + storage[toHex(it.Key)] = toHex(it.Value) + } + + return +} + // Block interface exposed to QML type Block struct { //Transactions string `json:"transactions"` diff --git a/xeth/world.go b/xeth/world.go index cdceec50d..9cbdd9461 100644 --- a/xeth/world.go +++ b/xeth/world.go @@ -11,7 +11,7 @@ func NewState(xeth *XEth) *State { } func (self *State) State() *state.StateDB { - return self.xeth.chainManager.State() + return self.xeth.chainManager.TransState() } func (self *State) Get(addr string) *Object { -- cgit v1.2.3 From 54927dc0e0b99009f92fbb7b28d71ae20179ce1e Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 29 Jan 2015 23:58:43 +0100 Subject: Fixed issue with Storage() * Storage() returned encoded values. They are now decode prior to hexing * Removed old code from state object * Updated coin --- xeth/types.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) (limited to 'xeth') diff --git a/xeth/types.go b/xeth/types.go index bee730ba1..34caf5cbc 100644 --- a/xeth/types.go +++ b/xeth/types.go @@ -1,6 +1,7 @@ package xeth import ( + "bytes" "fmt" "strings" @@ -9,6 +10,7 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/p2p" + "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/state" ) @@ -54,8 +56,11 @@ func (self *Object) Storage() (storage map[string]string) { it := self.StateObject.Trie().Iterator() for it.Next() { - storage[toHex(it.Key)] = toHex(it.Value) + var data []byte + rlp.Decode(bytes.NewReader(it.Value), &data) + storage[toHex(it.Key)] = toHex(data) } + self.StateObject.Trie().PrintRoot() return } -- cgit v1.2.3 From c03d403437c20584bcbf3cf3fa9d79ac7a0a8ca7 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 30 Jan 2015 13:25:12 +0100 Subject: Added whisper interface for xeth, added examples, updated RPC * Added RPC methods for whisper * Added whisper example --- xeth/whisper.go | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ xeth/xeth.go | 12 +++--- 2 files changed, 123 insertions(+), 5 deletions(-) create mode 100644 xeth/whisper.go (limited to 'xeth') diff --git a/xeth/whisper.go b/xeth/whisper.go new file mode 100644 index 000000000..31201271b --- /dev/null +++ b/xeth/whisper.go @@ -0,0 +1,116 @@ +package xeth + +import ( + "errors" + "fmt" + "time" + + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethutil" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/whisper" +) + +var qlogger = logger.NewLogger("XSHH") + +type Whisper struct { + *whisper.Whisper +} + +func NewWhisper(w *whisper.Whisper) *Whisper { + return &Whisper{w} +} + +func (self *Whisper) Post(payload string, to, from string, topics []string, priority, ttl uint32) error { + if priority == 0 { + priority = 1000 + } + + if ttl == 0 { + ttl = 100 + } + + pk := crypto.ToECDSAPub(fromHex(from)) + if key := self.Whisper.GetIdentity(pk); key != nil || len(from) == 0 { + msg := whisper.NewMessage(fromHex(payload)) + envelope, err := msg.Seal(time.Duration(priority*100000), whisper.Opts{ + Ttl: time.Duration(ttl) * time.Second, + To: crypto.ToECDSAPub(fromHex(to)), + From: key, + Topics: whisper.TopicsFromString(topics...), + }) + + if err != nil { + return err + } + + if err := self.Whisper.Send(envelope); err != nil { + return err + } + } else { + return errors.New("unmatched pub / priv for seal") + } + + return nil +} + +func (self *Whisper) NewIdentity() string { + key := self.Whisper.NewIdentity() + + return toHex(crypto.FromECDSAPub(&key.PublicKey)) +} + +func (self *Whisper) HasIdentity(key string) bool { + return self.Whisper.HasIdentity(crypto.ToECDSAPub(fromHex(key))) +} + +func (self *Whisper) Watch(opts *Options) int { + filter := whisper.Filter{ + To: crypto.ToECDSA(fromHex(opts.To)), + From: crypto.ToECDSAPub(fromHex(opts.From)), + Topics: whisper.TopicsFromString(opts.Topics...), + } + + var i int + filter.Fn = func(msg *whisper.Message) { + opts.Fn(NewWhisperMessage(msg)) + } + fmt.Println("new filter", filter) + + i = self.Whisper.Watch(filter) + + return i +} + +func (self *Whisper) Messages(id int) (messages []WhisperMessage) { + msgs := self.Whisper.Messages(id) + messages = make([]WhisperMessage, len(msgs)) + for i, message := range msgs { + messages[i] = NewWhisperMessage(message) + } + + return +} + +type Options struct { + To string + From string + Topics []string + Fn func(msg WhisperMessage) +} + +type WhisperMessage struct { + ref *whisper.Message + Flags int32 `json:"flags"` + Payload string `json:"payload"` + From string `json:"from"` +} + +func NewWhisperMessage(msg *whisper.Message) WhisperMessage { + return WhisperMessage{ + ref: msg, + Flags: int32(msg.Flags), + Payload: "0x" + ethutil.Bytes2Hex(msg.Payload), + From: "0x" + ethutil.Bytes2Hex(crypto.FromECDSAPub(msg.Recover())), + } +} diff --git a/xeth/xeth.go b/xeth/xeth.go index 4cfa104d0..a65fa1331 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -16,6 +16,7 @@ import ( "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/state" + "github.com/ethereum/go-ethereum/whisper" ) var pipelogger = logger.NewLogger("XETH") @@ -33,6 +34,7 @@ type Backend interface { ClientIdentity() p2p.ClientIdentity Db() ethutil.Database EventMux() *event.TypeMux + Whisper() *whisper.Whisper } type XEth struct { @@ -40,6 +42,7 @@ type XEth struct { blockProcessor *core.BlockProcessor chainManager *core.ChainManager state *State + whisper *Whisper } func New(eth Backend) *XEth { @@ -47,17 +50,16 @@ func New(eth Backend) *XEth { eth: eth, blockProcessor: eth.BlockProcessor(), chainManager: eth.ChainManager(), + whisper: NewWhisper(eth.Whisper()), } xeth.state = NewState(xeth) return xeth } -func (self *XEth) Backend() Backend { - return self.eth -} - -func (self *XEth) State() *State { return self.state } +func (self *XEth) Backend() Backend { return self.eth } +func (self *XEth) State() *State { return self.state } +func (self *XEth) Whisper() *Whisper { return self.whisper } func (self *XEth) BlockByHash(strHash string) *Block { hash := fromHex(strHash) -- cgit v1.2.3 From 2d9b3aa537a901d9b5b3aa951d71d9977c6e4703 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 30 Jan 2015 17:00:33 +0100 Subject: Removed debug log --- xeth/whisper.go | 2 -- 1 file changed, 2 deletions(-) (limited to 'xeth') diff --git a/xeth/whisper.go b/xeth/whisper.go index 31201271b..32ad1332b 100644 --- a/xeth/whisper.go +++ b/xeth/whisper.go @@ -2,7 +2,6 @@ package xeth import ( "errors" - "fmt" "time" "github.com/ethereum/go-ethereum/crypto" @@ -75,7 +74,6 @@ func (self *Whisper) Watch(opts *Options) int { filter.Fn = func(msg *whisper.Message) { opts.Fn(NewWhisperMessage(msg)) } - fmt.Println("new filter", filter) i = self.Whisper.Watch(filter) -- cgit v1.2.3 From d52878c744fd7acce727feb41c2d4296e56826d3 Mon Sep 17 00:00:00 2001 From: obscuren Date: Sun, 1 Feb 2015 15:29:57 +0100 Subject: Removed some VMEnv & Added VmType() to vm.Environment --- xeth/vm_env.go | 72 ---------------------------------------------------------- xeth/xeth.go | 24 ++++++++++++-------- 2 files changed, 14 insertions(+), 82 deletions(-) delete mode 100644 xeth/vm_env.go (limited to 'xeth') diff --git a/xeth/vm_env.go b/xeth/vm_env.go deleted file mode 100644 index 1470b9eaa..000000000 --- a/xeth/vm_env.go +++ /dev/null @@ -1,72 +0,0 @@ -package xeth - -import ( - "math/big" - - "github.com/ethereum/go-ethereum/core" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/state" - "github.com/ethereum/go-ethereum/vm" -) - -type VMEnv struct { - chain *core.ChainManager - state *state.StateDB - block *types.Block - value *big.Int - sender []byte - - depth int -} - -func NewEnv(chain *core.ChainManager, state *state.StateDB, block *types.Block, value *big.Int, sender []byte) *VMEnv { - return &VMEnv{ - state: state, - block: block, - value: value, - sender: sender, - } -} - -func (self *VMEnv) Origin() []byte { return self.sender } -func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number() } -func (self *VMEnv) PrevHash() []byte { return self.block.ParentHash() } -func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase() } -func (self *VMEnv) Time() int64 { return self.block.Time() } -func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty() } -func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit() } -func (self *VMEnv) Value() *big.Int { return self.value } -func (self *VMEnv) State() *state.StateDB { return self.state } -func (self *VMEnv) Depth() int { return self.depth } -func (self *VMEnv) SetDepth(i int) { self.depth = i } -func (self *VMEnv) GetHash(n uint64) []byte { - if block := self.chain.GetBlockByNumber(n); block != nil { - return block.Hash() - } - - return nil -} -func (self *VMEnv) AddLog(log state.Log) { - self.state.AddLog(log) -} -func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error { - return vm.Transfer(from, to, amount) -} - -func (self *VMEnv) vm(addr, data []byte, gas, price, value *big.Int) *core.Execution { - return core.NewExecution(self, addr, data, gas, price, value) -} - -func (self *VMEnv) Call(me vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) { - exe := self.vm(addr, data, gas, price, value) - return exe.Call(addr, me) -} -func (self *VMEnv) CallCode(me vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) { - exe := self.vm(me.Address(), data, gas, price, value) - return exe.Call(addr, me) -} - -func (self *VMEnv) Create(me vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ContextRef) { - exe := self.vm(addr, data, gas, price, value) - return exe.Create(me) -} diff --git a/xeth/xeth.go b/xeth/xeth.go index a65fa1331..0e71a0ed9 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -224,18 +224,22 @@ func (self *XEth) Call(toStr, valueStr, gasStr, gasPriceStr, dataStr string) (st } var ( - statedb = self.chainManager.TransState() - initiator = state.NewStateObject(self.eth.KeyManager().KeyPair().Address(), self.eth.Db()) - block = self.chainManager.CurrentBlock() - to = statedb.GetOrNewStateObject(fromHex(toStr)) - data = fromHex(dataStr) - gas = ethutil.Big(gasStr) - price = ethutil.Big(gasPriceStr) - value = ethutil.Big(valueStr) + statedb = self.chainManager.TransState() + key = self.eth.KeyManager().KeyPair() + from = state.NewStateObject(key.Address(), self.eth.Db()) + block = self.chainManager.CurrentBlock() + to = statedb.GetOrNewStateObject(fromHex(toStr)) + data = fromHex(dataStr) + gas = ethutil.Big(gasStr) + price = ethutil.Big(gasPriceStr) + value = ethutil.Big(valueStr) ) - vmenv := NewEnv(self.chainManager, statedb, block, value, initiator.Address()) - res, err := vmenv.Call(initiator, to.Address(), data, gas, price, value) + msg := types.NewTransactionMessage(fromHex(toStr), value, gas, price, data) + msg.Sign(key.PrivateKey) + vmenv := core.NewEnv(statedb, self.chainManager, msg, block) + + res, err := vmenv.Call(from, to.Address(), data, gas, price, value) if err != nil { return "", err } -- cgit v1.2.3 From 623469cb6c6cdb6ff84dc2cb7d4409e9d7cf3f65 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 3 Feb 2015 06:56:19 -0800 Subject: Added missing whisper timestamp. Closes #284 --- xeth/whisper.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'xeth') diff --git a/xeth/whisper.go b/xeth/whisper.go index 32ad1332b..d537f8c54 100644 --- a/xeth/whisper.go +++ b/xeth/whisper.go @@ -99,16 +99,16 @@ type Options struct { type WhisperMessage struct { ref *whisper.Message - Flags int32 `json:"flags"` Payload string `json:"payload"` From string `json:"from"` + Sent uint64 `json:"time"` } func NewWhisperMessage(msg *whisper.Message) WhisperMessage { return WhisperMessage{ ref: msg, - Flags: int32(msg.Flags), Payload: "0x" + ethutil.Bytes2Hex(msg.Payload), From: "0x" + ethutil.Bytes2Hex(crypto.FromECDSAPub(msg.Recover())), + Sent: msg.Sent, } } -- cgit v1.2.3 From 7bd2fbe2b1445c26190008d21ad52dc5c364765c Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 3 Feb 2015 07:16:05 -0800 Subject: Fixed whisper "to" filtering. Closes #283 --- xeth/whisper.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'xeth') diff --git a/xeth/whisper.go b/xeth/whisper.go index d537f8c54..42d7c44bc 100644 --- a/xeth/whisper.go +++ b/xeth/whisper.go @@ -2,6 +2,7 @@ package xeth import ( "errors" + "fmt" "time" "github.com/ethereum/go-ethereum/crypto" @@ -31,6 +32,7 @@ func (self *Whisper) Post(payload string, to, from string, topics []string, prio pk := crypto.ToECDSAPub(fromHex(from)) if key := self.Whisper.GetIdentity(pk); key != nil || len(from) == 0 { + fmt.Println("POST:", to) msg := whisper.NewMessage(fromHex(payload)) envelope, err := msg.Seal(time.Duration(priority*100000), whisper.Opts{ Ttl: time.Duration(ttl) * time.Second, @@ -101,7 +103,7 @@ type WhisperMessage struct { ref *whisper.Message Payload string `json:"payload"` From string `json:"from"` - Sent uint64 `json:"time"` + Sent int64 `json:"time"` } func NewWhisperMessage(msg *whisper.Message) WhisperMessage { -- cgit v1.2.3 From b1870631a4829e075eae77064973ef94aa2166b3 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 4 Feb 2015 05:52:59 -0800 Subject: WIP miner --- xeth/whisper.go | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) (limited to 'xeth') diff --git a/xeth/whisper.go b/xeth/whisper.go index 42d7c44bc..52f4593e4 100644 --- a/xeth/whisper.go +++ b/xeth/whisper.go @@ -2,11 +2,9 @@ package xeth import ( "errors" - "fmt" "time" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/whisper" ) @@ -32,7 +30,6 @@ func (self *Whisper) Post(payload string, to, from string, topics []string, prio pk := crypto.ToECDSAPub(fromHex(from)) if key := self.Whisper.GetIdentity(pk); key != nil || len(from) == 0 { - fmt.Println("POST:", to) msg := whisper.NewMessage(fromHex(payload)) envelope, err := msg.Seal(time.Duration(priority*100000), whisper.Opts{ Ttl: time.Duration(ttl) * time.Second, @@ -109,8 +106,8 @@ type WhisperMessage struct { func NewWhisperMessage(msg *whisper.Message) WhisperMessage { return WhisperMessage{ ref: msg, - Payload: "0x" + ethutil.Bytes2Hex(msg.Payload), - From: "0x" + ethutil.Bytes2Hex(crypto.FromECDSAPub(msg.Recover())), + Payload: toHex(msg.Payload), + From: toHex(crypto.FromECDSAPub(msg.Recover())), Sent: msg.Sent, } } -- cgit v1.2.3 From e40c1c62ce0c2d9567066d84ea74fd24b424a81a Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 5 Feb 2015 15:00:59 -0800 Subject: API changed to use Pubkey only. Reflected that change in the rest of the api --- xeth/whisper.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'xeth') diff --git a/xeth/whisper.go b/xeth/whisper.go index 52f4593e4..8e3bcefd0 100644 --- a/xeth/whisper.go +++ b/xeth/whisper.go @@ -64,7 +64,7 @@ func (self *Whisper) HasIdentity(key string) bool { func (self *Whisper) Watch(opts *Options) int { filter := whisper.Filter{ - To: crypto.ToECDSA(fromHex(opts.To)), + To: crypto.ToECDSAPub(fromHex(opts.To)), From: crypto.ToECDSAPub(fromHex(opts.From)), Topics: whisper.TopicsFromString(opts.Topics...), } -- cgit v1.2.3 From ddccea75e8f4931689fdf6b57ec7159b65c0d3c5 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 10 Feb 2015 13:20:06 +0100 Subject: Fixed "to" field --- xeth/whisper.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'xeth') diff --git a/xeth/whisper.go b/xeth/whisper.go index 8e3bcefd0..d9c7e1614 100644 --- a/xeth/whisper.go +++ b/xeth/whisper.go @@ -99,8 +99,9 @@ type Options struct { type WhisperMessage struct { ref *whisper.Message Payload string `json:"payload"` + To string `json:"to"` From string `json:"from"` - Sent int64 `json:"time"` + Sent int64 `json:"sent"` } func NewWhisperMessage(msg *whisper.Message) WhisperMessage { @@ -108,6 +109,7 @@ func NewWhisperMessage(msg *whisper.Message) WhisperMessage { ref: msg, Payload: toHex(msg.Payload), From: toHex(crypto.FromECDSAPub(msg.Recover())), + To: toHex(crypto.FromECDSAPub(msg.To)), Sent: msg.Sent, } } -- cgit v1.2.3 From 38faf2c51a1e4a86cda5dfa1b4f7fdae4fd7f58d Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 12 Feb 2015 17:06:15 +0100 Subject: removed messages --- xeth/types.go | 30 ------------------------------ xeth/xeth.go | 9 --------- 2 files changed, 39 deletions(-) (limited to 'xeth') diff --git a/xeth/types.go b/xeth/types.go index 34caf5cbc..1bab1e1b3 100644 --- a/xeth/types.go +++ b/xeth/types.go @@ -235,33 +235,3 @@ func NewReciept(contractCreation bool, creationAddress, hash, address []byte) *R toHex(address), } } - -type Message struct { - To string `json:"to"` - From string `json:"from"` - Input string `json:"input"` - Output string `json:"output"` - Path int32 `json:"path"` - Origin string `json:"origin"` - Timestamp int32 `json:"timestamp"` - Coinbase string `json:"coinbase"` - Block string `json:"block"` - Number int32 `json:"number"` - Value string `json:"value"` -} - -func NewMessage(message *state.Message) Message { - return Message{ - To: toHex(message.To), - From: toHex(message.From), - Input: toHex(message.Input), - Output: toHex(message.Output), - Path: int32(message.Path), - Origin: toHex(message.Origin), - Timestamp: int32(message.Timestamp), - Coinbase: toHex(message.Origin), - Block: toHex(message.Block), - Number: int32(message.Number.Int64()), - Value: message.Value.String(), - } -} diff --git a/xeth/xeth.go b/xeth/xeth.go index 0e71a0ed9..4098daf98 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -192,15 +192,6 @@ func (self *XEth) FromNumber(str string) string { return ethutil.BigD(fromHex(str)).String() } -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) -- cgit v1.2.3