plugeth/xeth/xeth.go

1002 lines
25 KiB
Go
Raw Normal View History

// eXtended ETHereum
2014-10-31 13:30:08 +00:00
package xeth
2015-01-28 17:25:50 +00:00
import (
"bytes"
"encoding/json"
"fmt"
"math/big"
2015-03-20 02:58:07 +00:00
"sync"
"time"
2015-01-28 17:25:50 +00:00
"github.com/ethereum/go-ethereum/accounts"
2015-03-18 12:00:01 +00:00
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/compiler"
2015-01-28 17:25:50 +00:00
"github.com/ethereum/go-ethereum/core"
2015-03-23 17:06:05 +00:00
"github.com/ethereum/go-ethereum/core/state"
2015-01-28 17:25:50 +00:00
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/eth"
2015-03-20 02:58:07 +00:00
"github.com/ethereum/go-ethereum/event/filter"
2015-01-28 17:25:50 +00:00
"github.com/ethereum/go-ethereum/logger"
2015-04-09 09:49:14 +00:00
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/miner"
2015-04-01 10:14:35 +00:00
"github.com/ethereum/go-ethereum/rlp"
2015-01-28 17:25:50 +00:00
)
2014-08-04 14:25:53 +00:00
2015-03-20 02:58:07 +00:00
var (
filterTickerTime = 5 * time.Minute
2015-03-20 04:23:48 +00:00
defaultGasPrice = big.NewInt(10000000000000) //150000000000
defaultGas = big.NewInt(90000) //500000
dappStorePre = []byte("dapp-")
2015-03-20 02:58:07 +00:00
)
2015-01-28 17:25:50 +00:00
// byte will be inferred
const (
UnknownFilterTy = iota
BlockFilterTy
TransactionFilterTy
LogFilterTy
)
2015-05-26 12:17:43 +00:00
func DefaultGas() *big.Int { return new(big.Int).Set(defaultGas) }
func (self *XEth) DefaultGasPrice() *big.Int {
2015-06-12 11:57:30 +00:00
if self.gpo == nil {
self.gpo = eth.NewGasPriceOracle(self.backend)
}
2015-05-26 12:17:43 +00:00
return self.gpo.SuggestPrice()
}
2015-04-02 11:55:35 +00:00
2015-01-28 17:35:49 +00:00
type XEth struct {
2015-03-24 16:45:31 +00:00
backend *eth.Ethereum
frontend Frontend
2015-03-24 15:08:18 +00:00
state *State
whisper *Whisper
2015-03-09 12:49:14 +00:00
2015-03-20 02:58:07 +00:00
quit chan struct{}
filterManager *filter.FilterManager
2015-03-09 12:49:14 +00:00
logMu sync.RWMutex
logQueue map[int]*logQueue
blockMu sync.RWMutex
blockQueue map[int]*hashQueue
transactionMu sync.RWMutex
transactionQueue map[int]*hashQueue
2015-03-20 02:58:07 +00:00
messagesMu sync.RWMutex
messages map[int]*whisperFilter
2015-03-20 13:12:07 +00:00
// regmut sync.Mutex
// register map[string][]*interface{} // TODO improve return type
2015-03-23 08:35:42 +00:00
2015-03-23 10:21:41 +00:00
agent *miner.RemoteAgent
2015-05-26 12:17:43 +00:00
gpo *eth.GasPriceOracle
2015-01-28 17:25:50 +00:00
}
2015-03-09 12:49:14 +00:00
func NewTest(eth *eth.Ethereum, frontend Frontend) *XEth {
return &XEth{
backend: eth,
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.
2015-05-26 12:17:43 +00:00
func New(ethereum *eth.Ethereum, frontend Frontend) *XEth {
2015-01-28 17:35:49 +00:00
xeth := &XEth{
2015-05-26 12:17:43 +00:00
backend: ethereum,
frontend: frontend,
quit: make(chan struct{}),
2015-05-26 12:17:43 +00:00
filterManager: filter.NewFilterManager(ethereum.EventMux()),
logQueue: make(map[int]*logQueue),
blockQueue: make(map[int]*hashQueue),
transactionQueue: make(map[int]*hashQueue),
messages: make(map[int]*whisperFilter),
agent: miner.NewRemoteAgent(),
2015-01-28 17:25:50 +00:00
}
2015-05-26 12:17:43 +00:00
if ethereum.Whisper() != nil {
xeth.whisper = NewWhisper(ethereum.Whisper())
}
2015-05-26 12:17:43 +00:00
ethereum.Miner().Register(xeth.agent)
2015-03-09 12:49:14 +00:00
if frontend == nil {
xeth.frontend = dummyFrontend{}
2015-03-09 12:49:14 +00:00
}
2015-03-24 15:08:18 +00:00
xeth.state = NewState(xeth, xeth.backend.ChainManager().TransState())
2015-03-24 16:45:31 +00:00
2015-03-20 02:58:07 +00:00
go xeth.start()
go xeth.filterManager.Start()
2015-01-28 17:25:50 +00:00
return xeth
}
2015-03-20 02:58:07 +00:00
func (self *XEth) start() {
timer := time.NewTicker(2 * time.Second)
done:
for {
select {
case <-timer.C:
self.logMu.Lock()
for id, filter := range self.logQueue {
if time.Since(filter.timeout) > filterTickerTime {
self.filterManager.UninstallFilter(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.UninstallFilter(id)
delete(self.blockQueue, id)
}
}
self.blockMu.Unlock()
self.transactionMu.Lock()
for id, filter := range self.transactionQueue {
2015-03-20 02:58:07 +00:00
if time.Since(filter.timeout) > filterTickerTime {
self.filterManager.UninstallFilter(id)
delete(self.transactionQueue, id)
2015-03-20 02:58:07 +00:00
}
}
self.transactionMu.Unlock()
2015-03-20 02:58:07 +00:00
self.messagesMu.Lock()
2015-03-20 02:58:07 +00:00
for id, filter := range self.messages {
if time.Since(filter.activity()) > filterTickerTime {
2015-03-20 02:58:07 +00:00
self.Whisper().Unwatch(id)
delete(self.messages, id)
}
}
self.messagesMu.Unlock()
2015-03-20 02:58:07 +00:00
case <-self.quit:
break done
}
}
}
func (self *XEth) stop() {
close(self.quit)
}
2015-03-27 15:36:01 +00:00
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))
2015-03-27 15:36:01 +00:00
for j, jv := range iv {
topics[i][j] = common.HexToHash(jv)
}
}
return topics
}
2015-03-23 10:21:41 +00:00
func (self *XEth) RemoteMining() *miner.RemoteAgent { return self.agent }
2015-03-23 08:35:42 +00:00
2015-03-20 03:28:45 +00:00
func (self *XEth) AtStateNum(num int64) *XEth {
var st *state.StateDB
2015-04-07 10:32:55 +00:00
switch num {
case -2:
st = self.backend.Miner().PendingState().Copy()
default:
if block := self.getBlockByHeight(num); block != nil {
st = state.New(block.Root(), self.backend.StateDb())
} else {
st = state.New(self.backend.ChainManager().GetBlockByNumber(0).Root(), self.backend.StateDb())
}
2015-03-20 03:28:45 +00:00
}
2015-03-24 16:58:16 +00:00
return self.WithState(st)
2015-03-20 03:28:45 +00:00
}
func (self *XEth) WithState(statedb *state.StateDB) *XEth {
2015-02-26 10:14:54 +00:00
xeth := &XEth{
backend: self.backend,
frontend: self.frontend,
2015-06-12 11:57:30 +00:00
gpo: self.gpo,
2015-02-26 10:14:54 +00:00
}
xeth.state = NewState(xeth, statedb)
return xeth
}
2015-03-24 16:45:31 +00:00
2015-02-26 10:14:54 +00:00
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() {
sub := self.backend.EventMux().Subscribe(core.ChainHeadEvent{})
var m, n *big.Int
var ok bool
out:
for {
select {
case event := <-sub.Chan():
ev, ok := event.(core.ChainHeadEvent)
if ok {
m = ev.Block.Number()
if n != nil && n.Cmp(m) < 0 {
wait <- n
n = nil
}
statedb := state.New(ev.Block.Root(), self.backend.StateDb())
self.state = NewState(self, statedb)
}
case n, ok = <-wait:
if !ok {
break out
}
}
}
sub.Unsubscribe()
}()
return
}
func (self *XEth) Whisper() *Whisper { return self.whisper }
2015-01-28 17:25:50 +00:00
2015-03-24 16:49:37 +00:00
func (self *XEth) getBlockByHeight(height int64) *types.Block {
var num uint64
2015-04-07 10:32:55 +00:00
switch height {
case -2:
return self.backend.Miner().PendingBlock()
case -1:
return self.CurrentBlock()
default:
if height < 0 {
return nil
}
2015-03-24 16:49:37 +00:00
num = uint64(height)
}
return self.backend.ChainManager().GetBlockByNumber(num)
}
2015-01-28 17:35:49 +00:00
func (self *XEth) BlockByHash(strHash string) *Block {
2015-03-18 12:00:01 +00:00
hash := common.HexToHash(strHash)
2015-03-24 15:08:18 +00:00
block := self.backend.ChainManager().GetBlock(hash)
2015-01-28 17:25:50 +00:00
2015-01-28 17:35:49 +00:00
return NewBlock(block)
2015-01-28 17:25:50 +00:00
}
2015-03-26 21:24:48 +00:00
func (self *XEth) EthBlockByHash(strHash string) *types.Block {
hash := common.HexToHash(strHash)
2015-03-24 15:08:18 +00:00
block := self.backend.ChainManager().GetBlock(hash)
2015-03-10 17:52:45 +00:00
return block
}
func (self *XEth) EthTransactionByHash(hash string) (tx *types.Transaction, blhash common.Hash, blnum *big.Int, txi uint64) {
2015-05-18 15:41:56 +00:00
// Due to increasing return params and need to determine if this is from transaction pool or
// some chain, this probably needs to be refactored for more expressiveness
2015-03-24 15:01:44 +00:00
data, _ := self.backend.ExtraDb().Get(common.FromHex(hash))
if len(data) != 0 {
tx = types.NewTransactionFromBytes(data)
} else { // check pending transactions
tx = self.backend.TxPool().GetTransaction(common.HexToHash(hash))
}
2015-04-01 10:14:35 +00:00
// meta
var txExtra struct {
BlockHash common.Hash
2015-04-02 14:28:42 +00:00
BlockIndex uint64
2015-04-01 10:14:35 +00:00
Index uint64
}
2015-04-01 10:14:35 +00:00
2015-05-14 16:57:29 +00:00
v, dberr := self.backend.ExtraDb().Get(append(common.FromHex(hash), 0x0001))
// TODO check specifically for ErrNotFound
if dberr != nil {
return
}
2015-04-01 10:14:35 +00:00
r := bytes.NewReader(v)
err := rlp.Decode(r, &txExtra)
if err == nil {
blhash = txExtra.BlockHash
2015-04-02 14:28:42 +00:00
blnum = big.NewInt(int64(txExtra.BlockIndex))
2015-04-01 10:14:35 +00:00
txi = txExtra.Index
2015-04-02 14:28:42 +00:00
} else {
2015-04-09 09:49:14 +00:00
glog.V(logger.Error).Infoln(err)
}
return
}
2015-03-06 15:54:08 +00:00
func (self *XEth) BlockByNumber(num int64) *Block {
2015-03-24 16:49:37 +00:00
return NewBlock(self.getBlockByHeight(num))
2015-01-28 17:25:50 +00:00
}
2015-03-10 17:52:45 +00:00
func (self *XEth) EthBlockByNumber(num int64) *types.Block {
2015-03-24 16:49:37 +00:00
return self.getBlockByHeight(num)
2015-03-10 17:52:45 +00:00
}
2015-03-24 15:33:37 +00:00
func (self *XEth) CurrentBlock() *types.Block {
return self.backend.ChainManager().CurrentBlock()
}
func (self *XEth) GetBlockReceipts(bhash common.Hash) types.Receipts {
2015-05-20 04:41:50 +00:00
return self.backend.BlockProcessor().GetBlockReceipts(bhash)
}
func (self *XEth) GetTxReceipt(txhash common.Hash) *types.Receipt {
return core.GetReceipt(self.backend.ExtraDb(), txhash)
2015-05-20 04:41:50 +00:00
}
func (self *XEth) GasLimit() *big.Int {
return self.backend.ChainManager().GasLimit()
}
2015-01-28 17:35:49 +00:00
func (self *XEth) Block(v interface{}) *Block {
2015-01-28 17:25:50 +00:00
if n, ok := v.(int32); ok {
2015-03-06 15:54:08 +00:00
return self.BlockByNumber(int64(n))
2015-01-28 17:25:50 +00:00
} else if str, ok := v.(string); ok {
return self.BlockByHash(str)
2015-05-18 15:41:56 +00:00
} else if f, ok := v.(float64); ok { // JSON numbers are represented as float64
2015-03-06 15:54:08 +00:00
return self.BlockByNumber(int64(f))
2015-01-28 17:25:50 +00:00
}
return nil
}
2015-01-28 17:35:49 +00:00
func (self *XEth) Accounts() []string {
// TODO: check err?
2015-03-24 15:01:44 +00:00
accounts, _ := self.backend.AccountManager().Accounts()
accountAddresses := make([]string, len(accounts))
for i, ac := range accounts {
2015-04-24 15:35:10 +00:00
accountAddresses[i] = ac.Address.Hex()
}
return accountAddresses
2015-01-28 17:25:50 +00:00
}
// accessor for solidity compiler.
// memoized if available, retried on-demand if not
func (self *XEth) Solc() (*compiler.Solidity, error) {
return self.backend.Solc()
}
// set in js console via admin interface or wrapper from cli flags
func (self *XEth) SetSolc(solcPath string) (*compiler.Solidity, error) {
self.backend.SetSolc(solcPath)
return self.Solc()
}
// store DApp value in extra database
2015-03-27 08:36:18 +00:00
func (self *XEth) DbPut(key, val []byte) bool {
self.backend.ExtraDb().Put(append(dappStorePre, key...), val)
2015-03-27 08:36:18 +00:00
return true
}
// retrieve DApp value from extra database
2015-03-27 08:36:18 +00:00
func (self *XEth) DbGet(key []byte) ([]byte, error) {
val, err := self.backend.ExtraDb().Get(append(dappStorePre, key...))
2015-03-27 08:36:18 +00:00
return val, err
}
2015-01-28 17:35:49 +00:00
func (self *XEth) PeerCount() int {
2015-03-24 15:01:44 +00:00
return self.backend.PeerCount()
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) IsMining() bool {
2015-03-24 15:01:44 +00:00
return self.backend.IsMining()
2015-01-28 17:25:50 +00:00
}
2015-04-12 12:17:07 +00:00
func (self *XEth) HashRate() int64 {
return self.backend.Miner().HashRate()
2015-04-12 12:17:07 +00:00
}
2015-03-25 11:09:55 +00:00
func (self *XEth) EthVersion() string {
return fmt.Sprintf("%d", self.backend.EthVersion())
2015-03-25 11:09:55 +00:00
}
2015-03-24 15:33:37 +00:00
func (self *XEth) NetworkVersion() string {
return fmt.Sprintf("%d", self.backend.NetVersion())
2015-03-25 11:09:55 +00:00
}
func (self *XEth) WhisperVersion() string {
return fmt.Sprintf("%d", self.backend.ShhVersion())
2015-03-24 15:33:37 +00:00
}
func (self *XEth) ClientVersion() string {
2015-03-25 11:09:55 +00:00
return self.backend.ClientVersion()
2015-03-24 15:33:37 +00:00
}
func (self *XEth) SetMining(shouldmine bool, threads int) bool {
2015-03-24 15:01:44 +00:00
ismining := self.backend.IsMining()
2015-02-19 17:58:15 +00:00
if shouldmine && !ismining {
err := self.backend.StartMining(threads)
return err == nil
2015-02-19 17:58:15 +00:00
}
if ismining && !shouldmine {
2015-03-24 15:01:44 +00:00
self.backend.StopMining()
2015-02-19 17:58:15 +00:00
}
2015-03-24 15:01:44 +00:00
return self.backend.IsMining()
2015-02-19 17:58:15 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) IsListening() bool {
2015-03-24 15:01:44 +00:00
return self.backend.IsListening()
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) Coinbase() string {
eb, err := self.backend.Etherbase()
if err != nil {
return "0x0"
}
return eb.Hex()
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) NumberToHuman(balance string) string {
2015-03-16 10:27:38 +00:00
b := common.Big(balance)
2015-01-28 17:25:50 +00:00
2015-03-16 10:27:38 +00:00
return common.CurrencyToString(b)
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) StorageAt(addr, storageAddr string) string {
2015-06-17 09:44:40 +00:00
return self.State().state.GetState(common.HexToAddress(addr), common.HexToHash(storageAddr)).Hex()
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) BalanceAt(addr string) string {
2015-04-02 10:57:04 +00:00
return common.ToHex(self.State().state.GetBalance(common.HexToAddress(addr)).Bytes())
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) TxCountAt(address string) int {
return int(self.State().state.GetNonce(common.HexToAddress(address)))
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) CodeAt(address string) string {
return common.ToHex(self.State().state.GetCode(common.HexToAddress(address)))
2015-01-28 17:25:50 +00:00
}
2015-04-02 11:38:12 +00:00
func (self *XEth) CodeAtBytes(address string) []byte {
return self.State().SafeGet(address).Code()
}
2015-01-28 17:35:49 +00:00
func (self *XEth) IsContract(address string) bool {
return len(self.State().SafeGet(address).Code()) > 0
2015-01-28 17:25:50 +00:00
}
func (self *XEth) UninstallFilter(id int) bool {
defer self.filterManager.UninstallFilter(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 {
2015-03-20 02:58:07 +00:00
var id int
2015-03-24 15:33:37 +00:00
filter := core.NewFilter(self.backend)
2015-03-27 15:36:01 +00:00
filter.SetEarliestBlock(earliest)
filter.SetLatestBlock(latest)
filter.SetSkip(skip)
filter.SetMax(max)
filter.SetAddress(cAddress(address))
filter.SetTopics(cTopics(topics))
2015-03-20 02:58:07 +00:00
filter.LogsCallback = func(logs state.Logs) {
self.logMu.Lock()
defer self.logMu.Unlock()
2015-03-20 02:58:07 +00:00
self.logQueue[id].add(logs...)
2015-03-20 02:58:07 +00:00
}
id = self.filterManager.InstallFilter(filter)
self.logQueue[id] = &logQueue{timeout: time.Now()}
2015-03-20 02:58:07 +00:00
return id
}
func (self *XEth) NewTransactionFilter() int {
var id int
filter := core.NewFilter(self.backend)
filter.TransactionCallback = func(tx *types.Transaction) {
self.transactionMu.Lock()
defer self.transactionMu.Unlock()
2015-03-20 02:58:07 +00:00
self.transactionQueue[id].add(tx.Hash())
}
id = self.filterManager.InstallFilter(filter)
self.transactionQueue[id] = &hashQueue{timeout: time.Now()}
return id
2015-03-20 02:58:07 +00:00
}
func (self *XEth) NewBlockFilter() int {
2015-03-20 02:58:07 +00:00
var id int
2015-03-24 15:33:37 +00:00
filter := core.NewFilter(self.backend)
filter.BlockCallback = func(block *types.Block, logs state.Logs) {
self.blockMu.Lock()
defer self.blockMu.Unlock()
2015-03-20 02:58:07 +00:00
self.blockQueue[id].add(block.Hash())
}
id = self.filterManager.InstallFilter(filter)
self.blockQueue[id] = &hashQueue{timeout: time.Now()}
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
2015-03-20 02:58:07 +00:00
}
return UnknownFilterTy
}
2015-03-20 02:58:07 +00:00
func (self *XEth) LogFilterChanged(id int) state.Logs {
self.logMu.Lock()
defer self.logMu.Unlock()
if self.logQueue[id] != nil {
return self.logQueue[id].get()
}
return nil
2015-03-20 02:58:07 +00:00
}
func (self *XEth) BlockFilterChanged(id int) []common.Hash {
self.blockMu.Lock()
defer self.blockMu.Unlock()
2015-03-20 02:58:07 +00:00
if self.blockQueue[id] != nil {
return self.blockQueue[id].get()
2015-03-20 02:58:07 +00:00
}
return nil
}
func (self *XEth) TransactionFilterChanged(id int) []common.Hash {
self.blockMu.Lock()
defer self.blockMu.Unlock()
2015-03-20 02:58:07 +00:00
if self.transactionQueue[id] != nil {
return self.transactionQueue[id].get()
}
2015-03-20 02:58:07 +00:00
return nil
}
func (self *XEth) Logs(id int) state.Logs {
self.logMu.Lock()
defer self.logMu.Unlock()
2015-03-20 02:58:07 +00:00
filter := self.filterManager.GetFilter(id)
if filter != nil {
return filter.Find()
}
return nil
}
2015-03-27 15:36:01 +00:00
func (self *XEth) AllLogs(earliest, latest int64, skip, max int, address []string, topics [][]string) state.Logs {
2015-03-24 15:33:37 +00:00
filter := core.NewFilter(self.backend)
2015-03-27 15:36:01 +00:00
filter.SetEarliestBlock(earliest)
filter.SetLatestBlock(latest)
filter.SetSkip(skip)
filter.SetMax(max)
filter.SetAddress(cAddress(address))
filter.SetTopics(cTopics(topics))
2015-03-20 02:58:07 +00:00
return filter.Find()
}
2015-04-22 15:35:50 +00:00
// 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 {
2015-04-22 15:35:50 +00:00
// Pre-define the id to be filled later
2015-03-20 02:58:07 +00:00
var id int
2015-04-22 15:35:50 +00:00
// 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()
p.messages[id].insert(msg)
2015-03-20 02:58:07 +00:00
}
2015-04-22 15:35:50 +00:00
// Initialize the core whisper filter and wrap into xeth
id = p.Whisper().Watch(to, from, topics, callback)
2015-04-22 15:35:50 +00:00
p.messagesMu.Lock()
p.messages[id] = newWhisperFilter(id, p.Whisper())
p.messagesMu.Unlock()
2015-04-22 15:35:50 +00:00
2015-03-20 02:58:07 +00:00
return id
}
2015-04-22 15:35:50 +00:00
// UninstallWhisperFilter disables and removes an existing filter.
2015-03-20 02:58:07 +00:00
func (p *XEth) UninstallWhisperFilter(id int) bool {
p.messagesMu.Lock()
defer p.messagesMu.Unlock()
2015-04-22 15:35:50 +00:00
2015-03-20 02:58:07 +00:00
if _, ok := p.messages[id]; ok {
delete(p.messages, id)
return true
}
return false
}
2015-04-22 15:35:50 +00:00
// 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()
2015-03-20 02:58:07 +00:00
if self.messages[id] != nil {
2015-04-22 15:35:50 +00:00
return self.messages[id].messages()
2015-03-20 02:58:07 +00:00
}
return nil
}
2015-04-22 15:35:50 +00:00
// 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()
2015-03-20 02:58:07 +00:00
if self.messages[id] != nil {
2015-04-22 15:35:50 +00:00
return self.messages[id].retrieve()
}
2015-03-20 02:58:07 +00:00
return nil
}
2015-03-20 13:12:07 +00:00
// 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
// }
2015-01-28 17:25:50 +00:00
type KeyVal struct {
Key string `json:"key"`
Value string `json:"value"`
}
2015-01-28 17:35:49 +00:00
func (self *XEth) EachStorage(addr string) string {
2015-01-28 17:25:50 +00:00
var values []KeyVal
object := self.State().SafeGet(addr)
it := object.Trie().Iterator()
for it.Next() {
2015-03-25 23:42:35 +00:00
values = append(values, KeyVal{common.ToHex(object.Trie().GetKey(it.Key)), common.ToHex(it.Value)})
2015-01-28 17:25:50 +00:00
}
valuesJson, err := json.Marshal(values)
if err != nil {
return ""
}
return string(valuesJson)
}
2015-01-28 17:35:49 +00:00
func (self *XEth) ToAscii(str string) string {
2015-03-16 10:27:38 +00:00
padded := common.RightPadBytes([]byte(str), 32)
2015-01-28 17:25:50 +00:00
return "0x" + common.ToHex(padded)
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) FromAscii(str string) string {
2015-03-16 10:27:38 +00:00
if common.IsHex(str) {
2015-01-28 17:25:50 +00:00
str = str[2:]
}
2015-03-16 10:27:38 +00:00
return string(bytes.Trim(common.FromHex(str), "\x00"))
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) FromNumber(str string) string {
2015-03-16 10:27:38 +00:00
if common.IsHex(str) {
2015-01-28 17:25:50 +00:00
str = str[2:]
}
2015-03-16 10:27:38 +00:00
return common.BigD(common.FromHex(str)).String()
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) PushTx(encodedTx string) (string, error) {
2015-03-16 10:27:38 +00:00
tx := types.NewTransactionFromBytes(common.FromHex(encodedTx))
2015-03-24 15:01:44 +00:00
err := self.backend.TxPool().Add(tx)
2015-01-28 17:25:50 +00:00
if err != nil {
return "", err
}
if tx.To() == nil {
from, err := tx.From()
if err != nil {
return "", err
}
addr := crypto.CreateAddress(from, tx.Nonce())
2015-06-16 16:47:34 +00:00
glog.V(logger.Info).Infof("Tx(%x) created: %x\n", tx.Hash(), addr)
2015-03-18 12:00:01 +00:00
return addr.Hex(), nil
2015-06-16 16:47:34 +00:00
} else {
glog.V(logger.Info).Infof("Tx(%x) to: %x\n", tx.Hash(), tx.To())
2015-01-28 17:25:50 +00:00
}
2015-06-16 16:47:34 +00:00
2015-03-18 12:00:01 +00:00
return tx.Hash().Hex(), nil
2015-01-28 17:25:50 +00:00
}
func (self *XEth) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, string, error) {
2015-05-18 15:41:56 +00:00
statedb := self.State().State().Copy()
var from *state.StateObject
if len(fromStr) == 0 {
accounts, err := self.backend.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)
from.SetGasLimit(self.backend.ChainManager().GasLimit())
msg := callmsg{
from: from,
2015-03-18 12:00:01 +00:00
to: common.HexToAddress(toStr),
2015-03-16 10:27:38 +00:00
gas: common.Big(gasStr),
gasPrice: common.Big(gasPriceStr),
value: common.Big(valueStr),
data: common.FromHex(dataStr),
}
2015-04-01 10:33:12 +00:00
if msg.gas.Cmp(big.NewInt(0)) == 0 {
2015-04-02 12:00:49 +00:00
msg.gas = DefaultGas()
}
if msg.gasPrice.Cmp(big.NewInt(0)) == 0 {
2015-05-26 12:17:43 +00:00
msg.gasPrice = self.DefaultGasPrice()
}
2015-06-16 10:41:50 +00:00
header := self.CurrentBlock().Header()
vmenv := core.NewEnv(statedb, self.backend.ChainManager(), msg, header)
res, gas, err := core.ApplyMessage(vmenv, msg, from)
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.backend.AccountManager().Sign(accounts.Account{Address: from}, hash.Bytes())
2015-05-08 14:17:19 +00:00
if err == accounts.ErrLocked {
if didUnlock {
return nil, fmt.Errorf("signer account still locked after successful unlock")
2015-05-08 14:17:19 +00:00
}
if !self.frontend.UnlockAccount(from.Bytes()) {
return nil, fmt.Errorf("could not unlock signer account")
2015-05-08 14:17:19 +00:00
}
// retry signing, the account should now be unlocked.
return self.doSign(from, hash, true)
2015-05-08 14:17:19 +00:00
} 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
2015-05-08 14:17:19 +00:00
}
return common.ToHex(sig), nil
2015-05-08 14:17:19 +00:00
}
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
}
var (
2015-03-18 12:00:01 +00:00
from = common.HexToAddress(fromStr)
to = common.HexToAddress(toStr)
2015-05-21 09:36:05 +00:00
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 {
2015-05-26 12:17:43 +00:00
price = self.DefaultGasPrice()
} else {
price = common.Big(gasPriceStr)
}
data = common.FromHex(codeStr)
if len(toStr) == 0 {
contractCreation = true
}
2015-05-18 15:41:56 +00:00
// 2015-05-18 Is this still needed?
2015-03-20 04:24:23 +00:00
// 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)
}
*/
2015-03-20 06:13:29 +00:00
// TODO: align default values to have the same type, e.g. not depend on
// common.Value conversions later on
var nonce uint64
if len(nonceStr) != 0 {
nonce = common.Big(nonceStr).Uint64()
} else {
state := self.backend.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
}
if err = self.backend.TxPool().Add(signed); err != nil {
return "", err
}
if contractCreation {
addr := crypto.CreateAddress(from, nonce)
2015-04-21 20:03:32 +00:00
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 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
2015-03-18 12:00:01 +00:00
to common.Address
gas, gasPrice *big.Int
value *big.Int
data []byte
}
// accessor boilerplate to implement core.Message
2015-03-18 12:00:01 +00:00
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 }
2015-03-20 02:58:07 +00:00
type logQueue struct {
2015-03-20 02:58:07 +00:00
logs state.Logs
timeout time.Time
id int
}
func (l *logQueue) add(logs ...*state.Log) {
2015-03-20 02:58:07 +00:00
l.logs = append(l.logs, logs...)
}
func (l *logQueue) get() state.Logs {
2015-03-20 02:58:07 +00:00
l.timeout = time.Now()
tmp := l.logs
l.logs = nil
return tmp
}
type hashQueue struct {
hashes []common.Hash
timeout time.Time
id int
}
func (l *hashQueue) add(hashes ...common.Hash) {
l.hashes = append(l.hashes, hashes...)
}
func (l *hashQueue) get() []common.Hash {
l.timeout = time.Now()
tmp := l.hashes
l.hashes = nil
return tmp
}