aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorobscuren <geffobscura@gmail.com>2014-12-18 20:19:41 +0800
committerobscuren <geffobscura@gmail.com>2014-12-18 20:19:41 +0800
commit721e8ae93f9b8918ff4bc74af86c530bacacea00 (patch)
treeee33bd346e396f56d6462f99de9ca7b5dac9c586
parente6fdf0c9f7564b8b08cf428e03af66fc423adcc1 (diff)
parent2d09e67713757e2a80eb614562c97f962af36cf7 (diff)
downloaddexon-721e8ae93f9b8918ff4bc74af86c530bacacea00.tar
dexon-721e8ae93f9b8918ff4bc74af86c530bacacea00.tar.gz
dexon-721e8ae93f9b8918ff4bc74af86c530bacacea00.tar.bz2
dexon-721e8ae93f9b8918ff4bc74af86c530bacacea00.tar.lz
dexon-721e8ae93f9b8918ff4bc74af86c530bacacea00.tar.xz
dexon-721e8ae93f9b8918ff4bc74af86c530bacacea00.tar.zst
dexon-721e8ae93f9b8918ff4bc74af86c530bacacea00.zip
Merged develop
-rwxr-xr-x_data/chain1bin0 -> 175331 bytes
-rwxr-xr-x_data/chain2bin0 -> 28118 bytes
-rw-r--r--cmd/ethereum/main.go2
-rw-r--r--cmd/mist/debugger.go2
-rw-r--r--cmd/mist/gui.go4
-rw-r--r--core/block_manager.go20
-rw-r--r--core/chain_manager.go120
-rw-r--r--core/chain_manager_test.go66
-rw-r--r--core/filter.go4
-rw-r--r--core/filter_test.go6
-rw-r--r--core/transaction_pool.go24
-rw-r--r--core/types/block.go2
-rw-r--r--core/types/common.go5
-rw-r--r--ethutil/rlp.go10
-rw-r--r--ethutil/value.go2
-rw-r--r--pow/ezp/pow.go2
-rw-r--r--xeth/hexface.go2
-rw-r--r--xeth/pipe.go2
18 files changed, 193 insertions, 80 deletions
diff --git a/_data/chain1 b/_data/chain1
new file mode 100755
index 000000000..ef392e001
--- /dev/null
+++ b/_data/chain1
Binary files differ
diff --git a/_data/chain2 b/_data/chain2
new file mode 100755
index 000000000..48ed4d5ea
--- /dev/null
+++ b/_data/chain2
Binary files differ
diff --git a/cmd/ethereum/main.go b/cmd/ethereum/main.go
index 4f87ef17b..da09e0b58 100644
--- a/cmd/ethereum/main.go
+++ b/cmd/ethereum/main.go
@@ -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 {
diff --git a/cmd/mist/debugger.go b/cmd/mist/debugger.go
index d7c584eab..a7a286e23 100644
--- a/cmd/mist/debugger.go
+++ b/cmd/mist/debugger.go
@@ -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)
diff --git a/cmd/mist/gui.go b/cmd/mist/gui.go
index ba031e6c3..0339f601e 100644
--- a/cmd/mist/gui.go
+++ b/cmd/mist/gui.go
@@ -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")
diff --git a/core/block_manager.go b/core/block_manager.go
index cf47218ed..7cb9c4208 100644
--- a/core/block_manager.go
+++ b/core/block_manager.go
@@ -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
diff --git a/core/chain_manager.go b/core/chain_manager.go
index a4ff5cb5c..4bbecd109 100644
--- a/core/chain_manager.go
+++ b/core/chain_manager.go
@@ -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,14 +51,41 @@ type ChainManager struct {
eventMux *event.TypeMux
genesisBlock *types.Block
// Last known total difficulty
- TD *big.Int
+ mu sync.RWMutex
+ td *big.Int
+ lastBlockNumber uint64
+ currentBlock *types.Block
+ lastBlockHash []byte
- LastBlockNumber uint64
+ transState *state.StateDB
+}
- CurrentBlock *types.Block
- LastBlockHash []byte
+func (self *ChainManager) Td() *big.Int {
+ self.mu.RLock()
+ defer self.mu.RUnlock()
- transState *state.StateDB
+ 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 {
@@ -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()
+
+ chainlogger.Infof("exporting %v blocks...\n", self.currentBlock.Number)
- blocks := make(types.Blocks, int(self.CurrentBlock.Number.Int64())+1)
- for block := self.CurrentBlock; block != nil; block = self.GetBlock(block.PrevHash) {
+ 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)
diff --git a/core/chain_manager_test.go b/core/chain_manager_test.go
index a84e3ff3b..52be8b0ea 100644
--- a/core/chain_manager_test.go
+++ b/core/chain_manager_test.go
@@ -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())
}
diff --git a/core/filter.go b/core/filter.go
index fe3665bf3..fb992782d 100644
--- a/core/filter.go
+++ b/core/filter.go
@@ -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 (
diff --git a/core/filter_test.go b/core/filter_test.go
index d53b835b7..9a8bc9592 100644
--- a/core/filter_test.go
+++ b/core/filter_test.go
@@ -1,7 +1 @@
package core
-
-// import "testing"
-
-// func TestFilter(t *testing.T) {
-// NewFilter(NewTestManager())
-// }
diff --git a/core/transaction_pool.go b/core/transaction_pool.go
index 2eb0b55df..86286f23d 100644
--- a/core/transaction_pool.go
+++ b/core/transaction_pool.go
@@ -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
}
diff --git a/core/types/block.go b/core/types/block.go
index 0108bd586..2d889f35f 100644
--- a/core/types/block.go
+++ b/core/types/block.go
@@ -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
diff --git a/core/types/common.go b/core/types/common.go
index ba88b77e1..89cb5f498 100644
--- a/core/types/common.go
+++ b/core/types/common.go
@@ -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{})
+}
diff --git a/ethutil/rlp.go b/ethutil/rlp.go
index 157dd4dd9..1bc1a58a7 100644
--- a/ethutil/rlp.go
+++ b/ethutil/rlp.go
@@ -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)
}
diff --git a/ethutil/value.go b/ethutil/value.go
index 6417b0008..7d4a7d98c 100644
--- a/ethutil/value.go
+++ b/ethutil/value.go
@@ -397,5 +397,5 @@ func (it *ValueIterator) Value() *Value {
}
func (it *ValueIterator) Idx() int {
- return it.idx
+ return it.idx - 1
}
diff --git a/pow/ezp/pow.go b/pow/ezp/pow.go
index b4f863cb6..f669f8aa4 100644
--- a/pow/ezp/pow.go
+++ b/pow/ezp/pow.go
@@ -21,7 +21,7 @@ type EasyPow struct {
}
func New() *EasyPow {
- return &EasyPow{}
+ return &EasyPow{turbo: true}
}
func (pow *EasyPow) GetHashrate() int64 {
diff --git a/xeth/hexface.go b/xeth/hexface.go
index 524b68210..dfb0a9fd8 100644
--- a/xeth/hexface.go
+++ b/xeth/hexface.go
@@ -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)))
diff --git a/xeth/pipe.go b/xeth/pipe.go
index a8d8ed999..1e4d0ec60 100644
--- a/xeth/pipe.go
+++ b/xeth/pipe.go
@@ -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()