plugeth/xeth/xeth.go

414 lines
11 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-01-28 17:25:50 +00:00
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common"
2015-01-28 17:25:50 +00:00
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/event"
2015-01-28 17:25:50 +00:00
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/p2p"
2015-02-26 10:14:54 +00:00
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/whisper"
2015-01-28 17:25:50 +00:00
)
2014-08-04 14:25:53 +00:00
2014-10-31 13:30:08 +00:00
var pipelogger = logger.NewLogger("XETH")
2015-01-28 17:25:50 +00:00
// to resolve the import cycle
type Backend interface {
BlockProcessor() *core.BlockProcessor
ChainManager() *core.ChainManager
2015-03-08 00:52:49 +00:00
AccountManager() *accounts.Manager
TxPool() *core.TxPool
PeerCount() int
2015-01-28 17:25:50 +00:00
IsListening() bool
Peers() []*p2p.Peer
2015-03-16 10:27:38 +00:00
BlockDb() common.Database
StateDb() common.Database
ExtraDb() common.Database
EventMux() *event.TypeMux
Whisper() *whisper.Whisper
IsMining() bool
StartMining() error
StopMining()
2015-03-13 00:20:46 +00:00
Version() string
2015-01-28 17:25:50 +00:00
}
// 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
}
2015-01-28 17:35:49 +00:00
type XEth struct {
2015-01-28 17:25:50 +00:00
eth Backend
blockProcessor *core.BlockProcessor
chainManager *core.ChainManager
2015-03-08 00:52:49 +00:00
accountManager *accounts.Manager
state *State
whisper *Whisper
2015-03-09 12:49:14 +00:00
frontend Frontend
2015-01-28 17:25:50 +00:00
}
// dummyFrontend is a non-interactive frontend that allows all
// transactions but cannot not unlock any keys.
type dummyFrontend struct{}
2015-03-09 12:49:14 +00:00
func (dummyFrontend) UnlockAccount([]byte) bool { return false }
func (dummyFrontend) ConfirmTransaction(*types.Transaction) bool { return true }
2015-03-09 12:49:14 +00:00
// 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 {
2015-01-28 17:35:49 +00:00
xeth := &XEth{
2015-01-28 17:25:50 +00:00
eth: eth,
blockProcessor: eth.BlockProcessor(),
chainManager: eth.ChainManager(),
accountManager: eth.AccountManager(),
whisper: NewWhisper(eth.Whisper()),
frontend: frontend,
2015-01-28 17:25:50 +00:00
}
2015-03-09 12:49:14 +00:00
if frontend == nil {
xeth.frontend = dummyFrontend{}
2015-03-09 12:49:14 +00:00
}
2015-02-26 10:14:54 +00:00
xeth.state = NewState(xeth, xeth.chainManager.TransState())
2015-01-28 17:25:50 +00:00
return xeth
}
2015-02-26 10:14:54 +00:00
func (self *XEth) Backend() Backend { return self.eth }
2015-03-11 16:00:20 +00:00
func (self *XEth) WithState(statedb *state.StateDB) *XEth {
2015-02-26 10:14:54 +00:00
xeth := &XEth{
eth: self.eth,
blockProcessor: self.blockProcessor,
chainManager: self.chainManager,
whisper: self.whisper,
}
xeth.state = NewState(xeth, statedb)
return xeth
}
func (self *XEth) State() *State { return self.state }
func (self *XEth) Whisper() *Whisper { return self.whisper }
2015-01-28 17:25:50 +00:00
2015-01-28 17:35:49 +00:00
func (self *XEth) BlockByHash(strHash string) *Block {
2015-03-16 10:27:38 +00:00
hash := common.FromHex(strHash)
2015-01-28 17:25:50 +00:00
block := self.chainManager.GetBlock(hash)
2015-01-28 17:35:49 +00:00
return NewBlock(block)
2015-01-28 17:25:50 +00:00
}
2015-03-10 17:52:45 +00:00
func (self *XEth) EthBlockByHash(strHash string) *types.Block {
2015-03-16 10:27:38 +00:00
hash := common.FromHex(strHash)
2015-03-10 17:52:45 +00:00
block := self.chainManager.GetBlock(hash)
return block
}
func (self *XEth) EthTransactionByHash(hash string) *types.Transaction {
2015-03-16 10:27:38 +00:00
data, _ := self.eth.ExtraDb().Get(common.FromHex(hash))
if len(data) != 0 {
return types.NewTransactionFromBytes(data)
}
return nil
}
2015-03-06 15:54:08 +00:00
func (self *XEth) BlockByNumber(num int64) *Block {
if num == -1 {
return NewBlock(self.chainManager.CurrentBlock())
}
return NewBlock(self.chainManager.GetBlockByNumber(uint64(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 {
if num == -1 {
return self.chainManager.CurrentBlock()
}
return self.chainManager.GetBlockByNumber(uint64(num))
}
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)
} else if f, ok := v.(float64); ok { // Don't ask ...
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?
accounts, _ := self.eth.AccountManager().Accounts()
accountAddresses := make([]string, len(accounts))
for i, ac := range accounts {
accountAddresses[i] = common.ToHex(ac.Address)
}
return accountAddresses
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) PeerCount() int {
2015-01-28 17:25:50 +00:00
return self.eth.PeerCount()
}
2015-01-28 17:35:49 +00:00
func (self *XEth) IsMining() bool {
return self.eth.IsMining()
2015-01-28 17:25:50 +00:00
}
2015-02-19 17:58:15 +00:00
func (self *XEth) SetMining(shouldmine bool) bool {
ismining := self.eth.IsMining()
2015-02-19 17:58:15 +00:00
if shouldmine && !ismining {
err := self.eth.StartMining()
return err == nil
2015-02-19 17:58:15 +00:00
}
if ismining && !shouldmine {
self.eth.StopMining()
2015-02-19 17:58:15 +00:00
}
return self.eth.IsMining()
2015-02-19 17:58:15 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) IsListening() bool {
2015-01-28 17:25:50 +00:00
return self.eth.IsListening()
}
2015-01-28 17:35:49 +00:00
func (self *XEth) Coinbase() string {
cb, _ := self.eth.AccountManager().Coinbase()
return common.ToHex(cb)
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-01-28 17:25:50 +00:00
storage := self.State().SafeGet(addr).StorageString(storageAddr)
return common.ToHex(storage.Bytes())
2015-01-28 17:25:50 +00:00
}
2015-01-28 17:35:49 +00:00
func (self *XEth) BalanceAt(addr string) string {
2015-01-28 17:25:50 +00:00
return self.State().SafeGet(addr).Balance().String()
}
2015-01-28 17:35:49 +00:00
func (self *XEth) TxCountAt(address string) int {
return int(self.State().SafeGet(address).Nonce())
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().SafeGet(address).Code())
2015-01-28 17:25:50 +00:00
}
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
}
2015-01-28 17:35:49 +00:00
func (self *XEth) SecretToAddress(key string) string {
2015-03-16 10:27:38 +00:00
pair, err := crypto.NewKeyPairFromSec(common.FromHex(key))
2015-01-28 17:25:50 +00:00
if err != nil {
return ""
}
return common.ToHex(pair.Address())
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() {
values = append(values, KeyVal{common.ToHex(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-01-28 17:25:50 +00:00
err := self.eth.TxPool().Add(tx)
if err != nil {
return "", err
}
if tx.To() == nil {
addr := core.AddressFromMessage(tx)
return common.ToHex(addr), nil
2015-01-28 17:25:50 +00:00
}
return common.ToHex(tx.Hash()), nil
2015-01-28 17:25:50 +00:00
}
var (
defaultGasPrice = big.NewInt(10000000000000)
defaultGas = big.NewInt(90000)
)
func (self *XEth) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
statedb := self.State().State() //self.chainManager.TransState()
msg := callmsg{
2015-03-16 10:27:38 +00:00
from: statedb.GetOrNewStateObject(common.FromHex(fromStr)),
to: common.FromHex(toStr),
gas: common.Big(gasStr),
gasPrice: common.Big(gasPriceStr),
value: common.Big(valueStr),
data: common.FromHex(dataStr),
}
if msg.gas.Cmp(big.NewInt(0)) == 0 {
msg.gas = defaultGas
}
if msg.gasPrice.Cmp(big.NewInt(0)) == 0 {
msg.gasPrice = defaultGasPrice
}
block := self.chainManager.CurrentBlock()
vmenv := core.NewEnv(statedb, self.chainManager, msg, block)
res, err := vmenv.Call(msg.from, msg.to, msg.data, msg.gas, msg.gasPrice, msg.value)
return common.ToHex(res), err
}
func (self *XEth) Transact(fromStr, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
var (
from []byte
to []byte
2015-03-16 10:27:38 +00:00
value = common.NewValue(valueStr)
gas = common.NewValue(gasStr)
price = common.NewValue(gasPriceStr)
data []byte
contractCreation bool
)
2015-03-16 10:27:38 +00:00
from = common.FromHex(fromStr)
data = common.FromHex(codeStr)
to = common.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.TxState()
nonce := state.NewNonce(from) //state.GetNonce(from)
tx.SetNonce(nonce)
if err := self.sign(tx, from, false); err != nil {
return "", err
}
if err := self.eth.TxPool().Add(tx); err != nil {
return "", err
}
//state.IncrementNonce(from)
if contractCreation {
addr := core.AddressFromMessage(tx)
pipelogger.Infof("Contract addr %x\n", addr)
}
if types.IsContractAddr(to) {
return common.ToHex(core.AddressFromMessage(tx)), nil
}
return common.ToHex(tx.Hash()), nil
}
func (self *XEth) sign(tx *types.Transaction, from []byte, didUnlock bool) error {
sig, err := self.accountManager.Sign(accounts.Account{Address: from}, tx.Hash())
if err == accounts.ErrLocked {
if didUnlock {
return fmt.Errorf("sender account still locked after successful unlock")
}
if !self.frontend.UnlockAccount(from) {
return fmt.Errorf("could not unlock sender account")
}
// retry signing, the account should now be unlocked.
return self.sign(tx, from, true)
} else if err != nil {
return err
}
tx.SetSignatureValues(sig)
return nil
}
// callmsg is the message type used for call transations.
type callmsg struct {
from *state.StateObject
to []byte
gas, gasPrice *big.Int
value *big.Int
data []byte
}
// accessor boilerplate to implement core.Message
func (m callmsg) From() []byte { return m.from.Address() }
func (m callmsg) Nonce() uint64 { return m.from.Nonce() }
func (m callmsg) To() []byte { 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 }