roysc/plugeth
1
0
Fork 0
forked from cerc-io/plugeth
Code Pull Requests Activity

Merged develop

Browse Source
This commit is contained in:
obscuren 2014-12-18 13:19:41 +01:00
commit 721e8ae93f
18 changed files with 194 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
_data/chain1 Executable file
View File

Binary file not shown.

BIN
_data/chain2 Executable file
View File

Binary file not shown.

2
cmd/ethereum/main.go
View File

@ -77,7 +77,7 @@ func main() {
var block *types.Block
if len(DumpHash) == 0 && DumpNumber == -1 {
block = ethereum.ChainManager().CurrentBlock
block = ethereum.ChainManager().CurrentBlock()
} else if len(DumpHash) > 0 {
block = ethereum.ChainManager().GetBlock(ethutil.Hex2Bytes(DumpHash))
} else {

2
cmd/mist/debugger.go
View File

@ -149,7 +149,7 @@ func (self *DebuggerWindow) Debug(valueStr, gasStr, gasPriceStr, scriptStr, data
self.SetAsm(script)
block := self.lib.eth.ChainManager().CurrentBlock
block := self.lib.eth.ChainManager().CurrentBlock()
env := utils.NewEnv(statedb, block, account.Address(), value)

4
cmd/mist/gui.go
View File

@ -250,7 +250,7 @@ func (gui *Gui) CreateAndSetPrivKey() (string, string, string, string) {
}
func (gui *Gui) setInitialChain(ancientBlocks bool) {
sBlk := gui.eth.ChainManager().LastBlockHash
sBlk := gui.eth.ChainManager().LastBlockHash()
blk := gui.eth.ChainManager().GetBlock(sBlk)
for ; blk != nil; blk = gui.eth.ChainManager().GetBlock(sBlk) {
sBlk = blk.PrevHash
@ -470,7 +470,7 @@ func (gui *Gui) update() {
case <-peerUpdateTicker.C:
gui.setPeerInfo()
case <-generalUpdateTicker.C:
statusText := "#" + gui.eth.ChainManager().CurrentBlock.Number.String()
statusText := "#" + gui.eth.ChainManager().CurrentBlock().Number.String()
lastBlockLabel.Set("text", statusText)
miningLabel.Set("text", "Mining @ "+strconv.FormatInt(gui.uiLib.miner.GetPow().GetHashrate(), 10)+"Khash")

20
core/block_manager.go
View File

@ -56,8 +56,8 @@ type BlockManager struct {
mem map[string]*big.Int
// Proof of work used for validating
Pow pow.PoW
// The ethereum manager interface
eth EthManager
txpool *TxPool
// The last attempted block is mainly used for debugging purposes
// This does not have to be a valid block and will be set during
@ -69,13 +69,13 @@ type BlockManager struct {
eventMux *event.TypeMux
}
func NewBlockManager(ethereum EthManager) *BlockManager {
func NewBlockManager(txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockManager {
sm := &BlockManager{
mem: make(map[string]*big.Int),
Pow: ezp.New(),
eth: ethereum,
bc: ethereum.ChainManager(),
eventMux: ethereum.EventMux(),
bc: chainManager,
eventMux: eventMux,
txpool: txpool,
}
return sm
@ -238,7 +238,7 @@ func (sm *BlockManager) ProcessWithParent(block, parent *types.Block) (td *big.I
chainlogger.Infof("Processed block #%d (%x...)\n", block.Number, block.Hash()[0:4])
sm.eth.TxPool().RemoveSet(block.Transactions())
sm.txpool.RemoveSet(block.Transactions())
return td, messages, nil
} else {
@ -254,12 +254,12 @@ func (sm *BlockManager) CalculateTD(block *types.Block) (*big.Int, bool) {
// TD(genesis_block) = 0 and TD(B) = TD(B.parent) + sum(u.difficulty for u in B.uncles) + B.difficulty
td := new(big.Int)
td = td.Add(sm.bc.TD, uncleDiff)
td = td.Add(sm.bc.Td(), uncleDiff)
td = td.Add(td, block.Difficulty)
// The new TD will only be accepted if the new difficulty is
// is greater than the previous.
if td.Cmp(sm.bc.TD) > 0 {
if td.Cmp(sm.bc.Td()) > 0 {
return td, true
}
@ -277,7 +277,7 @@ func (sm *BlockManager) ValidateBlock(block, parent *types.Block) error {
diff := block.Time - parent.Time
if diff < 0 {
return ValidationError("Block timestamp less then prev block %v (%v - %v)", diff, block.Time, sm.bc.CurrentBlock.Time)
return ValidationError("Block timestamp less then prev block %v (%v - %v)", diff, block.Time, sm.bc.CurrentBlock().Time)
}
/* XXX

122
core/chain_manager.go
View File

@ -3,6 +3,7 @@ package core
import (
"fmt"
"math/big"
"sync"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/ethutil"
@ -50,16 +51,43 @@ type ChainManager struct {
eventMux *event.TypeMux
genesisBlock *types.Block
// Last known total difficulty
TD *big.Int
LastBlockNumber uint64
CurrentBlock *types.Block
LastBlockHash []byte
mu sync.RWMutex
td *big.Int
lastBlockNumber uint64
currentBlock *types.Block
lastBlockHash []byte
transState *state.StateDB
}
func (self *ChainManager) Td() *big.Int {
self.mu.RLock()
defer self.mu.RUnlock()
return self.td
}
func (self *ChainManager) LastBlockNumber() uint64 {
self.mu.RLock()
defer self.mu.RUnlock()
return self.lastBlockNumber
}
func (self *ChainManager) LastBlockHash() []byte {
self.mu.RLock()
defer self.mu.RUnlock()
return self.lastBlockHash
}
func (self *ChainManager) CurrentBlock() *types.Block {
self.mu.RLock()
defer self.mu.RUnlock()
return self.currentBlock
}
func NewChainManager(mux *event.TypeMux) *ChainManager {
bc := &ChainManager{}
bc.genesisBlock = types.NewBlockFromBytes(ethutil.Encode(Genesis))
@ -81,7 +109,7 @@ func (self *ChainManager) SetProcessor(proc types.BlockProcessor) {
}
func (self *ChainManager) State() *state.StateDB {
return self.CurrentBlock.State()
return self.CurrentBlock().State()
}
func (self *ChainManager) TransState() *state.StateDB {
@ -95,27 +123,30 @@ func (bc *ChainManager) setLastBlock() {
AddTestNetFunds(bc.genesisBlock)
block := types.NewBlockFromBytes(data)
bc.CurrentBlock = block
bc.LastBlockHash = block.Hash()
bc.LastBlockNumber = block.Number.Uint64()
bc.currentBlock = block
bc.lastBlockHash = block.Hash()
bc.lastBlockNumber = block.Number.Uint64()
// Set the last know difficulty (might be 0x0 as initial value, Genesis)
bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD())
bc.td = ethutil.BigD(ethutil.Config.Db.LastKnownTD())
} else {
bc.Reset()
}
chainlogger.Infof("Last block (#%d) %x\n", bc.LastBlockNumber, bc.CurrentBlock.Hash())
chainlogger.Infof("Last block (#%d) %x\n", bc.lastBlockNumber, bc.currentBlock.Hash())
}
// Block creation & chain handling
func (bc *ChainManager) NewBlock(coinbase []byte) *types.Block {
bc.mu.RLock()
defer bc.mu.RUnlock()
var root interface{}
hash := ZeroHash256
if bc.CurrentBlock != nil {
root = bc.CurrentBlock.Root()
hash = bc.LastBlockHash
root = bc.currentBlock.Root()
hash = bc.lastBlockHash
}
block := types.CreateBlock(
@ -126,11 +157,11 @@ func (bc *ChainManager) NewBlock(coinbase []byte) *types.Block {
nil,
"")
parent := bc.CurrentBlock
parent := bc.currentBlock
if parent != nil {
block.Difficulty = CalcDifficulty(block, parent)
block.Number = new(big.Int).Add(bc.CurrentBlock.Number, ethutil.Big1)
block.GasLimit = block.CalcGasLimit(bc.CurrentBlock)
block.Number = new(big.Int).Add(bc.currentBlock.Number, ethutil.Big1)
block.GasLimit = block.CalcGasLimit(bc.currentBlock)
}
@ -138,35 +169,42 @@ func (bc *ChainManager) NewBlock(coinbase []byte) *types.Block {
}
func (bc *ChainManager) Reset() {
bc.mu.Lock()
defer bc.mu.Unlock()
AddTestNetFunds(bc.genesisBlock)
bc.genesisBlock.Trie().Sync()
// Prepare the genesis block
bc.write(bc.genesisBlock)
bc.insert(bc.genesisBlock)
bc.CurrentBlock = bc.genesisBlock
bc.currentBlock = bc.genesisBlock
bc.SetTotalDifficulty(ethutil.Big("0"))
bc.setTotalDifficulty(ethutil.Big("0"))
// Set the last know difficulty (might be 0x0 as initial value, Genesis)
bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD())
bc.td = ethutil.BigD(ethutil.Config.Db.LastKnownTD())
}
func (self *ChainManager) Export() []byte {
chainlogger.Infoln("exporting", self.CurrentBlock.Number, "blocks")
self.mu.RLock()
defer self.mu.RUnlock()
blocks := make(types.Blocks, int(self.CurrentBlock.Number.Int64())+1)
for block := self.CurrentBlock; block != nil; block = self.GetBlock(block.PrevHash) {
chainlogger.Infof("exporting %v blocks...\n", self.currentBlock.Number)
blocks := make([]*types.Block, int(self.currentBlock.Number.Int64())+1)
for block := self.currentBlock; block != nil; block = self.GetBlock(block.PrevHash) {
blocks[block.Number.Int64()] = block
}
return ethutil.Encode(blocks)
}
func (bc *ChainManager) insert(block *types.Block) {
encodedBlock := block.RlpEncode()
ethutil.Config.Db.Put([]byte("LastBlock"), encodedBlock)
bc.CurrentBlock = block
bc.LastBlockHash = block.Hash()
bc.currentBlock = block
bc.lastBlockHash = block.Hash()
}
func (bc *ChainManager) write(block *types.Block) {
@ -217,7 +255,10 @@ func (self *ChainManager) GetBlock(hash []byte) *types.Block {
}
func (self *ChainManager) GetBlockByNumber(num uint64) *types.Block {
block := self.CurrentBlock
self.mu.RLock()
defer self.mu.RUnlock()
block := self.currentBlock
for ; block != nil; block = self.GetBlock(block.PrevHash) {
if block.Number.Uint64() == num {
break
@ -231,9 +272,9 @@ func (self *ChainManager) GetBlockByNumber(num uint64) *types.Block {
return block
}
func (bc *ChainManager) SetTotalDifficulty(td *big.Int) {
func (bc *ChainManager) setTotalDifficulty(td *big.Int) {
ethutil.Config.Db.Put([]byte("LTD"), td.Bytes())
bc.TD = td
bc.td = td
}
func (self *ChainManager) CalcTotalDiff(block *types.Block) (*big.Int, error) {
@ -266,8 +307,8 @@ func (bc *ChainManager) BlockInfo(block *types.Block) types.BlockInfo {
// Unexported method for writing extra non-essential block info to the db
func (bc *ChainManager) writeBlockInfo(block *types.Block) {
bc.LastBlockNumber++
bi := types.BlockInfo{Number: bc.LastBlockNumber, Hash: block.Hash(), Parent: block.PrevHash, TD: bc.TD}
bc.lastBlockNumber++
bi := types.BlockInfo{Number: bc.lastBlockNumber, Hash: block.Hash(), Parent: block.PrevHash, TD: bc.td}
// For now we use the block hash with the words "info" appended as key
ethutil.Config.Db.Put(append(block.Hash(), []byte("Info")...), bi.RlpEncode())
@ -293,17 +334,22 @@ func (self *ChainManager) InsertChain(chain types.Blocks) error {
return err
}
self.write(block)
if td.Cmp(self.TD) > 0 {
if block.Number.Cmp(new(big.Int).Add(self.CurrentBlock.Number, ethutil.Big1)) < 0 {
chainlogger.Infof("Split detected. New head #%v (%x), was #%v (%x)\n", block.Number, block.Hash()[:4], self.CurrentBlock.Number, self.CurrentBlock.Hash()[:4])
self.mu.Lock()
{
self.write(block)
if td.Cmp(self.td) > 0 {
if block.Number.Cmp(new(big.Int).Add(self.currentBlock.Number, ethutil.Big1)) < 0 {
chainlogger.Infof("Split detected. New head #%v (%x), was #%v (%x)\n", block.Number, block.Hash()[:4], self.currentBlock.Number, self.currentBlock.Hash()[:4])
}
self.setTotalDifficulty(td)
self.insert(block)
self.transState = self.currentBlock.State().Copy()
}
self.SetTotalDifficulty(td)
self.insert(block)
self.transState = self.State().Copy()
//sm.eth.TxPool().RemoveSet(block.Transactions())
}
self.mu.Unlock()
self.eventMux.Post(NewBlockEvent{block})
self.eventMux.Post(messages)

66
core/chain_manager_test.go
View File

@ -3,17 +3,75 @@ package core
import (
"fmt"
"path"
"runtime"
"testing"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/event"
//logpkg "github.com/ethereum/go-ethereum/logger"
)
func TestChainInsertions(t *testing.T) {
c1, err := ethutil.ReadAllFile(path.Join("..", "_data", "chain1"))
//var Logger logpkg.LogSystem
//var Log = logpkg.NewLogger("TEST")
func init() {
runtime.GOMAXPROCS(runtime.NumCPU())
//Logger = logpkg.NewStdLogSystem(os.Stdout, log.LstdFlags, logpkg.InfoLevel)
//logpkg.AddLogSystem(Logger)
ethutil.ReadConfig("/tmp/ethtest", "/tmp/ethtest", "ETH")
db, err := ethdb.NewMemDatabase()
if err != nil {
panic("Could not create mem-db, failing")
}
ethutil.Config.Db = db
}
func loadChain(fn string, t *testing.T) types.Blocks {
c1, err := ethutil.ReadAllFile(path.Join("..", "_data", fn))
if err != nil {
fmt.Println(err)
t.FailNow()
}
data1, _ := ethutil.Decode([]byte(c1), 0)
fmt.Println(data1)
value := ethutil.NewValueFromBytes([]byte(c1))
blocks := make(types.Blocks, value.Len())
it := value.NewIterator()
for it.Next() {
blocks[it.Idx()] = types.NewBlockFromRlpValue(it.Value())
}
return blocks
}
func insertChain(done chan bool, chainMan *ChainManager, chain types.Blocks, t *testing.T) {
err := chainMan.InsertChain(chain)
if err != nil {
fmt.Println(err)
t.FailNow()
}
done <- true
}
func TestChainInsertions(t *testing.T) {
chain1 := loadChain("chain1", t)
chain2 := loadChain("chain2", t)
var eventMux event.TypeMux
chainMan := NewChainManager(&eventMux)
txPool := NewTxPool(chainMan, nil, &eventMux)
blockMan := NewBlockManager(txPool, chainMan, &eventMux)
chainMan.SetProcessor(blockMan)
const max = 2
done := make(chan bool, max)
go insertChain(done, chainMan, chain1, t)
go insertChain(done, chainMan, chain2, t)
for i := 0; i < max; i++ {
<-done
}
fmt.Println(chainMan.CurrentBlock())
}

4
core/filter.go
View File

@ -78,11 +78,11 @@ func (self *Filter) SetSkip(skip int) {
func (self *Filter) Find() []*state.Message {
var earliestBlockNo uint64 = uint64(self.earliest)
if self.earliest == -1 {
earliestBlockNo = self.eth.ChainManager().CurrentBlock.Number.Uint64()
earliestBlockNo = self.eth.ChainManager().CurrentBlock().Number.Uint64()
}
var latestBlockNo uint64 = uint64(self.latest)
if self.latest == -1 {
latestBlockNo = self.eth.ChainManager().CurrentBlock.Number.Uint64()
latestBlockNo = self.eth.ChainManager().CurrentBlock().Number.Uint64()
}
var (

6
core/filter_test.go
View File

@ -1,7 +1 @@
package core
// import "testing"
// func TestFilter(t *testing.T) {
// NewFilter(NewTestManager())
// }

24
core/transaction_pool.go
View File

@ -8,6 +8,7 @@ import (
"sync"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/state"
)
@ -57,7 +58,6 @@ type TxProcessor interface {
// pool is being drained or synced for whatever reason the transactions
// will simple queue up and handled when the mutex is freed.
type TxPool struct {
Ethereum EthManager
// The mutex for accessing the Tx pool.
mutex sync.Mutex
// Queueing channel for reading and writing incoming
@ -71,14 +71,20 @@ type TxPool struct {
SecondaryProcessor TxProcessor
subscribers []chan TxMsg
broadcaster types.Broadcaster
chainManager *ChainManager
eventMux *event.TypeMux
}
func NewTxPool(ethereum EthManager) *TxPool {
func NewTxPool(chainManager *ChainManager, broadcaster types.Broadcaster, eventMux *event.TypeMux) *TxPool {
return &TxPool{
pool: list.New(),
queueChan: make(chan *types.Transaction, txPoolQueueSize),
quit: make(chan bool),
Ethereum: ethereum,
pool: list.New(),
queueChan: make(chan *types.Transaction, txPoolQueueSize),
quit: make(chan bool),
chainManager: chainManager,
eventMux: eventMux,
broadcaster: broadcaster,
}
}
@ -96,7 +102,7 @@ func (pool *TxPool) addTransaction(tx *types.Transaction) {
func (pool *TxPool) ValidateTransaction(tx *types.Transaction) error {
// Get the last block so we can retrieve the sender and receiver from
// the merkle trie
block := pool.Ethereum.ChainManager().CurrentBlock
block := pool.chainManager.CurrentBlock
// Something has gone horribly wrong if this happens
if block == nil {
return fmt.Errorf("No last block on the block chain")
@ -112,7 +118,7 @@ func (pool *TxPool) ValidateTransaction(tx *types.Transaction) error {
}
// Get the sender
sender := pool.Ethereum.ChainManager().State().GetAccount(tx.Sender())
sender := pool.chainManager.State().GetAccount(tx.Sender())
totAmount := new(big.Int).Set(tx.Value)
// Make sure there's enough in the sender's account. Having insufficient
@ -156,7 +162,7 @@ func (self *TxPool) Add(tx *types.Transaction) error {
txplogger.Debugf("(t) %x => %x (%v) %x\n", tx.Sender()[:4], tmp, tx.Value, tx.Hash())
// Notify the subscribers
go self.Ethereum.EventMux().Post(TxPreEvent{tx})
go self.eventMux.Post(TxPreEvent{tx})
return nil
}

2
core/types/block.go
View File

@ -409,7 +409,7 @@ func (self *Block) Size() ethutil.StorageSize {
// Implement RlpEncodable
func (self *Block) RlpData() interface{} {
return self.Value().Val
return []interface{}{self.header(), self.transactions, self.rlpUncles()}
}
// Implement pow.Block

5
core/types/common.go
View File

@ -4,8 +4,13 @@ import (
"math/big"
"github.com/ethereum/go-ethereum/state"
"github.com/ethereum/go-ethereum/wire"
)
type BlockProcessor interface {
Process(*Block) (*big.Int, state.Messages, error)
}
type Broadcaster interface {
Broadcast(wire.MsgType, []interface{})
}

10
ethutil/rlp.go
View File

@ -2,7 +2,6 @@ package ethutil
import (
"bytes"
"encoding/binary"
"fmt"
"math/big"
"reflect"
@ -193,8 +192,13 @@ func Encode(object interface{}) []byte {
if blen < 56 {
buff.WriteByte(byte(blen) + 0xc0)
} else {
buff.WriteByte(byte(intlen(int64(blen))) + 0xf7)
binary.Write(&buff, binary.BigEndian, int64(blen))
ilen := byte(intlen(int64(blen)))
buff.WriteByte(ilen + 0xf7)
t := make([]byte, ilen)
for i := byte(0); i < ilen; i++ {
t[ilen-i-1] = byte(blen >> (i * 8))
}
buff.Write(t)
}
buff.ReadFrom(&b)
}

2
ethutil/value.go
View File

@ -397,5 +397,5 @@ func (it *ValueIterator) Value() *Value {
}
func (it *ValueIterator) Idx() int {
return it.idx
return it.idx - 1
}

2
pow/ezp/pow.go
View File

@ -21,7 +21,7 @@ type EasyPow struct {
}
func New() *EasyPow {
return &EasyPow{}
return &EasyPow{turbo: true}
}
func (pow *EasyPow) GetHashrate() int64 {

2
xeth/hexface.go
View File

@ -28,7 +28,7 @@ func (self *JSXEth) BlockByHash(strHash string) *JSBlock {
func (self *JSXEth) BlockByNumber(num int32) *JSBlock {
if num == -1 {
return NewJSBlock(self.obj.ChainManager().CurrentBlock)
return NewJSBlock(self.obj.ChainManager().CurrentBlock())
}
return NewJSBlock(self.obj.ChainManager().GetBlockByNumber(uint64(num)))

2
xeth/pipe.go
View File

@ -82,7 +82,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 = state.NewStateObject(self.obj.KeyManager().KeyPair().Address())
block = self.chainManager.CurrentBlock
block = self.chainManager.CurrentBlock()
)
self.Vm.State = self.World().State().Copy()