plugeth/xeth/xeth.go

182 lines
4.5 KiB
Go
Raw Normal View History

2014-10-31 13:30:08 +00:00
package xeth
/*
* eXtended ETHereum
*/
2014-08-04 14:25:53 +00:00
import (
2014-12-04 09:28:02 +00:00
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types"
2014-10-31 11:37:43 +00:00
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethutil"
2014-10-31 11:56:05 +00:00
"github.com/ethereum/go-ethereum/logger"
2014-10-31 13:43:14 +00:00
"github.com/ethereum/go-ethereum/state"
2014-08-04 14:25:53 +00:00
)
2014-10-31 13:30:08 +00:00
var pipelogger = logger.NewLogger("XETH")
2014-08-04 14:25:53 +00:00
2014-08-05 09:10:24 +00:00
type VmVars struct {
2014-12-04 10:40:20 +00:00
State *state.StateDB
2014-08-05 09:10:24 +00:00
}
2014-10-31 13:30:08 +00:00
type XEth struct {
2015-01-04 23:18:44 +00:00
obj core.EthManager
blockProcessor *core.BlockProcessor
chainManager *core.ChainManager
world *World
2014-08-05 09:10:24 +00:00
Vm VmVars
2014-08-04 14:25:53 +00:00
}
2014-12-04 09:28:02 +00:00
func New(obj core.EthManager) *XEth {
2014-10-31 13:30:08 +00:00
pipe := &XEth{
2015-01-04 23:18:44 +00:00
obj: obj,
blockProcessor: obj.BlockProcessor(),
chainManager: obj.ChainManager(),
2014-08-04 14:25:53 +00:00
}
pipe.world = NewWorld(pipe)
return pipe
}
/*
* State / Account accessors
*/
2014-10-31 13:30:08 +00:00
func (self *XEth) Balance(addr []byte) *ethutil.Value {
2014-08-04 14:25:53 +00:00
return ethutil.NewValue(self.World().safeGet(addr).Balance)
}
2014-10-31 13:30:08 +00:00
func (self *XEth) Nonce(addr []byte) uint64 {
2014-08-04 14:25:53 +00:00
return self.World().safeGet(addr).Nonce
}
func (self *XEth) Block(hash []byte) *types.Block {
2014-12-10 18:59:12 +00:00
return self.chainManager.GetBlock(hash)
2014-08-04 14:25:53 +00:00
}
2014-10-31 13:30:08 +00:00
func (self *XEth) Storage(addr, storageAddr []byte) *ethutil.Value {
2014-08-04 14:25:53 +00:00
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
2014-10-31 13:30:08 +00:00
func (self *XEth) ToAddress(priv []byte) []byte {
2014-10-31 11:37:43 +00:00
pair, err := crypto.NewKeyPairFromSec(priv)
2014-08-04 14:25:53 +00:00
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 (
2015-01-07 12:17:48 +00:00
initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address(), self.obj.Db())
2014-12-18 12:17:24 +00:00
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())
2014-08-04 14:34:55 +00:00
}
/*
* Transactional methods
*/
2014-12-03 13:05:19 +00:00
func (self *XEth) TransactString(key *crypto.KeyPair, rec string, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) {
2014-08-04 14:25:53 +00:00
// 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)
}
2014-12-03 13:05:19 +00:00
func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) {
2014-08-04 14:25:53 +00:00
var hash []byte
var contractCreation bool
2014-12-03 13:05:19 +00:00
if types.IsContractAddr(to) {
2014-08-04 14:25:53 +00:00
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
}
2014-08-04 14:25:53 +00:00
}
var tx *types.Transaction
2014-08-04 14:25:53 +00:00
if contractCreation {
2014-12-03 13:05:19 +00:00
tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), data)
2014-08-04 14:25:53 +00:00
} else {
2014-12-03 13:05:19 +00:00
tx = types.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data)
2014-08-04 14:25:53 +00:00
}
2014-12-10 18:59:12 +00:00
state := self.chainManager.TransState()
nonce := state.GetNonce(key.Address())
2014-08-04 14:25:53 +00:00
tx.SetNonce(nonce)
2014-08-04 14:25:53 +00:00
tx.Sign(key.PrivateKey)
// Do some pre processing for our "pre" events and hooks
2014-12-10 18:59:12 +00:00
block := self.chainManager.NewBlock(key.Address())
2015-01-02 21:18:23 +00:00
coinbase := state.GetOrNewStateObject(key.Address())
coinbase.SetGasPool(block.GasLimit())
2015-01-04 23:18:44 +00:00
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)
2014-08-04 14:25:53 +00:00
if contractCreation {
addr := core.AddressFromMessage(tx)
2014-10-31 11:56:05 +00:00
pipelogger.Infof("Contract addr %x\n", addr)
2014-08-04 14:25:53 +00:00
}
return tx, nil
2014-08-04 14:25:53 +00:00
}
2014-08-17 10:42:02 +00:00
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)
2014-10-31 11:56:05 +00:00
pipelogger.Infof("Contract addr %x\n", addr)
2014-10-02 15:03:15 +00:00
return addr, nil
}
return tx.Hash(), nil
}
2014-10-31 13:30:08 +00:00
func (self *XEth) CompileMutan(code string) ([]byte, error) {
2014-08-17 10:42:02 +00:00
data, err := ethutil.Compile(code, false)
if err != nil {
return nil, err
}
return data, nil
}