From c1dee151445d1d9700e0c623916299370868490c Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 5 Jan 2015 00:18:44 +0100 Subject: BlockManager => BlockProcessor --- xeth/xeth.go | 181 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 xeth/xeth.go (limited to 'xeth/xeth.go') diff --git a/xeth/xeth.go b/xeth/xeth.go new file mode 100644 index 000000000..a10ccfc8b --- /dev/null +++ b/xeth/xeth.go @@ -0,0 +1,181 @@ +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" +) + +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()) + 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 fed3e6a808921fb8274b50043c5c39a24a1bbccf Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 7 Jan 2015 13:17:48 +0100 Subject: Refactored ethutil.Config.Db out --- xeth/xeth.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'xeth/xeth.go') diff --git a/xeth/xeth.go b/xeth/xeth.go index a10ccfc8b..34d8ffd0a 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -81,7 +81,7 @@ func (self *XEth) Execute(addr []byte, data []byte, value, gas, price *ethutil.V func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) { var ( - initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address()) + initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address(), self.obj.Db()) block = self.chainManager.CurrentBlock() ) -- cgit v1.2.3 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/xeth.go | 174 +---------------------------------------------------------- 1 file changed, 1 insertion(+), 173 deletions(-) (limited to 'xeth/xeth.go') 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/xeth.go | 211 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 210 insertions(+), 1 deletion(-) (limited to 'xeth/xeth.go') 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/xeth.go | 68 ++++++++++++++++++++++++++++++------------------------------ 1 file changed, 34 insertions(+), 34 deletions(-) (limited to 'xeth/xeth.go') 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/xeth.go') 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/xeth.go') 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/xeth.go') 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 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/xeth.go | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) (limited to 'xeth/xeth.go') 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 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/xeth.go | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) (limited to 'xeth/xeth.go') 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 56f777b2fc77275bc636562b66a08b19afe2ec56 Mon Sep 17 00:00:00 2001 From: Felix Lange Date: Thu, 5 Feb 2015 03:16:16 +0100 Subject: cmd/ethereum, cmd/mist, core, eth, javascript, xeth: fixes for new p2p API --- xeth/xeth.go | 1 - 1 file changed, 1 deletion(-) (limited to 'xeth/xeth.go') diff --git a/xeth/xeth.go b/xeth/xeth.go index 0e71a0ed9..02e68e697 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -31,7 +31,6 @@ type Backend interface { IsListening() bool Peers() []*p2p.Peer KeyManager() *crypto.KeyManager - ClientIdentity() p2p.ClientIdentity Db() ethutil.Database EventMux() *event.TypeMux Whisper() *whisper.Whisper -- 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/xeth.go | 9 --------- 1 file changed, 9 deletions(-) (limited to 'xeth/xeth.go') 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 From 8135752a32837748e6d4a986912131736b1a0aa0 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 17 Feb 2015 12:24:51 +0100 Subject: "centralised" mining to backend. Closes #323 --- xeth/xeth.go | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) (limited to 'xeth/xeth.go') diff --git a/xeth/xeth.go b/xeth/xeth.go index 75d83f80b..27435b956 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -14,6 +14,7 @@ import ( "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/miner" "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/whisper" @@ -27,13 +28,13 @@ type Backend interface { ChainManager() *core.ChainManager TxPool() *core.TxPool PeerCount() int - IsMining() bool IsListening() bool Peers() []*p2p.Peer KeyManager() *crypto.KeyManager Db() ethutil.Database EventMux() *event.TypeMux Whisper() *whisper.Whisper + Miner() *miner.Miner } type XEth struct { @@ -42,6 +43,7 @@ type XEth struct { chainManager *core.ChainManager state *State whisper *Whisper + miner *miner.Miner } func New(eth Backend) *XEth { @@ -50,15 +52,17 @@ func New(eth Backend) *XEth { blockProcessor: eth.BlockProcessor(), chainManager: eth.ChainManager(), whisper: NewWhisper(eth.Whisper()), + miner: eth.Miner(), } 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) Whisper() *Whisper { return self.whisper } +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) Miner() *miner.Miner { return self.miner } func (self *XEth) BlockByHash(strHash string) *Block { hash := fromHex(strHash) @@ -96,7 +100,7 @@ func (self *XEth) PeerCount() int { } func (self *XEth) IsMining() bool { - return self.eth.IsMining() + return self.miner.Mining() } func (self *XEth) IsListening() bool { -- cgit v1.2.3 From 7fc9b5b3f9ca0111cc4bc1b2a6b4bb2eccd3e048 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 17 Feb 2015 22:20:47 +0100 Subject: Changed to ChainEvent and fixed a nil pointer in transact --- xeth/xeth.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'xeth/xeth.go') diff --git a/xeth/xeth.go b/xeth/xeth.go index 27435b956..f005105bb 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -16,7 +16,6 @@ import ( "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/miner" "github.com/ethereum/go-ethereum/p2p" - "github.com/ethereum/go-ethereum/state" "github.com/ethereum/go-ethereum/whisper" ) @@ -220,7 +219,7 @@ func (self *XEth) Call(toStr, valueStr, gasStr, gasPriceStr, dataStr string) (st var ( statedb = self.chainManager.TransState() key = self.eth.KeyManager().KeyPair() - from = state.NewStateObject(key.Address(), self.eth.Db()) + from = statedb.GetOrNewStateObject(key.Address()) block = self.chainManager.CurrentBlock() to = statedb.GetOrNewStateObject(fromHex(toStr)) data = fromHex(dataStr) -- cgit v1.2.3 From a59cd94625f589bb167be7a9c4588ff959dcfc00 Mon Sep 17 00:00:00 2001 From: Taylor Gerring Date: Thu, 19 Feb 2015 18:58:15 +0100 Subject: Add setMining RPC method --- xeth/xeth.go | 11 +++++++++++ 1 file changed, 11 insertions(+) (limited to 'xeth/xeth.go') diff --git a/xeth/xeth.go b/xeth/xeth.go index f005105bb..06915c5e0 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -102,6 +102,17 @@ func (self *XEth) IsMining() bool { return self.miner.Mining() } +func (self *XEth) SetMining(shouldmine bool) bool { + ismining := self.miner.Mining() + if shouldmine && !ismining { + self.miner.Start() + } + if ismining && !shouldmine { + self.miner.Stop() + } + return self.miner.Mining() +} + func (self *XEth) IsListening() bool { return self.eth.IsListening() } -- cgit v1.2.3 From fa4cbad315609e41d88c59ecbce7c6c6169fc57a Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 19 Feb 2015 22:33:22 +0100 Subject: Optimisations and fixed a couple of DDOS issues in the miner --- xeth/xeth.go | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) (limited to 'xeth/xeth.go') diff --git a/xeth/xeth.go b/xeth/xeth.go index f005105bb..d578c03c9 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -7,6 +7,7 @@ package xeth import ( "bytes" "encoding/json" + "fmt" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" @@ -241,7 +242,6 @@ func (self *XEth) Call(toStr, valueStr, gasStr, gasPriceStr, dataStr string) (st } func (self *XEth) Transact(toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { - var ( to []byte value = ethutil.NewValue(valueStr) @@ -265,29 +265,32 @@ func (self *XEth) Transact(toStr, valueStr, gasStr, gasPriceStr, codeStr string) tx = types.NewTransactionMessage(to, value.BigInt(), gas.BigInt(), price.BigInt(), data) } - state := self.chainManager.TransState() + var err error + state := self.eth.ChainManager().TransState() + if balance := state.GetBalance(key.Address()); balance.Cmp(tx.Value()) < 0 { + return "", fmt.Errorf("insufficient balance. balance=%v tx=%v", balance, tx.Value()) + } 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) + //fmt.Printf("create tx: %x %v\n", tx.Hash()[:4], tx.Nonce()) - err := self.eth.TxPool().Add(tx) + /* + // 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 } -- cgit v1.2.3 From ea9a549bbdc8377bca73f1417f2dc4a18396a382 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 20 Feb 2015 14:19:34 +0100 Subject: Removed exported fields from state object and added proper set/getters --- xeth/xeth.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'xeth/xeth.go') diff --git a/xeth/xeth.go b/xeth/xeth.go index d578c03c9..67dac948c 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -128,15 +128,15 @@ func (self *XEth) BalanceAt(addr string) string { } func (self *XEth) TxCountAt(address string) int { - return int(self.State().SafeGet(address).Nonce) + return int(self.State().SafeGet(address).Nonce()) } func (self *XEth) CodeAt(address string) string { - return toHex(self.State().SafeGet(address).Code) + return toHex(self.State().SafeGet(address).Code()) } func (self *XEth) IsContract(address string) bool { - return len(self.State().SafeGet(address).Code) > 0 + return len(self.State().SafeGet(address).Code()) > 0 } func (self *XEth) SecretToAddress(key string) string { -- cgit v1.2.3