interesting
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

ethstate => state

This commit is contained in:
obscuren 2014-10-31 14:43:14 +01:00
parent 0ed1a8b50a
commit af8f5f0b69
36 changed files with 167 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
chain/block.go
View File

@ -8,9 +8,9 @@ import (
"time"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethtrie"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type BlockInfo struct {
@ -77,7 +77,7 @@ type Block struct {
Coinbase []byte
// Block Trie state
//state *ethutil.Trie
state *ethstate.State
state *state.State
// Difficulty for the current block
Difficulty *big.Int
// Creation time
@ -137,7 +137,7 @@ func CreateBlock(root interface{},
}
block.SetUncles([]*Block{})
block.state = ethstate.New(ethtrie.New(ethutil.Config.Db, root))
block.state = state.New(ethtrie.New(ethutil.Config.Db, root))
return block
}
@ -152,7 +152,7 @@ func (block *Block) HashNoNonce() []byte {
return crypto.Sha3(ethutil.Encode(block.miningHeader()))
}
func (block *Block) State() *ethstate.State {
func (block *Block) State() *state.State {
return block.state
}
@ -294,7 +294,7 @@ func (self *Block) setHeader(header *ethutil.Value) {
self.PrevHash = header.Get(0).Bytes()
self.UncleSha = header.Get(1).Bytes()
self.Coinbase = header.Get(2).Bytes()
self.state = ethstate.New(ethtrie.New(ethutil.Config.Db, header.Get(3).Val))
self.state = state.New(ethtrie.New(ethutil.Config.Db, header.Get(3).Val))
self.TxSha = header.Get(4).Bytes()
self.ReceiptSha = header.Get(5).Bytes()
self.LogsBloom = header.Get(6).Bytes()

4
chain/bloom9.go
View File

@ -3,8 +3,8 @@ package chain
import (
"math/big"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
func CreateBloom(block *Block) []byte {
@ -17,7 +17,7 @@ func CreateBloom(block *Block) []byte {
return bin.Bytes()
}
func LogsBloom(logs ethstate.Logs) *big.Int {
func LogsBloom(logs state.Logs) *big.Int {
bin := new(big.Int)
for _, log := range logs {
data := [][]byte{log.Address}

12
chain/filter.go
View File

@ -4,7 +4,7 @@ import (
"bytes"
"math"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/state"
)
type AccountChange struct {
@ -23,7 +23,7 @@ type Filter struct {
Altered []AccountChange
BlockCallback func(*Block)
MessageCallback func(ethstate.Messages)
MessageCallback func(state.Messages)
}
// Create a new filter which uses a bloom filter on blocks to figure out whether a particular block
@ -72,7 +72,7 @@ func (self *Filter) SetSkip(skip int) {
}
// Run filters messages with the current parameters set
func (self *Filter) Find() []*ethstate.Message {
func (self *Filter) Find() []*state.Message {
var earliestBlockNo uint64 = uint64(self.earliest)
if self.earliest == -1 {
earliestBlockNo = self.eth.ChainManager().CurrentBlock.Number.Uint64()
@ -83,7 +83,7 @@ func (self *Filter) Find() []*ethstate.Message {
}
var (
messages []*ethstate.Message
messages []*state.Message
block = self.eth.ChainManager().GetBlockByNumber(latestBlockNo)
quit bool
)
@ -128,8 +128,8 @@ func includes(addresses [][]byte, a []byte) (found bool) {
return
}
func (self *Filter) FilterMessages(msgs []*ethstate.Message) []*ethstate.Message {
var messages []*ethstate.Message
func (self *Filter) FilterMessages(msgs []*state.Message) []*state.Message {
var messages []*state.Message
// Filter the messages for interesting stuff
for _, message := range msgs {

24
chain/state_manager.go
View File

@ -10,11 +10,11 @@ import (
"time"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/ethwire"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/state"
)
var statelogger = logger.NewLogger("BLOCK")
@ -61,10 +61,10 @@ type StateManager struct {
// Transiently state. The trans state isn't ever saved, validated and
// it could be used for setting account nonces without effecting
// the main states.
transState *ethstate.State
transState *state.State
// Mining state. The mining state is used purely and solely by the mining
// operation.
miningState *ethstate.State
miningState *state.State
// The last attempted block is mainly used for debugging purposes
// This does not have to be a valid block and will be set during
@ -112,19 +112,19 @@ func (self *StateManager) updateThread() {
}
}
func (sm *StateManager) CurrentState() *ethstate.State {
func (sm *StateManager) CurrentState() *state.State {
return sm.eth.ChainManager().CurrentBlock.State()
}
func (sm *StateManager) TransState() *ethstate.State {
func (sm *StateManager) TransState() *state.State {
return sm.transState
}
func (sm *StateManager) MiningState() *ethstate.State {
func (sm *StateManager) MiningState() *state.State {
return sm.miningState
}
func (sm *StateManager) NewMiningState() *ethstate.State {
func (sm *StateManager) NewMiningState() *state.State {
sm.miningState = sm.eth.ChainManager().CurrentBlock.State().Copy()
return sm.miningState
@ -134,7 +134,7 @@ func (sm *StateManager) ChainManager() *ChainManager {
return sm.bc
}
func (self *StateManager) ProcessTransactions(coinbase *ethstate.StateObject, state *ethstate.State, block, parent *Block, txs Transactions) (Receipts, Transactions, Transactions, Transactions, error) {
func (self *StateManager) ProcessTransactions(coinbase *state.StateObject, state *state.State, block, parent *Block, txs Transactions) (Receipts, Transactions, Transactions, Transactions, error) {
var (
receipts Receipts
handled, unhandled Transactions
@ -296,7 +296,7 @@ func (sm *StateManager) Process(block *Block) (err error) {
return nil
}
func (sm *StateManager) ApplyDiff(state *ethstate.State, parent, block *Block) (receipts Receipts, err error) {
func (sm *StateManager) ApplyDiff(state *state.State, parent, block *Block) (receipts Receipts, err error) {
coinbase := state.GetOrNewStateObject(block.Coinbase)
coinbase.SetGasPool(block.CalcGasLimit(parent))
@ -372,7 +372,7 @@ func (sm *StateManager) ValidateBlock(block *Block) error {
return nil
}
func (sm *StateManager) AccumelateRewards(state *ethstate.State, block, parent *Block) error {
func (sm *StateManager) AccumelateRewards(state *state.State, block, parent *Block) error {
reward := new(big.Int).Set(BlockReward)
knownUncles := ethutil.Set(parent.Uncles)
@ -416,7 +416,7 @@ func (sm *StateManager) AccumelateRewards(state *ethstate.State, block, parent *
}
// Manifest will handle both creating notifications and generating bloom bin data
func (sm *StateManager) createBloomFilter(state *ethstate.State) *BloomFilter {
func (sm *StateManager) createBloomFilter(state *state.State) *BloomFilter {
bloomf := NewBloomFilter(nil)
for _, msg := range state.Manifest().Messages {
@ -429,7 +429,7 @@ func (sm *StateManager) createBloomFilter(state *ethstate.State) *BloomFilter {
return bloomf
}
func (sm *StateManager) GetMessages(block *Block) (messages []*ethstate.Message, err error) {
func (sm *StateManager) GetMessages(block *Block) (messages []*state.Message, err error) {
if !sm.bc.HasBlock(block.PrevHash) {
return nil, ParentError(block.PrevHash)
}

26
chain/state_transition.go
View File

@ -4,8 +4,8 @@ import (
"fmt"
"math/big"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/vm"
)
@ -31,17 +31,17 @@ type StateTransition struct {
gas, gasPrice *big.Int
value *big.Int
data []byte
state *ethstate.State
state *state.State
block *Block
cb, rec, sen *ethstate.StateObject
cb, rec, sen *state.StateObject
}
func NewStateTransition(coinbase *ethstate.StateObject, tx *Transaction, state *ethstate.State, block *Block) *StateTransition {
func NewStateTransition(coinbase *state.StateObject, tx *Transaction, state *state.State, block *Block) *StateTransition {
return &StateTransition{coinbase.Address(), tx.Recipient, tx, new(big.Int), new(big.Int).Set(tx.GasPrice), tx.Value, tx.Data, state, block, coinbase, nil, nil}
}
func (self *StateTransition) Coinbase() *ethstate.StateObject {
func (self *StateTransition) Coinbase() *state.StateObject {
if self.cb != nil {
return self.cb
}
@ -49,7 +49,7 @@ func (self *StateTransition) Coinbase() *ethstate.StateObject {
self.cb = self.state.GetOrNewStateObject(self.coinbase)
return self.cb
}
func (self *StateTransition) Sender() *ethstate.StateObject {
func (self *StateTransition) Sender() *state.StateObject {
if self.sen != nil {
return self.sen
}
@ -58,7 +58,7 @@ func (self *StateTransition) Sender() *ethstate.StateObject {
return self.sen
}
func (self *StateTransition) Receiver() *ethstate.StateObject {
func (self *StateTransition) Receiver() *state.StateObject {
if self.tx != nil && self.tx.CreatesContract() {
return nil
}
@ -143,7 +143,7 @@ func (self *StateTransition) TransitionState() (err error) {
var (
tx = self.tx
sender = self.Sender()
receiver *ethstate.StateObject
receiver *state.StateObject
)
defer self.RefundGas()
@ -167,7 +167,7 @@ func (self *StateTransition) TransitionState() (err error) {
return fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", self.value, sender.Balance)
}
var snapshot *ethstate.State
var snapshot *state.State
// If the receiver is nil it's a contract (\0*32).
if tx.CreatesContract() {
// Subtract the (irreversible) amount from the senders account
@ -195,7 +195,7 @@ func (self *StateTransition) TransitionState() (err error) {
snapshot = self.state.Copy()
}
msg := self.state.Manifest().AddMessage(&ethstate.Message{
msg := self.state.Manifest().AddMessage(&state.Message{
To: receiver.Address(), From: sender.Address(),
Input: self.tx.Data,
Origin: sender.Address(),
@ -232,14 +232,14 @@ func (self *StateTransition) TransitionState() (err error) {
} else {
// Add default LOG. Default = big(sender.addr) + 1
addr := ethutil.BigD(receiver.Address())
self.state.AddLog(ethstate.Log{sender.Address(), [][]byte{ethutil.U256(addr.Add(addr, ethutil.Big1)).Bytes()}, nil})
self.state.AddLog(state.Log{sender.Address(), [][]byte{ethutil.U256(addr.Add(addr, ethutil.Big1)).Bytes()}, nil})
}
}
return
}
func (self *StateTransition) Eval(msg *ethstate.Message, script []byte, context *ethstate.StateObject) (ret []byte, err error) {
func (self *StateTransition) Eval(msg *state.Message, script []byte, context *state.StateObject) (ret []byte, err error) {
var (
transactor = self.Sender()
state = self.state
@ -254,7 +254,7 @@ func (self *StateTransition) Eval(msg *ethstate.Message, script []byte, context
}
// Converts an transaction in to a state object
func MakeContract(tx *Transaction, state *ethstate.State) *ethstate.StateObject {
func MakeContract(tx *Transaction, state *state.State) *state.StateObject {
addr := tx.CreationAddress(state)
contract := state.GetOrNewStateObject(addr)

8
chain/transaction.go
View File

@ -6,8 +6,8 @@ import (
"math/big"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
"github.com/obscuren/secp256k1-go"
)
@ -78,7 +78,7 @@ func (tx *Transaction) IsContract() bool {
return tx.CreatesContract()
}
func (tx *Transaction) CreationAddress(state *ethstate.State) []byte {
func (tx *Transaction) CreationAddress(state *state.State) []byte {
// Generate a new address
addr := crypto.Sha3(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce}).Encode())[12:]
//for i := uint64(0); state.GetStateObject(addr) != nil; i++ {
@ -205,7 +205,7 @@ type Receipt struct {
PostState []byte
CumulativeGasUsed *big.Int
Bloom []byte
logs ethstate.Logs
logs state.Logs
}
func NewRecieptFromValue(val *ethutil.Value) *Receipt {
@ -222,7 +222,7 @@ func (self *Receipt) RlpValueDecode(decoder *ethutil.Value) {
it := decoder.Get(3).NewIterator()
for it.Next() {
self.logs = append(self.logs, ethstate.NewLogFromValue(it.Value()))
self.logs = append(self.logs, state.NewLogFromValue(it.Value()))
}
}

4
chain/transaction_pool.go
View File

@ -7,9 +7,9 @@ import (
"math/big"
"sync"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethwire"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/state"
)
var txplogger = logger.NewLogger("TXP")
@ -193,7 +193,7 @@ func (pool *TxPool) CurrentTransactions() []*Transaction {
return txList
}
func (pool *TxPool) RemoveInvalid(state *ethstate.State) {
func (pool *TxPool) RemoveInvalid(state *state.State) {
pool.mutex.Lock()
defer pool.mutex.Unlock()

28
chain/vm_env.go
View File

@ -3,17 +3,17 @@ package chain
import (
"math/big"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/vm"
)
type VMEnv struct {
state *ethstate.State
state *state.State
block *Block
tx *Transaction
}
func NewEnv(state *ethstate.State, tx *Transaction, block *Block) *VMEnv {
func NewEnv(state *state.State, tx *Transaction, block *Block) *VMEnv {
return &VMEnv{
state: state,
block: block,
@ -21,17 +21,17 @@ func NewEnv(state *ethstate.State, tx *Transaction, block *Block) *VMEnv {
}
}
func (self *VMEnv) Origin() []byte { return self.tx.Sender() }
func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
func (self *VMEnv) PrevHash() []byte { return self.block.PrevHash }
func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase }
func (self *VMEnv) Time() int64 { return self.block.Time }
func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty }
func (self *VMEnv) BlockHash() []byte { return self.block.Hash() }
func (self *VMEnv) Value() *big.Int { return self.tx.Value }
func (self *VMEnv) State() *ethstate.State { return self.state }
func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit }
func (self *VMEnv) AddLog(log ethstate.Log) {
func (self *VMEnv) Origin() []byte { return self.tx.Sender() }
func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
func (self *VMEnv) PrevHash() []byte { return self.block.PrevHash }
func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase }
func (self *VMEnv) Time() int64 { return self.block.Time }
func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty }
func (self *VMEnv) BlockHash() []byte { return self.block.Hash() }
func (self *VMEnv) Value() *big.Int { return self.tx.Value }
func (self *VMEnv) State() *state.State { return self.state }
func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit }
func (self *VMEnv) AddLog(log state.Log) {
self.state.AddLog(log)
}
func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {

20
cmd/mist/debugger.go
View File

@ -26,8 +26,8 @@ import (
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/vm"
"gopkg.in/qml.v1"
)
@ -40,7 +40,7 @@ type DebuggerWindow struct {
vm *vm.DebugVm
Db *Debugger
state *ethstate.State
state *state.State
}
func NewDebuggerWindow(lib *UiLib) *DebuggerWindow {
@ -141,17 +141,17 @@ func (self *DebuggerWindow) Debug(valueStr, gasStr, gasPriceStr, scriptStr, data
keyPair = self.lib.eth.KeyManager().KeyPair()
)
state := self.lib.eth.StateManager().TransState()
statedb := self.lib.eth.StateManager().TransState()
account := self.lib.eth.StateManager().TransState().GetAccount(keyPair.Address())
contract := ethstate.NewStateObject([]byte{0})
contract := statedb.NewStateObject([]byte{0})
contract.SetBalance(value)
self.SetAsm(script)
block := self.lib.eth.ChainManager().CurrentBlock
callerClosure := vm.NewClosure(&ethstate.Message{}, account, contract, script, gas, gasPrice)
env := utils.NewEnv(state, block, account.Address(), value)
callerClosure := vm.NewClosure(&state.Message{}, account, contract, script, gas, gasPrice)
env := utils.NewEnv(statedb, block, account.Address(), value)
evm := vm.NewDebugVm(env)
evm.Dbg = self.Db
@ -172,7 +172,7 @@ func (self *DebuggerWindow) Debug(valueStr, gasStr, gasPriceStr, scriptStr, data
}
}
state.Reset()
statedb.Reset()
if !self.Db.interrupt {
self.Db.done = true
@ -267,13 +267,13 @@ type storeVal struct {
Key, Value string
}
func (self *Debugger) BreakHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *ethstate.StateObject) bool {
func (self *Debugger) BreakHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *state.StateObject) bool {
self.main.Logln("break on instr:", pc)
return self.halting(pc, op, mem, stack, stateObject)
}
func (self *Debugger) StepHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *ethstate.StateObject) bool {
func (self *Debugger) StepHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *state.StateObject) bool {
return self.halting(pc, op, mem, stack, stateObject)
}
@ -285,7 +285,7 @@ func (self *Debugger) BreakPoints() []int64 {
return self.breakPoints
}
func (d *Debugger) halting(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *ethstate.StateObject) bool {
func (d *Debugger) halting(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *state.StateObject) bool {
d.win.Root().Call("setInstruction", pc)
d.win.Root().Call("clearMem")
d.win.Root().Call("clearStack")

8
cmd/mist/ext_app.go
View File

@ -21,9 +21,9 @@ import (
"encoding/json"
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/javascript"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/ui/qt"
"github.com/ethereum/go-ethereum/xeth"
"gopkg.in/qml.v1"
@ -38,7 +38,7 @@ type AppContainer interface {
NewBlock(*chain.Block)
NewWatcher(chan bool)
Messages(ethstate.Messages, string)
Messages(state.Messages, string)
Post(string, int)
}
@ -80,7 +80,7 @@ func (app *ExtApplication) run() {
// Subscribe to events
mux := app.lib.eth.EventMux()
app.events = mux.Subscribe(chain.NewBlockEvent{}, ethstate.Messages(nil))
app.events = mux.Subscribe(chain.NewBlockEvent{}, state.Messages(nil))
// Call the main loop
go app.mainLoop()
@ -109,7 +109,7 @@ func (app *ExtApplication) mainLoop() {
case chain.NewBlockEvent:
app.container.NewBlock(ev.Block)
case ethstate.Messages:
case state.Messages:
for id, filter := range app.filters {
msgs := filter.FilterMessages(ev)
if len(msgs) > 0 {

4
cmd/mist/html_container.go
View File

@ -28,9 +28,9 @@ import (
"path/filepath"
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/javascript"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/xeth"
"github.com/howeyc/fsnotify"
"gopkg.in/qml.v1"
@ -143,7 +143,7 @@ func (app *HtmlApplication) NewBlock(block *chain.Block) {
app.webView.Call("onNewBlockCb", b)
}
func (self *HtmlApplication) Messages(messages ethstate.Messages, id string) {
func (self *HtmlApplication) Messages(messages state.Messages, id string) {
var msgs []javascript.JSMessage
for _, m := range messages {
msgs = append(msgs, javascript.NewJSMessage(m))

4
cmd/mist/qml_container.go
View File

@ -22,8 +22,8 @@ import (
"runtime"
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/xeth"
"gopkg.in/qml.v1"
)
@ -70,7 +70,7 @@ func (app *QmlApplication) NewBlock(block *chain.Block) {
app.win.Call("onNewBlockCb", pblock)
}
func (self *QmlApplication) Messages(msgs ethstate.Messages, id string) {
func (self *QmlApplication) Messages(msgs state.Messages, id string) {
fmt.Println("IMPLEMENT QML APPLICATION MESSAGES METHOD")
}

4
cmd/mist/ui_lib.go
View File

@ -27,9 +27,9 @@ import (
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/javascript"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/ui/qt"
"github.com/ethereum/go-ethereum/xeth"
"gopkg.in/qml.v1"
@ -213,7 +213,7 @@ func (self *UiLib) StartDebugger() {
func (self *UiLib) NewFilter(object map[string]interface{}) (id int) {
filter := qt.NewFilterFromMap(object, self.eth)
filter.MessageCallback = func(messages ethstate.Messages) {
filter.MessageCallback = func(messages state.Messages) {
self.win.Root().Call("invokeFilterCallback", xeth.ToJSMessages(messages), id)
}
id = self.eth.InstallFilter(filter)

28
cmd/utils/vm_env.go
View File

@ -4,19 +4,19 @@ import (
"math/big"
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/vm"
)
type VMEnv struct {
state *ethstate.State
state *state.State
block *chain.Block
transactor []byte
value *big.Int
}
func NewEnv(state *ethstate.State, block *chain.Block, transactor []byte, value *big.Int) *VMEnv {
func NewEnv(state *state.State, block *chain.Block, transactor []byte, value *big.Int) *VMEnv {
return &VMEnv{
state: state,
block: block,
@ -25,17 +25,17 @@ func NewEnv(state *ethstate.State, block *chain.Block, transactor []byte, value
}
}
func (self *VMEnv) Origin() []byte { return self.transactor }
func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
func (self *VMEnv) PrevHash() []byte { return self.block.PrevHash }
func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase }
func (self *VMEnv) Time() int64 { return self.block.Time }
func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty }
func (self *VMEnv) BlockHash() []byte { return self.block.Hash() }
func (self *VMEnv) Value() *big.Int { return self.value }
func (self *VMEnv) State() *ethstate.State { return self.state }
func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit }
func (self *VMEnv) AddLog(ethstate.Log) {}
func (self *VMEnv) Origin() []byte { return self.transactor }
func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
func (self *VMEnv) PrevHash() []byte { return self.block.PrevHash }
func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase }
func (self *VMEnv) Time() int64 { return self.block.Time }
func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty }
func (self *VMEnv) BlockHash() []byte { return self.block.Hash() }
func (self *VMEnv) Value() *big.Int { return self.value }
func (self *VMEnv) State() *state.State { return self.state }
func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit }
func (self *VMEnv) AddLog(state.Log) {}
func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
return vm.Transfer(from, to, amount)
}

6
ethereum.go
View File

@ -16,12 +16,12 @@ import (
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/ethwire"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/rpc"
"github.com/ethereum/go-ethereum/state"
)
const (
@ -615,7 +615,7 @@ func (self *Ethereum) GetFilter(id int) *chain.Filter {
func (self *Ethereum) filterLoop() {
// Subscribe to events
events := self.eventMux.Subscribe(chain.NewBlockEvent{}, ethstate.Messages(nil))
events := self.eventMux.Subscribe(chain.NewBlockEvent{}, state.Messages(nil))
for event := range events.Chan() {
switch event := event.(type) {
case chain.NewBlockEvent:
@ -627,7 +627,7 @@ func (self *Ethereum) filterLoop() {
}
self.filterMu.RUnlock()
case ethstate.Messages:
case state.Messages:
self.filterMu.RLock()
for _, filter := range self.filters {
if filter.MessageCallback != nil {

0
ethstate/.ethtest
View File

4
javascript/javascript_runtime.go
View File

@ -10,10 +10,10 @@ import (
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/xeth"
"github.com/obscuren/otto"
)
@ -127,7 +127,7 @@ func (self *JSRE) initStdFuncs() {
*/
func (self *JSRE) dump(call otto.FunctionCall) otto.Value {
var state *ethstate.State
var state *state.State
if len(call.ArgumentList) > 0 {
var block *chain.Block

4
javascript/types.go
View File

@ -4,8 +4,8 @@ import (
"fmt"
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/ui"
"github.com/ethereum/go-ethereum/xeth"
"github.com/obscuren/otto"
@ -51,7 +51,7 @@ type JSMessage struct {
Number int32 `json:"number"`
}
func NewJSMessage(message *ethstate.Message) JSMessage {
func NewJSMessage(message *state.Message) JSMessage {
return JSMessage{
To: ethutil.Bytes2Hex(message.To),
From: ethutil.Bytes2Hex(message.From),

2
ethstate/dump.go → state/dump.go
View File

@ -1,4 +1,4 @@
package ethstate
package state
import (
"encoding/json"

2
ethstate/errors.go → state/errors.go
View File

@ -1,4 +1,4 @@
package ethstate
package state
import (
"fmt"

2
ethstate/log.go → state/log.go
View File

@ -1,4 +1,4 @@
package ethstate
package state
import "github.com/ethereum/go-ethereum/ethutil"

2
ethstate/manifest.go → state/manifest.go
View File

@ -1,4 +1,4 @@
package ethstate
package state
import (
"fmt"

2
ethstate/state.go → state/state.go
View File

@ -1,4 +1,4 @@
package ethstate
package state
import (
"math/big"

2
ethstate/state_object.go → state/state_object.go
View File

@ -1,4 +1,4 @@
package ethstate
package state
import (
"fmt"

2
ethstate/state_test.go → state/state_test.go
View File

@ -1,4 +1,4 @@
package ethstate
package state
import (
"testing"

12
vm/closure.go
View File

@ -5,14 +5,14 @@ package vm
import (
"math/big"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type ClosureRef interface {
ReturnGas(*big.Int, *big.Int)
Address() []byte
Object() *ethstate.StateObject
Object() *state.StateObject
GetStorage(*big.Int) *ethutil.Value
SetStorage(*big.Int, *ethutil.Value)
}
@ -20,9 +20,9 @@ type ClosureRef interface {
// Basic inline closure object which implement the 'closure' interface
type Closure struct {
caller ClosureRef
object *ethstate.StateObject
object *state.StateObject
Code []byte
message *ethstate.Message
message *state.Message
exe *Execution
Gas, UsedGas, Price *big.Int
@ -31,7 +31,7 @@ type Closure struct {
}
// Create a new closure for the given data items
func NewClosure(msg *ethstate.Message, caller ClosureRef, object *ethstate.StateObject, code []byte, gas, price *big.Int) *Closure {
func NewClosure(msg *state.Message, caller ClosureRef, object *state.StateObject, code []byte, gas, price *big.Int) *Closure {
c := &Closure{message: msg, caller: caller, object: object, Code: code, Args: nil}
// Gas should be a pointer so it can safely be reduced through the run
@ -131,7 +131,7 @@ func (c *Closure) ReturnGas(gas, price *big.Int) {
c.UsedGas.Sub(c.UsedGas, gas)
}
func (c *Closure) Object() *ethstate.StateObject {
func (c *Closure) Object() *state.StateObject {
return c.object
}

6
vm/debugger.go
View File

@ -1,10 +1,10 @@
package vm
import "github.com/ethereum/go-ethereum/ethstate"
import "github.com/ethereum/go-ethereum/state"
type Debugger interface {
BreakHook(step int, op OpCode, mem *Memory, stack *Stack, object *ethstate.StateObject) bool
StepHook(step int, op OpCode, mem *Memory, stack *Stack, object *ethstate.StateObject) bool
BreakHook(step int, op OpCode, mem *Memory, stack *Stack, object *state.StateObject) bool
StepHook(step int, op OpCode, mem *Memory, stack *Stack, object *state.StateObject) bool
BreakPoints() []int64
SetCode(byteCode []byte)
}

6
vm/environment.go
View File

@ -4,12 +4,12 @@ import (
"errors"
"math/big"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type Environment interface {
State() *ethstate.State
State() *state.State
Origin() []byte
BlockNumber() *big.Int
@ -20,7 +20,7 @@ type Environment interface {
BlockHash() []byte
GasLimit() *big.Int
Transfer(from, to Account, amount *big.Int) error
AddLog(ethstate.Log)
AddLog(state.Log)
}
type Object interface {

6
vm/execution.go
View File

@ -4,15 +4,15 @@ import (
"fmt"
"math/big"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type Execution struct {
vm VirtualMachine
address, input []byte
Gas, price, value *big.Int
object *ethstate.StateObject
object *state.StateObject
SkipTransfer bool
}
@ -41,7 +41,7 @@ func (self *Execution) exec(code, caddr []byte, caller ClosureRef) (ret []byte,
}
}()
msg := env.State().Manifest().AddMessage(&ethstate.Message{
msg := env.State().Manifest().AddMessage(&state.Message{
To: self.address, From: caller.Address(),
Input: self.input,
Origin: env.Origin(),

34
vm/vm_debug.go
View File

@ -5,8 +5,8 @@ import (
"math/big"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type DebugVm struct {
@ -49,7 +49,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
pc = big.NewInt(0)
step = 0
prevStep = 0
state = self.env.State()
statedb = self.env.State()
require = func(m int) {
if stack.Len() < m {
panic(fmt.Sprintf("%04v (%v) stack err size = %d, required = %d", pc, op, stack.Len(), m))
@ -115,7 +115,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
if self.logTy == LogTyDiff {
switch op {
case STOP, RETURN, SUICIDE:
state.GetStateObject(closure.Address()).EachStorage(func(key string, value *ethutil.Value) {
statedb.GetStateObject(closure.Address()).EachStorage(func(key string, value *ethutil.Value) {
value.Decode()
fmt.Printf("%x %x\n", new(big.Int).SetBytes([]byte(key)).Bytes(), value.Bytes())
})
@ -184,7 +184,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
// 0 => non 0
mult = ethutil.Big3
} else if val.BigInt().Cmp(ethutil.Big0) != 0 && len(y.Bytes()) == 0 {
state.Refund(closure.caller.Address(), GasSStoreRefund, closure.Price)
statedb.Refund(closure.caller.Address(), GasSStoreRefund, closure.Price)
mult = ethutil.Big0
} else {
@ -532,7 +532,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
case BALANCE:
addr := stack.Pop().Bytes()
balance := state.GetBalance(addr)
balance := statedb.GetBalance(addr)
stack.Push(balance)
@ -599,7 +599,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
if op == EXTCODESIZE {
addr := stack.Pop().Bytes()
code = state.GetCode(addr)
code = statedb.GetCode(addr)
} else {
code = closure.Code
}
@ -613,7 +613,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
if op == EXTCODECOPY {
addr := stack.Pop().Bytes()
code = state.GetCode(addr)
code = statedb.GetCode(addr)
} else {
code = closure.Code
}
@ -711,7 +711,7 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
for i := 0; i < n; i++ {
topics[i] = stack.Pop().Bytes()
}
self.env.AddLog(ethstate.Log{closure.Address(), topics, data})
self.env.AddLog(state.Log{closure.Address(), topics, data})
case MLOAD:
offset := stack.Pop()
val := ethutil.BigD(mem.Get(offset.Int64(), 32))
@ -733,13 +733,13 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
self.Printf(" => [%v] 0x%x", off, val)
case SLOAD:
loc := stack.Pop()
val := ethutil.BigD(state.GetState(closure.Address(), loc.Bytes()))
val := ethutil.BigD(statedb.GetState(closure.Address(), loc.Bytes()))
stack.Push(val)
self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
case SSTORE:
val, loc := stack.Popn()
state.SetState(closure.Address(), loc.Bytes(), val)
statedb.SetState(closure.Address(), loc.Bytes(), val)
// Debug sessions are allowed to run without message
if closure.message != nil {
@ -784,9 +784,9 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
)
// Generate a new address
n := state.GetNonce(closure.Address())
n := statedb.GetNonce(closure.Address())
addr := crypto.CreateAddress(closure.Address(), n)
state.SetNonce(closure.Address(), n+1)
statedb.SetNonce(closure.Address(), n+1)
self.Printf(" (*) %x", addr).Endl()
@ -861,10 +861,10 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
return closure.Return(ret), nil
case SUICIDE:
receiver := state.GetOrNewStateObject(stack.Pop().Bytes())
receiver := statedb.GetOrNewStateObject(stack.Pop().Bytes())
receiver.AddAmount(state.GetBalance(closure.Address()))
state.Delete(closure.Address())
receiver.AddAmount(statedb.GetBalance(closure.Address()))
statedb.Delete(closure.Address())
fallthrough
case STOP: // Stop the closure
@ -889,11 +889,11 @@ func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
if pc.Cmp(big.NewInt(instrNo)) == 0 {
self.Stepping = true
if !self.Dbg.BreakHook(prevStep, op, mem, stack, state.GetStateObject(closure.Address())) {
if !self.Dbg.BreakHook(prevStep, op, mem, stack, statedb.GetStateObject(closure.Address())) {
return nil, nil
}
} else if self.Stepping {
if !self.Dbg.StepHook(prevStep, op, mem, stack, state.GetStateObject(closure.Address())) {
if !self.Dbg.StepHook(prevStep, op, mem, stack, statedb.GetStateObject(closure.Address())) {
return nil, nil
}
}

4
xeth/hexface.go
View File

@ -7,8 +7,8 @@ import (
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type JSXEth struct {
@ -254,7 +254,7 @@ func (self *JSXEth) CompileMutan(code string) string {
return ethutil.Bytes2Hex(data)
}
func ToJSMessages(messages ethstate.Messages) *ethutil.List {
func ToJSMessages(messages state.Messages) *ethutil.List {
var msgs []JSMessage
for _, m := range messages {
msgs = append(msgs, NewJSMessage(m))

6
xeth/js_types.go
View File

@ -7,8 +7,8 @@ import (
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
// Block interface exposed to QML
@ -90,7 +90,7 @@ type JSTransaction struct {
Confirmations int `json:"confirmations"`
}
func NewJSTx(tx *chain.Transaction, state *ethstate.State) *JSTransaction {
func NewJSTx(tx *chain.Transaction, state *state.State) *JSTransaction {
hash := ethutil.Bytes2Hex(tx.Hash())
receiver := ethutil.Bytes2Hex(tx.Recipient)
if receiver == "0000000000000000000000000000000000000000" {
@ -212,7 +212,7 @@ type JSMessage struct {
Value string `json:"value"`
}
func NewJSMessage(message *ethstate.Message) JSMessage {
func NewJSMessage(message *state.Message) JSMessage {
return JSMessage{
To: ethutil.Bytes2Hex(message.To),
From: ethutil.Bytes2Hex(message.From),

4
xeth/object.go
View File

@ -1,12 +1,12 @@
package xeth
import (
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type Object struct {
*ethstate.StateObject
*state.StateObject
}
func (self *Object) StorageString(str string) *ethutil.Value {

6
xeth/pipe.go
View File

@ -10,16 +10,16 @@ import (
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/vm"
)
var pipelogger = logger.NewLogger("XETH")
type VmVars struct {
State *ethstate.State
State *state.State
}
type XEth struct {
@ -56,7 +56,7 @@ func (self *XEth) Execute(addr []byte, data []byte, value, gas, price *ethutil.V
func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) {
var (
initiator = ethstate.NewStateObject(self.obj.KeyManager().KeyPair().Address())
initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address())
block = self.blockChain.CurrentBlock
)

28
xeth/vm_env.go
View File

@ -4,18 +4,18 @@ import (
"math/big"
"github.com/ethereum/go-ethereum/chain"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/vm"
)
type VMEnv struct {
state *ethstate.State
state *state.State
block *chain.Block
value *big.Int
sender []byte
}
func NewEnv(state *ethstate.State, block *chain.Block, value *big.Int, sender []byte) *VMEnv {
func NewEnv(state *state.State, block *chain.Block, value *big.Int, sender []byte) *VMEnv {
return &VMEnv{
state: state,
block: block,
@ -24,17 +24,17 @@ func NewEnv(state *ethstate.State, block *chain.Block, value *big.Int, sender []
}
}
func (self *VMEnv) Origin() []byte { return self.sender }
func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
func (self *VMEnv) PrevHash() []byte { return self.block.PrevHash }
func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase }
func (self *VMEnv) Time() int64 { return self.block.Time }
func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty }
func (self *VMEnv) BlockHash() []byte { return self.block.Hash() }
func (self *VMEnv) Value() *big.Int { return self.value }
func (self *VMEnv) State() *ethstate.State { return self.state }
func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit }
func (self *VMEnv) AddLog(ethstate.Log) {}
func (self *VMEnv) Origin() []byte { return self.sender }
func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
func (self *VMEnv) PrevHash() []byte { return self.block.PrevHash }
func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase }
func (self *VMEnv) Time() int64 { return self.block.Time }
func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty }
func (self *VMEnv) BlockHash() []byte { return self.block.Hash() }
func (self *VMEnv) Value() *big.Int { return self.value }
func (self *VMEnv) State() *state.State { return self.state }
func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit }
func (self *VMEnv) AddLog(state.Log) {}
func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
return vm.Transfer(from, to, amount)
}

10
xeth/world.go
View File

@ -3,7 +3,7 @@ package xeth
import (
"container/list"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/state"
)
type World struct {
@ -22,7 +22,7 @@ func (self *XEth) World() *World {
return self.world
}
func (self *World) State() *ethstate.State {
func (self *World) State() *state.State {
return self.pipe.stateManager.CurrentState()
}
@ -34,16 +34,16 @@ func (self *World) SafeGet(addr []byte) *Object {
return &Object{self.safeGet(addr)}
}
func (self *World) safeGet(addr []byte) *ethstate.StateObject {
func (self *World) safeGet(addr []byte) *state.StateObject {
object := self.State().GetStateObject(addr)
if object == nil {
object = ethstate.NewStateObject(addr)
object = state.NewStateObject(addr)
}
return object
}
func (self *World) Coinbase() *ethstate.StateObject {
func (self *World) Coinbase() *state.StateObject {
return nil
}