aboutsummaryrefslogtreecommitdiffstats
path: root/xeth
diff options
context:
space:
mode:
Diffstat (limited to 'xeth')
-rw-r--r--xeth/frontend.go32
-rw-r--r--xeth/state.go4
-rw-r--r--xeth/types.go4
-rw-r--r--xeth/xeth.go255
4 files changed, 166 insertions, 129 deletions
diff --git a/xeth/frontend.go b/xeth/frontend.go
new file mode 100644
index 000000000..8deb5c98c
--- /dev/null
+++ b/xeth/frontend.go
@@ -0,0 +1,32 @@
+package xeth
+
+import (
+ "github.com/ethereum/go-ethereum/core/types"
+)
+
+// Frontend should be implemented by users of XEth. Its methods are
+// called whenever XEth makes a decision that requires user input.
+type Frontend interface {
+ // UnlockAccount is called when a transaction needs to be signed
+ // but the key corresponding to the transaction's sender is
+ // locked.
+ //
+ // It should unlock the account with the given address and return
+ // true if unlocking succeeded.
+ UnlockAccount(address []byte) bool
+
+ // This is called for all transactions inititated through
+ // Transact. It should prompt the user to confirm the transaction
+ // and return true if the transaction was acknowledged.
+ //
+ // ConfirmTransaction is not used for Call transactions
+ // because they cannot change any state.
+ ConfirmTransaction(tx *types.Transaction) bool
+}
+
+// dummyFrontend is a non-interactive frontend that allows all
+// transactions but cannot not unlock any keys.
+type dummyFrontend struct{}
+
+func (dummyFrontend) UnlockAccount([]byte) bool { return false }
+func (dummyFrontend) ConfirmTransaction(*types.Transaction) bool { return true }
diff --git a/xeth/state.go b/xeth/state.go
index f645a9cac..669cf91e6 100644
--- a/xeth/state.go
+++ b/xeth/state.go
@@ -2,7 +2,7 @@ package xeth
import (
"github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/state"
+ "github.com/ethereum/go-ethereum/core/state"
)
type State struct {
@@ -29,7 +29,7 @@ func (self *State) SafeGet(addr string) *Object {
func (self *State) safeGet(addr string) *state.StateObject {
object := self.state.GetStateObject(common.HexToAddress(addr))
if object == nil {
- object = state.NewStateObject(common.HexToAddress(addr), self.xeth.eth.StateDb())
+ object = state.NewStateObject(common.HexToAddress(addr), self.xeth.backend.StateDb())
}
return object
diff --git a/xeth/types.go b/xeth/types.go
index b4ba7bab0..3f96f8f8b 100644
--- a/xeth/types.go
+++ b/xeth/types.go
@@ -7,11 +7,11 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/state"
)
type Object struct {
@@ -45,7 +45,7 @@ func (self *Object) Storage() (storage map[string]string) {
for it.Next() {
var data []byte
rlp.Decode(bytes.NewReader(it.Value), &data)
- storage[common.ToHex(it.Key)] = common.ToHex(data)
+ storage[common.ToHex(self.Trie().GetKey(it.Key))] = common.ToHex(data)
}
return
diff --git a/xeth/xeth.go b/xeth/xeth.go
index d3c3131d4..7e1548964 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -12,15 +12,13 @@ import (
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/eth"
"github.com/ethereum/go-ethereum/event/filter"
"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"
)
var (
@@ -30,65 +28,13 @@ var (
defaultGas = big.NewInt(90000) //500000
)
-// to resolve the import cycle
-type Backend interface {
- BlockProcessor() *core.BlockProcessor
- ChainManager() *core.ChainManager
- AccountManager() *accounts.Manager
- TxPool() *core.TxPool
- PeerCount() int
- IsListening() bool
- Peers() []*p2p.Peer
- BlockDb() common.Database
- StateDb() common.Database
- ExtraDb() common.Database
- EventMux() *event.TypeMux
- Whisper() *whisper.Whisper
- Miner() *miner.Miner
-
- IsMining() bool
- StartMining() error
- StopMining()
- Version() string
-}
-
-// Frontend should be implemented by users of XEth. Its methods are
-// called whenever XEth makes a decision that requires user input.
-type Frontend interface {
- // UnlockAccount is called when a transaction needs to be signed
- // but the key corresponding to the transaction's sender is
- // locked.
- //
- // It should unlock the account with the given address and return
- // true if unlocking succeeded.
- UnlockAccount(address []byte) bool
-
- // This is called for all transactions inititated through
- // Transact. It should prompt the user to confirm the transaction
- // and return true if the transaction was acknowledged.
- //
- // ConfirmTransaction is not used for Call transactions
- // because they cannot change any state.
- ConfirmTransaction(tx *types.Transaction) bool
-}
-
-// dummyFrontend is a non-interactive frontend that allows all
-// transactions but cannot not unlock any keys.
-type dummyFrontend struct{}
-
-func (dummyFrontend) UnlockAccount([]byte) bool { return false }
-func (dummyFrontend) ConfirmTransaction(*types.Transaction) bool { return true }
-
type XEth struct {
- eth Backend
- blockProcessor *core.BlockProcessor
- chainManager *core.ChainManager
- accountManager *accounts.Manager
- state *State
- whisper *Whisper
-
+ backend *eth.Ethereum
frontend Frontend
+ state *State
+ whisper *Whisper
+
quit chan struct{}
filterManager *filter.FilterManager
@@ -100,28 +46,31 @@ type XEth struct {
// regmut sync.Mutex
// register map[string][]*interface{} // TODO improve return type
+
+ agent *miner.RemoteAgent
}
// New creates an XEth that uses the given frontend.
// If a nil Frontend is provided, a default frontend which
// confirms all transactions will be used.
-func New(eth Backend, frontend Frontend) *XEth {
+func New(eth *eth.Ethereum, frontend Frontend) *XEth {
xeth := &XEth{
- eth: eth,
- blockProcessor: eth.BlockProcessor(),
- chainManager: eth.ChainManager(),
- accountManager: eth.AccountManager(),
- whisper: NewWhisper(eth.Whisper()),
- quit: make(chan struct{}),
- filterManager: filter.NewFilterManager(eth.EventMux()),
- frontend: frontend,
- logs: make(map[int]*logFilter),
- messages: make(map[int]*whisperFilter),
+ backend: eth,
+ frontend: frontend,
+ whisper: NewWhisper(eth.Whisper()),
+ quit: make(chan struct{}),
+ filterManager: filter.NewFilterManager(eth.EventMux()),
+ logs: make(map[int]*logFilter),
+ messages: make(map[int]*whisperFilter),
+ agent: miner.NewRemoteAgent(),
}
+ eth.Miner().Register(xeth.agent)
+
if frontend == nil {
xeth.frontend = dummyFrontend{}
}
- xeth.state = NewState(xeth, xeth.chainManager.TransState())
+ xeth.state = NewState(xeth, xeth.backend.ChainManager().TransState())
+
go xeth.start()
go xeth.filterManager.Start()
@@ -161,59 +110,83 @@ func (self *XEth) stop() {
close(self.quit)
}
+func cAddress(a []string) []common.Address {
+ bslice := make([]common.Address, len(a))
+ for i, addr := range a {
+ bslice[i] = common.HexToAddress(addr)
+ }
+ return bslice
+}
+
+func cTopics(t [][]string) [][]common.Hash {
+ topics := make([][]common.Hash, len(t))
+ for i, iv := range t {
+ for j, jv := range iv {
+ topics[i][j] = common.HexToHash(jv)
+ }
+ }
+ return topics
+}
+
func (self *XEth) DefaultGas() *big.Int { return defaultGas }
func (self *XEth) DefaultGasPrice() *big.Int { return defaultGasPrice }
-func (self *XEth) AtStateNum(num int64) *XEth {
- chain := self.Backend().ChainManager()
- var block *types.Block
+func (self *XEth) RemoteMining() *miner.RemoteAgent { return self.agent }
- if num < 0 {
- num = chain.CurrentBlock().Number().Int64() + num + 1
- }
- block = chain.GetBlockByNumber(uint64(num))
+func (self *XEth) AtStateNum(num int64) *XEth {
+ block := self.getBlockByHeight(num)
var st *state.StateDB
if block != nil {
- st = state.New(block.Root(), self.Backend().StateDb())
+ st = state.New(block.Root(), self.backend.StateDb())
} else {
- st = chain.State()
+ st = self.backend.ChainManager().State()
}
- return self.WithState(st)
+
+ return self.withState(st)
}
-func (self *XEth) Backend() Backend { return self.eth }
-func (self *XEth) WithState(statedb *state.StateDB) *XEth {
+func (self *XEth) withState(statedb *state.StateDB) *XEth {
xeth := &XEth{
- eth: self.eth,
- blockProcessor: self.blockProcessor,
- chainManager: self.chainManager,
- whisper: self.whisper,
+ backend: self.backend,
}
xeth.state = NewState(xeth, statedb)
return xeth
}
+
func (self *XEth) State() *State { return self.state }
func (self *XEth) Whisper() *Whisper { return self.whisper }
+func (self *XEth) getBlockByHeight(height int64) *types.Block {
+ var num uint64
+
+ if height < 0 {
+ num = self.CurrentBlock().NumberU64() + uint64(-1*height)
+ } else {
+ num = uint64(height)
+ }
+
+ return self.backend.ChainManager().GetBlockByNumber(num)
+}
+
func (self *XEth) BlockByHash(strHash string) *Block {
hash := common.HexToHash(strHash)
- block := self.chainManager.GetBlock(hash)
+ block := self.backend.ChainManager().GetBlock(hash)
return NewBlock(block)
}
func (self *XEth) EthBlockByHash(strHash string) *types.Block {
hash := common.HexToHash(strHash)
- block := self.chainManager.GetBlock(hash)
+ block := self.backend.ChainManager().GetBlock(hash)
return block
}
func (self *XEth) EthTransactionByHash(hash string) *types.Transaction {
- data, _ := self.eth.ExtraDb().Get(common.FromHex(hash))
+ data, _ := self.backend.ExtraDb().Get(common.FromHex(hash))
if len(data) != 0 {
return types.NewTransactionFromBytes(data)
}
@@ -221,19 +194,15 @@ func (self *XEth) EthTransactionByHash(hash string) *types.Transaction {
}
func (self *XEth) BlockByNumber(num int64) *Block {
- if num == -1 {
- return NewBlock(self.chainManager.CurrentBlock())
- }
-
- return NewBlock(self.chainManager.GetBlockByNumber(uint64(num)))
+ return NewBlock(self.getBlockByHeight(num))
}
func (self *XEth) EthBlockByNumber(num int64) *types.Block {
- if num == -1 {
- return self.chainManager.CurrentBlock()
- }
+ return self.getBlockByHeight(num)
+}
- return self.chainManager.GetBlockByNumber(uint64(num))
+func (self *XEth) CurrentBlock() *types.Block {
+ return self.backend.ChainManager().CurrentBlock()
}
func (self *XEth) Block(v interface{}) *Block {
@@ -250,7 +219,7 @@ func (self *XEth) Block(v interface{}) *Block {
func (self *XEth) Accounts() []string {
// TODO: check err?
- accounts, _ := self.eth.AccountManager().Accounts()
+ accounts, _ := self.backend.AccountManager().Accounts()
accountAddresses := make([]string, len(accounts))
for i, ac := range accounts {
accountAddresses[i] = common.ToHex(ac.Address)
@@ -258,33 +227,59 @@ func (self *XEth) Accounts() []string {
return accountAddresses
}
+func (self *XEth) DbPut(key, val []byte) bool {
+ self.backend.ExtraDb().Put(key, val)
+ return true
+}
+
+func (self *XEth) DbGet(key []byte) ([]byte, error) {
+ val, err := self.backend.ExtraDb().Get(key)
+ return val, err
+}
+
func (self *XEth) PeerCount() int {
- return self.eth.PeerCount()
+ return self.backend.PeerCount()
}
func (self *XEth) IsMining() bool {
- return self.eth.IsMining()
+ return self.backend.IsMining()
+}
+
+func (self *XEth) EthVersion() string {
+ return fmt.Sprintf("%d", self.backend.EthVersion())
+}
+
+func (self *XEth) NetworkVersion() string {
+ return fmt.Sprintf("%d", self.backend.NetVersion())
+}
+
+func (self *XEth) WhisperVersion() string {
+ return fmt.Sprintf("%d", self.backend.ShhVersion())
+}
+
+func (self *XEth) ClientVersion() string {
+ return self.backend.ClientVersion()
}
func (self *XEth) SetMining(shouldmine bool) bool {
- ismining := self.eth.IsMining()
+ ismining := self.backend.IsMining()
if shouldmine && !ismining {
- err := self.eth.StartMining()
+ err := self.backend.StartMining()
return err == nil
}
if ismining && !shouldmine {
- self.eth.StopMining()
+ self.backend.StopMining()
}
- return self.eth.IsMining()
+ return self.backend.IsMining()
}
func (self *XEth) IsListening() bool {
- return self.eth.IsListening()
+ return self.backend.IsListening()
}
func (self *XEth) Coinbase() string {
- cb, _ := self.eth.AccountManager().Coinbase()
- return common.ToHex(cb)
+ eb, _ := self.backend.Etherbase()
+ return eb.Hex()
}
func (self *XEth) NumberToHuman(balance string) string {
@@ -324,10 +319,15 @@ func (self *XEth) SecretToAddress(key string) string {
return common.ToHex(pair.Address())
}
-func (self *XEth) RegisterFilter(args *core.FilterOptions) int {
+func (self *XEth) RegisterFilter(earliest, latest int64, skip, max int, address []string, topics [][]string) int {
var id int
- filter := core.NewFilter(self.Backend())
- filter.SetOptions(args)
+ filter := core.NewFilter(self.backend)
+ filter.SetEarliestBlock(earliest)
+ filter.SetLatestBlock(latest)
+ filter.SetSkip(skip)
+ filter.SetMax(max)
+ filter.SetAddress(cAddress(address))
+ filter.SetTopics(cTopics(topics))
filter.LogsCallback = func(logs state.Logs) {
self.logMut.Lock()
defer self.logMut.Unlock()
@@ -352,7 +352,7 @@ func (self *XEth) UninstallFilter(id int) bool {
func (self *XEth) NewFilterString(word string) int {
var id int
- filter := core.NewFilter(self.Backend())
+ filter := core.NewFilter(self.backend)
switch word {
case "pending":
@@ -403,9 +403,14 @@ func (self *XEth) Logs(id int) state.Logs {
return nil
}
-func (self *XEth) AllLogs(args *core.FilterOptions) state.Logs {
- filter := core.NewFilter(self.Backend())
- filter.SetOptions(args)
+func (self *XEth) AllLogs(earliest, latest int64, skip, max int, address []string, topics [][]string) state.Logs {
+ filter := core.NewFilter(self.backend)
+ filter.SetEarliestBlock(earliest)
+ filter.SetLatestBlock(latest)
+ filter.SetSkip(skip)
+ filter.SetMax(max)
+ filter.SetAddress(cAddress(address))
+ filter.SetTopics(cTopics(topics))
return filter.Find()
}
@@ -485,7 +490,7 @@ func (self *XEth) EachStorage(addr string) string {
object := self.State().SafeGet(addr)
it := object.Trie().Iterator()
for it.Next() {
- values = append(values, KeyVal{common.ToHex(it.Key), common.ToHex(it.Value)})
+ values = append(values, KeyVal{common.ToHex(object.Trie().GetKey(it.Key)), common.ToHex(it.Value)})
}
valuesJson, err := json.Marshal(values)
@@ -520,7 +525,7 @@ func (self *XEth) FromNumber(str string) string {
func (self *XEth) PushTx(encodedTx string) (string, error) {
tx := types.NewTransactionFromBytes(common.FromHex(encodedTx))
- err := self.eth.TxPool().Add(tx)
+ err := self.backend.TxPool().Add(tx)
if err != nil {
return "", err
}
@@ -533,7 +538,7 @@ func (self *XEth) PushTx(encodedTx string) (string, error) {
}
func (self *XEth) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
- statedb := self.State().State() //self.chainManager.TransState()
+ statedb := self.State().State() //self.eth.ChainManager().TransState()
msg := callmsg{
from: statedb.GetOrNewStateObject(common.HexToAddress(fromStr)),
to: common.HexToAddress(toStr),
@@ -550,8 +555,8 @@ func (self *XEth) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, dataStr st
msg.gasPrice = defaultGasPrice
}
- block := self.chainManager.CurrentBlock()
- vmenv := core.NewEnv(statedb, self.chainManager, msg, block)
+ block := self.CurrentBlock()
+ vmenv := core.NewEnv(statedb, self.backend.ChainManager(), msg, block)
res, err := vmenv.Call(msg.from, msg.to, msg.data, msg.gas, msg.gasPrice, msg.value)
return common.ToHex(res), err
@@ -612,14 +617,14 @@ func (self *XEth) Transact(fromStr, toStr, valueStr, gasStr, gasPriceStr, codeSt
tx = types.NewTransactionMessage(to, value.BigInt(), gas, price, data)
}
- state := self.chainManager.TxState()
+ state := self.backend.ChainManager().TxState()
nonce := state.NewNonce(from)
tx.SetNonce(nonce)
if err := self.sign(tx, from, false); err != nil {
return "", err
}
- if err := self.eth.TxPool().Add(tx); err != nil {
+ if err := self.backend.TxPool().Add(tx); err != nil {
return "", err
}
@@ -633,7 +638,7 @@ func (self *XEth) Transact(fromStr, toStr, valueStr, gasStr, gasPriceStr, codeSt
}
func (self *XEth) sign(tx *types.Transaction, from common.Address, didUnlock bool) error {
- sig, err := self.accountManager.Sign(accounts.Account{Address: from.Bytes()}, tx.Hash().Bytes())
+ sig, err := self.backend.AccountManager().Sign(accounts.Account{Address: from.Bytes()}, tx.Hash().Bytes())
if err == accounts.ErrLocked {
if didUnlock {
return fmt.Errorf("sender account still locked after successful unlock")
generated by cgit v1.2.3 (git 2.25.1) at 2025-03-09 14:05:10 +0800