aboutsummaryrefslogtreecommitdiffstats
path: root/xeth/xeth.go
diff options
context:
space:
mode:
Diffstat (limited to 'xeth/xeth.go')
-rw-r--r--xeth/xeth.go1137
1 files changed, 0 insertions, 1137 deletions
diff --git a/xeth/xeth.go b/xeth/xeth.go
deleted file mode 100644
index 5a5399a3e..000000000
--- a/xeth/xeth.go
+++ /dev/null
@@ -1,1137 +0,0 @@
-// Copyright 2014 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Package xeth is the interface to all Ethereum functionality.
-package xeth
-
-import (
- "bytes"
- "encoding/json"
- "errors"
- "fmt"
- "math/big"
- "regexp"
- "sync"
- "time"
-
- "github.com/ethereum/go-ethereum/accounts"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/compiler"
- "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/core/vm"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/eth"
- "github.com/ethereum/go-ethereum/eth/filters"
- "github.com/ethereum/go-ethereum/logger"
- "github.com/ethereum/go-ethereum/logger/glog"
- "github.com/ethereum/go-ethereum/miner"
- "github.com/ethereum/go-ethereum/node"
- "github.com/ethereum/go-ethereum/rlp"
- "github.com/ethereum/go-ethereum/whisper"
-)
-
-var (
- filterTickerTime = 5 * time.Minute
- defaultGasPrice = big.NewInt(10000000000000) //150000000000
- defaultGas = big.NewInt(90000) //500000
- dappStorePre = []byte("dapp-")
- addrReg = regexp.MustCompile(`^(0x)?[a-fA-F0-9]{40}$`)
-)
-
-// byte will be inferred
-const (
- UnknownFilterTy = iota
- BlockFilterTy
- TransactionFilterTy
- LogFilterTy
-)
-
-type XEth struct {
- quit chan struct{}
-
- logMu sync.RWMutex
- logQueue map[int]*logQueue
-
- blockMu sync.RWMutex
- blockQueue map[int]*hashQueue
-
- transactionMu sync.RWMutex
- transactionQueue map[int]*hashQueue
-
- messagesMu sync.RWMutex
- messages map[int]*whisperFilter
-
- transactMu sync.Mutex
-
- // read-only fields
- backend *node.Node
- frontend Frontend
- agent *miner.RemoteAgent
- gpo *eth.GasPriceOracle
- state *State
- whisper *Whisper
- filterManager *filters.FilterSystem
-}
-
-func NewTest(stack *node.Node, frontend Frontend) *XEth {
- return &XEth{backend: stack, frontend: frontend}
-}
-
-// 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(stack *node.Node, frontend Frontend) *XEth {
- var (
- ethereum *eth.Ethereum
- whisper *whisper.Whisper
- )
- stack.Service(&ethereum)
- stack.Service(&whisper)
-
- xeth := &XEth{
- backend: stack,
- frontend: frontend,
- quit: make(chan struct{}),
- filterManager: filters.NewFilterSystem(stack.EventMux()),
- logQueue: make(map[int]*logQueue),
- blockQueue: make(map[int]*hashQueue),
- transactionQueue: make(map[int]*hashQueue),
- messages: make(map[int]*whisperFilter),
- agent: miner.NewRemoteAgent(),
- gpo: eth.NewGasPriceOracle(ethereum),
- }
- if whisper != nil {
- xeth.whisper = NewWhisper(whisper)
- }
- ethereum.Miner().Register(xeth.agent)
- if frontend == nil {
- xeth.frontend = dummyFrontend{}
- }
- state, _ := ethereum.BlockChain().State()
- xeth.state = NewState(xeth, state)
- go xeth.start()
- return xeth
-}
-
-func (self *XEth) EthereumService() *eth.Ethereum {
- var ethereum *eth.Ethereum
- if err := self.backend.Service(&ethereum); err != nil {
- return nil
- }
- return ethereum
-}
-
-func (self *XEth) WhisperService() *whisper.Whisper {
- var whisper *whisper.Whisper
- if err := self.backend.Service(&whisper); err != nil {
- return nil
- }
- return whisper
-}
-
-func (self *XEth) start() {
- timer := time.NewTicker(2 * time.Second)
- defer timer.Stop()
-done:
- for {
- select {
- case <-timer.C:
- self.logMu.Lock()
- for id, filter := range self.logQueue {
- if time.Since(filter.timeout) > filterTickerTime {
- self.filterManager.Remove(id)
- delete(self.logQueue, id)
- }
- }
- self.logMu.Unlock()
-
- self.blockMu.Lock()
- for id, filter := range self.blockQueue {
- if time.Since(filter.timeout) > filterTickerTime {
- self.filterManager.Remove(id)
- delete(self.blockQueue, id)
- }
- }
- self.blockMu.Unlock()
-
- self.transactionMu.Lock()
- for id, filter := range self.transactionQueue {
- if time.Since(filter.timeout) > filterTickerTime {
- self.filterManager.Remove(id)
- delete(self.transactionQueue, id)
- }
- }
- self.transactionMu.Unlock()
-
- self.messagesMu.Lock()
- for id, filter := range self.messages {
- if time.Since(filter.activity()) > filterTickerTime {
- self.Whisper().Unwatch(id)
- delete(self.messages, id)
- }
- }
- self.messagesMu.Unlock()
- case <-self.quit:
- break done
- }
- }
-}
-
-// Stop releases any resources associated with self.
-// It may not be called more than once.
-func (self *XEth) Stop() {
- close(self.quit)
- self.filterManager.Stop()
- self.EthereumService().Miner().Unregister(self.agent)
-}
-
-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 {
- topics[i] = make([]common.Hash, len(iv))
- for j, jv := range iv {
- topics[i][j] = common.HexToHash(jv)
- }
- }
- return topics
-}
-
-func DefaultGas() *big.Int { return new(big.Int).Set(defaultGas) }
-
-func (self *XEth) DefaultGasPrice() *big.Int {
- return self.gpo.SuggestPrice()
-}
-
-func (self *XEth) RemoteMining() *miner.RemoteAgent { return self.agent }
-
-func (self *XEth) AtStateNum(num int64) *XEth {
- var st *state.StateDB
- var err error
- switch num {
- case -2:
- st = self.EthereumService().Miner().PendingState().Copy()
- default:
- if block := self.getBlockByHeight(num); block != nil {
- st, err = state.New(block.Root(), self.EthereumService().ChainDb())
- if err != nil {
- return nil
- }
- } else {
- st, err = state.New(self.EthereumService().BlockChain().GetBlockByNumber(0).Root(), self.EthereumService().ChainDb())
- if err != nil {
- return nil
- }
- }
- }
- return self.WithState(st)
-}
-
-func (self *XEth) WithState(statedb *state.StateDB) *XEth {
- xeth := &XEth{
- backend: self.backend,
- frontend: self.frontend,
- gpo: self.gpo,
- }
-
- xeth.state = NewState(xeth, statedb)
- return xeth
-}
-
-func (self *XEth) State() *State { return self.state }
-
-// subscribes to new head block events and
-// waits until blockchain height is greater n at any time
-// given the current head, waits for the next chain event
-// sets the state to the current head
-// loop is async and quit by closing the channel
-// used in tests and JS console debug module to control advancing private chain manually
-// Note: this is not threadsafe, only called in JS single process and tests
-func (self *XEth) UpdateState() (wait chan *big.Int) {
- wait = make(chan *big.Int)
- go func() {
- eventSub := self.backend.EventMux().Subscribe(core.ChainHeadEvent{})
- defer eventSub.Unsubscribe()
-
- var m, n *big.Int
- var ok bool
-
- eventCh := eventSub.Chan()
- for {
- select {
- case event, ok := <-eventCh:
- if !ok {
- // Event subscription closed, set the channel to nil to stop spinning
- eventCh = nil
- continue
- }
- // A real event arrived, process if new head block assignment
- if event, ok := event.Data.(core.ChainHeadEvent); ok {
- m = event.Block.Number()
- if n != nil && n.Cmp(m) < 0 {
- wait <- n
- n = nil
- }
- statedb, err := state.New(event.Block.Root(), self.EthereumService().ChainDb())
- if err != nil {
- glog.V(logger.Error).Infoln("Could not create new state: %v", err)
- return
- }
- self.state = NewState(self, statedb)
- }
- case n, ok = <-wait:
- if !ok {
- return
- }
- }
- }
- }()
- return
-}
-
-func (self *XEth) Whisper() *Whisper { return self.whisper }
-
-func (self *XEth) getBlockByHeight(height int64) *types.Block {
- var num uint64
-
- switch height {
- case -2:
- return self.EthereumService().Miner().PendingBlock()
- case -1:
- return self.CurrentBlock()
- default:
- if height < 0 {
- return nil
- }
-
- num = uint64(height)
- }
-
- return self.EthereumService().BlockChain().GetBlockByNumber(num)
-}
-
-func (self *XEth) BlockByHash(strHash string) *Block {
- hash := common.HexToHash(strHash)
- block := self.EthereumService().BlockChain().GetBlock(hash)
-
- return NewBlock(block)
-}
-
-func (self *XEth) EthBlockByHash(strHash string) *types.Block {
- hash := common.HexToHash(strHash)
- block := self.EthereumService().BlockChain().GetBlock(hash)
-
- return block
-}
-
-func (self *XEth) EthTransactionByHash(hash string) (*types.Transaction, common.Hash, uint64, uint64) {
- ethereum := self.EthereumService()
- if tx, hash, number, index := core.GetTransaction(ethereum.ChainDb(), common.HexToHash(hash)); tx != nil {
- return tx, hash, number, index
- }
- return ethereum.TxPool().GetTransaction(common.HexToHash(hash)), common.Hash{}, 0, 0
-}
-
-func (self *XEth) BlockByNumber(num int64) *Block {
- return NewBlock(self.getBlockByHeight(num))
-}
-
-func (self *XEth) EthBlockByNumber(num int64) *types.Block {
- return self.getBlockByHeight(num)
-}
-
-func (self *XEth) Td(hash common.Hash) *big.Int {
- return self.EthereumService().BlockChain().GetTd(hash)
-}
-
-func (self *XEth) CurrentBlock() *types.Block {
- return self.EthereumService().BlockChain().CurrentBlock()
-}
-
-func (self *XEth) GetBlockReceipts(bhash common.Hash) types.Receipts {
- return core.GetBlockReceipts(self.EthereumService().ChainDb(), bhash)
-}
-
-func (self *XEth) GetTxReceipt(txhash common.Hash) *types.Receipt {
- return core.GetReceipt(self.EthereumService().ChainDb(), txhash)
-}
-
-func (self *XEth) GasLimit() *big.Int {
- return self.EthereumService().BlockChain().GasLimit()
-}
-
-func (self *XEth) Block(v interface{}) *Block {
- if n, ok := v.(int32); ok {
- return self.BlockByNumber(int64(n))
- } else if str, ok := v.(string); ok {
- return self.BlockByHash(str)
- } else if f, ok := v.(float64); ok { // JSON numbers are represented as float64
- return self.BlockByNumber(int64(f))
- }
-
- return nil
-}
-
-func (self *XEth) Accounts() []string {
- // TODO: check err?
- accounts, _ := self.EthereumService().AccountManager().Accounts()
- accountAddresses := make([]string, len(accounts))
- for i, ac := range accounts {
- accountAddresses[i] = ac.Address.Hex()
- }
- return accountAddresses
-}
-
-// accessor for solidity compiler.
-// memoized if available, retried on-demand if not
-func (self *XEth) Solc() (*compiler.Solidity, error) {
- return self.EthereumService().Solc()
-}
-
-// set in js console via admin interface or wrapper from cli flags
-func (self *XEth) SetSolc(solcPath string) (*compiler.Solidity, error) {
- self.EthereumService().SetSolc(solcPath)
- return self.Solc()
-}
-
-// store DApp value in extra database
-func (self *XEth) DbPut(key, val []byte) bool {
- self.EthereumService().DappDb().Put(append(dappStorePre, key...), val)
- return true
-}
-
-// retrieve DApp value from extra database
-func (self *XEth) DbGet(key []byte) ([]byte, error) {
- val, err := self.EthereumService().DappDb().Get(append(dappStorePre, key...))
- return val, err
-}
-
-func (self *XEth) PeerCount() int {
- return self.backend.Server().PeerCount()
-}
-
-func (self *XEth) IsMining() bool {
- return self.EthereumService().IsMining()
-}
-
-func (self *XEth) HashRate() int64 {
- return self.EthereumService().Miner().HashRate()
-}
-
-func (self *XEth) EthVersion() string {
- return fmt.Sprintf("%d", self.EthereumService().EthVersion())
-}
-
-func (self *XEth) NetworkVersion() string {
- return fmt.Sprintf("%d", self.EthereumService().NetVersion())
-}
-
-func (self *XEth) WhisperVersion() string {
- return fmt.Sprintf("%d", self.WhisperService().Version())
-}
-
-func (self *XEth) ClientVersion() string {
- return self.backend.Server().Name
-}
-
-func (self *XEth) SetMining(shouldmine bool, threads int) bool {
- ismining := self.EthereumService().IsMining()
- if shouldmine && !ismining {
- err := self.EthereumService().StartMining(threads, "")
- return err == nil
- }
- if ismining && !shouldmine {
- self.EthereumService().StopMining()
- }
- return self.EthereumService().IsMining()
-}
-
-func (self *XEth) IsListening() bool {
- return true
-}
-
-func (self *XEth) Coinbase() string {
- eb, err := self.EthereumService().Etherbase()
- if err != nil {
- return "0x0"
- }
- return eb.Hex()
-}
-
-func (self *XEth) NumberToHuman(balance string) string {
- b := common.Big(balance)
-
- return common.CurrencyToString(b)
-}
-
-func (self *XEth) StorageAt(addr, storageAddr string) string {
- return self.State().state.GetState(common.HexToAddress(addr), common.HexToHash(storageAddr)).Hex()
-}
-
-func (self *XEth) BalanceAt(addr string) string {
- return common.ToHex(self.State().state.GetBalance(common.HexToAddress(addr)).Bytes())
-}
-
-func (self *XEth) TxCountAt(address string) int {
- return int(self.State().state.GetNonce(common.HexToAddress(address)))
-}
-
-func (self *XEth) CodeAt(address string) string {
- return common.ToHex(self.State().state.GetCode(common.HexToAddress(address)))
-}
-
-func (self *XEth) CodeAtBytes(address string) []byte {
- return self.State().SafeGet(address).Code()
-}
-
-func (self *XEth) IsContract(address string) bool {
- return len(self.State().SafeGet(address).Code()) > 0
-}
-
-func (self *XEth) UninstallFilter(id int) bool {
- defer self.filterManager.Remove(id)
-
- if _, ok := self.logQueue[id]; ok {
- self.logMu.Lock()
- defer self.logMu.Unlock()
- delete(self.logQueue, id)
- return true
- }
- if _, ok := self.blockQueue[id]; ok {
- self.blockMu.Lock()
- defer self.blockMu.Unlock()
- delete(self.blockQueue, id)
- return true
- }
- if _, ok := self.transactionQueue[id]; ok {
- self.transactionMu.Lock()
- defer self.transactionMu.Unlock()
- delete(self.transactionQueue, id)
- return true
- }
-
- return false
-}
-
-func (self *XEth) NewLogFilter(earliest, latest int64, skip, max int, address []string, topics [][]string) int {
- self.logMu.Lock()
- defer self.logMu.Unlock()
-
- filter := filters.New(self.EthereumService().ChainDb())
- id := self.filterManager.Add(filter)
- self.logQueue[id] = &logQueue{timeout: time.Now()}
-
- filter.SetBeginBlock(earliest)
- filter.SetEndBlock(latest)
- filter.SetAddresses(cAddress(address))
- filter.SetTopics(cTopics(topics))
- filter.LogsCallback = func(logs vm.Logs) {
- self.logMu.Lock()
- defer self.logMu.Unlock()
-
- if queue := self.logQueue[id]; queue != nil {
- queue.add(logs...)
- }
- }
-
- return id
-}
-
-func (self *XEth) NewTransactionFilter() int {
- self.transactionMu.Lock()
- defer self.transactionMu.Unlock()
-
- filter := filters.New(self.EthereumService().ChainDb())
- id := self.filterManager.Add(filter)
- self.transactionQueue[id] = &hashQueue{timeout: time.Now()}
-
- filter.TransactionCallback = func(tx *types.Transaction) {
- self.transactionMu.Lock()
- defer self.transactionMu.Unlock()
-
- if queue := self.transactionQueue[id]; queue != nil {
- queue.add(tx.Hash())
- }
- }
- return id
-}
-
-func (self *XEth) NewBlockFilter() int {
- self.blockMu.Lock()
- defer self.blockMu.Unlock()
-
- filter := filters.New(self.EthereumService().ChainDb())
- id := self.filterManager.Add(filter)
- self.blockQueue[id] = &hashQueue{timeout: time.Now()}
-
- filter.BlockCallback = func(block *types.Block, logs vm.Logs) {
- self.blockMu.Lock()
- defer self.blockMu.Unlock()
-
- if queue := self.blockQueue[id]; queue != nil {
- queue.add(block.Hash())
- }
- }
- return id
-}
-
-func (self *XEth) GetFilterType(id int) byte {
- if _, ok := self.blockQueue[id]; ok {
- return BlockFilterTy
- } else if _, ok := self.transactionQueue[id]; ok {
- return TransactionFilterTy
- } else if _, ok := self.logQueue[id]; ok {
- return LogFilterTy
- }
-
- return UnknownFilterTy
-}
-
-func (self *XEth) LogFilterChanged(id int) vm.Logs {
- self.logMu.Lock()
- defer self.logMu.Unlock()
-
- if self.logQueue[id] != nil {
- return self.logQueue[id].get()
- }
- return nil
-}
-
-func (self *XEth) BlockFilterChanged(id int) []common.Hash {
- self.blockMu.Lock()
- defer self.blockMu.Unlock()
-
- if self.blockQueue[id] != nil {
- return self.blockQueue[id].get()
- }
- return nil
-}
-
-func (self *XEth) TransactionFilterChanged(id int) []common.Hash {
- self.blockMu.Lock()
- defer self.blockMu.Unlock()
-
- if self.transactionQueue[id] != nil {
- return self.transactionQueue[id].get()
- }
- return nil
-}
-
-func (self *XEth) Logs(id int) vm.Logs {
- filter := self.filterManager.Get(id)
- if filter != nil {
- return filter.Find()
- }
-
- return nil
-}
-
-func (self *XEth) AllLogs(earliest, latest int64, skip, max int, address []string, topics [][]string) vm.Logs {
- filter := filters.New(self.EthereumService().ChainDb())
- filter.SetBeginBlock(earliest)
- filter.SetEndBlock(latest)
- filter.SetAddresses(cAddress(address))
- filter.SetTopics(cTopics(topics))
-
- return filter.Find()
-}
-
-// NewWhisperFilter creates and registers a new message filter to watch for
-// inbound whisper messages. All parameters at this point are assumed to be
-// HEX encoded.
-func (p *XEth) NewWhisperFilter(to, from string, topics [][]string) int {
- // Pre-define the id to be filled later
- var id int
-
- // Callback to delegate core whisper messages to this xeth filter
- callback := func(msg WhisperMessage) {
- p.messagesMu.RLock() // Only read lock to the filter pool
- defer p.messagesMu.RUnlock()
- if p.messages[id] != nil {
- p.messages[id].insert(msg)
- }
- }
- // Initialize the core whisper filter and wrap into xeth
- id = p.Whisper().Watch(to, from, topics, callback)
-
- p.messagesMu.Lock()
- p.messages[id] = newWhisperFilter(id, p.Whisper())
- p.messagesMu.Unlock()
-
- return id
-}
-
-// UninstallWhisperFilter disables and removes an existing filter.
-func (p *XEth) UninstallWhisperFilter(id int) bool {
- p.messagesMu.Lock()
- defer p.messagesMu.Unlock()
-
- if _, ok := p.messages[id]; ok {
- delete(p.messages, id)
- return true
- }
- return false
-}
-
-// WhisperMessages retrieves all the known messages that match a specific filter.
-func (self *XEth) WhisperMessages(id int) []WhisperMessage {
- self.messagesMu.RLock()
- defer self.messagesMu.RUnlock()
-
- if self.messages[id] != nil {
- return self.messages[id].messages()
- }
- return nil
-}
-
-// WhisperMessagesChanged retrieves all the new messages matched by a filter
-// since the last retrieval
-func (self *XEth) WhisperMessagesChanged(id int) []WhisperMessage {
- self.messagesMu.RLock()
- defer self.messagesMu.RUnlock()
-
- if self.messages[id] != nil {
- return self.messages[id].retrieve()
- }
- return nil
-}
-
-// func (self *XEth) Register(args string) bool {
-// self.regmut.Lock()
-// defer self.regmut.Unlock()
-
-// if _, ok := self.register[args]; ok {
-// self.register[args] = nil // register with empty
-// }
-// return true
-// }
-
-// func (self *XEth) Unregister(args string) bool {
-// self.regmut.Lock()
-// defer self.regmut.Unlock()
-
-// if _, ok := self.register[args]; ok {
-// delete(self.register, args)
-// return true
-// }
-
-// return false
-// }
-
-// // TODO improve return type
-// func (self *XEth) PullWatchTx(args string) []*interface{} {
-// self.regmut.Lock()
-// defer self.regmut.Unlock()
-
-// txs := self.register[args]
-// self.register[args] = nil
-
-// return txs
-// }
-
-type KeyVal struct {
- Key string `json:"key"`
- Value string `json:"value"`
-}
-
-func (self *XEth) EachStorage(addr string) string {
- var values []KeyVal
- object := self.State().SafeGet(addr)
- it := object.Trie().Iterator()
- for it.Next() {
- values = append(values, KeyVal{common.ToHex(object.Trie().GetKey(it.Key)), common.ToHex(it.Value)})
- }
-
- valuesJson, err := json.Marshal(values)
- if err != nil {
- return ""
- }
-
- return string(valuesJson)
-}
-
-func (self *XEth) ToAscii(str string) string {
- padded := common.RightPadBytes([]byte(str), 32)
-
- return "0x" + common.ToHex(padded)
-}
-
-func (self *XEth) FromAscii(str string) string {
- if common.IsHex(str) {
- str = str[2:]
- }
-
- return string(bytes.Trim(common.FromHex(str), "\x00"))
-}
-
-func (self *XEth) FromNumber(str string) string {
- if common.IsHex(str) {
- str = str[2:]
- }
-
- return common.BigD(common.FromHex(str)).String()
-}
-
-func (self *XEth) PushTx(encodedTx string) (string, error) {
- tx := new(types.Transaction)
- err := rlp.DecodeBytes(common.FromHex(encodedTx), tx)
- if err != nil {
- glog.V(logger.Error).Infoln(err)
- return "", err
- }
-
- err = self.EthereumService().TxPool().Add(tx)
- if err != nil {
- return "", err
- }
-
- if tx.To() == nil {
- from, err := tx.From()
- if err != nil {
- return "", err
- }
-
- addr := crypto.CreateAddress(from, tx.Nonce())
- glog.V(logger.Info).Infof("Tx(%x) created: %x\n", tx.Hash(), addr)
- } else {
- glog.V(logger.Info).Infof("Tx(%x) to: %x\n", tx.Hash(), tx.To())
- }
-
- return tx.Hash().Hex(), nil
-}
-
-func (self *XEth) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, string, error) {
- statedb := self.State().State().Copy()
- var from *state.StateObject
- if len(fromStr) == 0 {
- accounts, err := self.EthereumService().AccountManager().Accounts()
- if err != nil || len(accounts) == 0 {
- from = statedb.GetOrNewStateObject(common.Address{})
- } else {
- from = statedb.GetOrNewStateObject(accounts[0].Address)
- }
- } else {
- from = statedb.GetOrNewStateObject(common.HexToAddress(fromStr))
- }
-
- from.SetBalance(common.MaxBig)
-
- msg := callmsg{
- from: from,
- gas: common.Big(gasStr),
- gasPrice: common.Big(gasPriceStr),
- value: common.Big(valueStr),
- data: common.FromHex(dataStr),
- }
- if len(toStr) > 0 {
- addr := common.HexToAddress(toStr)
- msg.to = &addr
- }
-
- if msg.gas.Cmp(big.NewInt(0)) == 0 {
- msg.gas = big.NewInt(50000000)
- }
-
- if msg.gasPrice.Cmp(big.NewInt(0)) == 0 {
- msg.gasPrice = self.DefaultGasPrice()
- }
-
- header := self.CurrentBlock().Header()
- vmenv := core.NewEnv(statedb, self.EthereumService().BlockChain(), msg, header)
- gp := new(core.GasPool).AddGas(common.MaxBig)
- res, gas, err := core.ApplyMessage(vmenv, msg, gp)
- return common.ToHex(res), gas.String(), err
-}
-
-func (self *XEth) ConfirmTransaction(tx string) bool {
- return self.frontend.ConfirmTransaction(tx)
-}
-
-func (self *XEth) doSign(from common.Address, hash common.Hash, didUnlock bool) ([]byte, error) {
- sig, err := self.EthereumService().AccountManager().Sign(accounts.Account{Address: from}, hash.Bytes())
- if err == accounts.ErrLocked {
- if didUnlock {
- return nil, fmt.Errorf("signer account still locked after successful unlock")
- }
- if !self.frontend.UnlockAccount(from.Bytes()) {
- return nil, fmt.Errorf("could not unlock signer account")
- }
- // retry signing, the account should now be unlocked.
- return self.doSign(from, hash, true)
- } else if err != nil {
- return nil, err
- }
- return sig, nil
-}
-
-func (self *XEth) Sign(fromStr, hashStr string, didUnlock bool) (string, error) {
- var (
- from = common.HexToAddress(fromStr)
- hash = common.HexToHash(hashStr)
- )
- sig, err := self.doSign(from, hash, didUnlock)
- if err != nil {
- return "", err
- }
- return common.ToHex(sig), nil
-}
-
-func isAddress(addr string) bool {
- return addrReg.MatchString(addr)
-}
-
-func (self *XEth) Frontend() Frontend {
- return self.frontend
-}
-
-func (self *XEth) SignTransaction(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (*types.Transaction, error) {
- if len(toStr) > 0 && toStr != "0x" && !isAddress(toStr) {
- return nil, errors.New("Invalid address")
- }
-
- var (
- from = common.HexToAddress(fromStr)
- to = common.HexToAddress(toStr)
- value = common.Big(valueStr)
- gas *big.Int
- price *big.Int
- data []byte
- contractCreation bool
- )
-
- if len(gasStr) == 0 {
- gas = DefaultGas()
- } else {
- gas = common.Big(gasStr)
- }
-
- if len(gasPriceStr) == 0 {
- price = self.DefaultGasPrice()
- } else {
- price = common.Big(gasPriceStr)
- }
-
- data = common.FromHex(codeStr)
- if len(toStr) == 0 {
- contractCreation = true
- }
-
- var nonce uint64
- if len(nonceStr) != 0 {
- nonce = common.Big(nonceStr).Uint64()
- } else {
- state := self.EthereumService().TxPool().State()
- nonce = state.GetNonce(from)
- }
- var tx *types.Transaction
- if contractCreation {
- tx = types.NewContractCreation(nonce, value, gas, price, data)
- } else {
- tx = types.NewTransaction(nonce, to, value, gas, price, data)
- }
-
- signed, err := self.sign(tx, from, false)
- if err != nil {
- return nil, err
- }
-
- return signed, nil
-}
-
-func (self *XEth) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
-
- // this minimalistic recoding is enough (works for natspec.js)
- var jsontx = fmt.Sprintf(`{"params":[{"to":"%s","data": "%s"}]}`, toStr, codeStr)
- if !self.ConfirmTransaction(jsontx) {
- err := fmt.Errorf("Transaction not confirmed")
- return "", err
- }
-
- if len(toStr) > 0 && toStr != "0x" && !isAddress(toStr) {
- return "", errors.New("Invalid address")
- }
-
- var (
- from = common.HexToAddress(fromStr)
- to = common.HexToAddress(toStr)
- value = common.Big(valueStr)
- gas *big.Int
- price *big.Int
- data []byte
- contractCreation bool
- )
-
- if len(gasStr) == 0 {
- gas = DefaultGas()
- } else {
- gas = common.Big(gasStr)
- }
-
- if len(gasPriceStr) == 0 {
- price = self.DefaultGasPrice()
- } else {
- price = common.Big(gasPriceStr)
- }
-
- data = common.FromHex(codeStr)
- if len(toStr) == 0 {
- contractCreation = true
- }
-
- // 2015-05-18 Is this still needed?
- // TODO if no_private_key then
- //if _, exists := p.register[args.From]; exists {
- // p.register[args.From] = append(p.register[args.From], args)
- //} else {
- /*
- account := accounts.Get(common.FromHex(args.From))
- if account != nil {
- if account.Unlocked() {
- if !unlockAccount(account) {
- return
- }
- }
-
- result, _ := account.Transact(common.FromHex(args.To), common.FromHex(args.Value), common.FromHex(args.Gas), common.FromHex(args.GasPrice), common.FromHex(args.Data))
- if len(result) > 0 {
- *reply = common.ToHex(result)
- }
- } else if _, exists := p.register[args.From]; exists {
- p.register[ags.From] = append(p.register[args.From], args)
- }
- */
-
- self.transactMu.Lock()
- defer self.transactMu.Unlock()
-
- var nonce uint64
- if len(nonceStr) != 0 {
- nonce = common.Big(nonceStr).Uint64()
- } else {
- state := self.EthereumService().TxPool().State()
- nonce = state.GetNonce(from)
- }
- var tx *types.Transaction
- if contractCreation {
- tx = types.NewContractCreation(nonce, value, gas, price, data)
- } else {
- tx = types.NewTransaction(nonce, to, value, gas, price, data)
- }
-
- signed, err := self.sign(tx, from, false)
- if err != nil {
- return "", err
- }
- self.EthereumService().TxPool().SetLocal(signed)
- if err = self.EthereumService().TxPool().Add(signed); err != nil {
- return "", err
- }
-
- if contractCreation {
- addr := crypto.CreateAddress(from, nonce)
- glog.V(logger.Info).Infof("Tx(%s) created: %s\n", signed.Hash().Hex(), addr.Hex())
- } else {
- glog.V(logger.Info).Infof("Tx(%s) to: %s\n", signed.Hash().Hex(), tx.To().Hex())
- }
-
- return signed.Hash().Hex(), nil
-}
-
-func (self *XEth) sign(tx *types.Transaction, from common.Address, didUnlock bool) (*types.Transaction, error) {
- hash := tx.SigHash()
- sig, err := self.doSign(from, hash, didUnlock)
- if err != nil {
- return tx, err
- }
- return tx.WithSignature(sig)
-}
-
-// callmsg is the message type used for call transations.
-type callmsg struct {
- from *state.StateObject
- to *common.Address
- gas, gasPrice *big.Int
- value *big.Int
- data []byte
-}
-
-// accessor boilerplate to implement core.Message
-func (m callmsg) From() (common.Address, error) { return m.from.Address(), nil }
-func (m callmsg) Nonce() uint64 { return m.from.Nonce() }
-func (m callmsg) To() *common.Address { return m.to }
-func (m callmsg) GasPrice() *big.Int { return m.gasPrice }
-func (m callmsg) Gas() *big.Int { return m.gas }
-func (m callmsg) Value() *big.Int { return m.value }
-func (m callmsg) Data() []byte { return m.data }
-
-type logQueue struct {
- mu sync.Mutex
-
- logs vm.Logs
- timeout time.Time
- id int
-}
-
-func (l *logQueue) add(logs ...*vm.Log) {
- l.mu.Lock()
- defer l.mu.Unlock()
-
- l.logs = append(l.logs, logs...)
-}
-
-func (l *logQueue) get() vm.Logs {
- l.mu.Lock()
- defer l.mu.Unlock()
-
- l.timeout = time.Now()
- tmp := l.logs
- l.logs = nil
- return tmp
-}
-
-type hashQueue struct {
- mu sync.Mutex
-
- hashes []common.Hash
- timeout time.Time
- id int
-}
-
-func (l *hashQueue) add(hashes ...common.Hash) {
- l.mu.Lock()
- defer l.mu.Unlock()
-
- l.hashes = append(l.hashes, hashes...)
-}
-
-func (l *hashQueue) get() []common.Hash {
- l.mu.Lock()
- defer l.mu.Unlock()
-
- l.timeout = time.Now()
- tmp := l.hashes
- l.hashes = nil
- return tmp
-}
generated by cgit (git 2.34.1) at 2024-09-27 19:27:07 +0800