27 files changed, 2015 insertions, 1019 deletions

diff --git a/eth/backend.go b/eth/backend.go
index db8e8e029..065a4f7d8 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -36,6 +36,9 @@ type Config struct {
 	NATType    string
 	PMPGateway string
 
+	Shh  bool
+	Dial bool
+
 	KeyManager *crypto.KeyManager
 }
 
@@ -130,11 +133,13 @@ func New(config *Config) (*Ethereum, error) {
 	insertChain := eth.chainManager.InsertChain
 	eth.blockPool = NewBlockPool(hasBlock, insertChain, ezp.Verify)
 
-	// Start services
-	eth.txPool.Start()
-
 	ethProto := EthProtocol(eth.txPool, eth.chainManager, eth.blockPool)
-	protocols := []p2p.Protocol{ethProto, eth.whisper.Protocol()}
+	protocols := []p2p.Protocol{ethProto}
+
+	if config.Shh {
+		eth.whisper = whisper.New()
+		protocols = append(protocols, eth.whisper.Protocol())
+	}
 
 	nat, err := p2p.ParseNAT(config.NATType, config.PMPGateway)
 	if err != nil {
@@ -142,12 +147,16 @@ func New(config *Config) (*Ethereum, error) {
 	}
 
 	eth.net = &p2p.Server{
-		Identity:   clientId,
-		MaxPeers:   config.MaxPeers,
-		Protocols:  protocols,
-		ListenAddr: ":" + config.Port,
-		Blacklist:  eth.blacklist,
-		NAT:        nat,
+		Identity:  clientId,
+		MaxPeers:  config.MaxPeers,
+		Protocols: protocols,
+		Blacklist: eth.blacklist,
+		NAT:       nat,
+		NoDial:    !config.Dial,
+	}
+
+	if len(config.Port) > 0 {
+		eth.net.ListenAddr = ":" + config.Port
 	}
 
 	return eth, nil
@@ -219,8 +228,14 @@ func (s *Ethereum) Start(seed bool) error {
 	if err != nil {
 		return err
 	}
+
+	// Start services
+	s.txPool.Start()
 	s.blockPool.Start()
-	s.whisper.Start()
+
+	if s.whisper != nil {
+		s.whisper.Start()
+	}
 
 	// broadcast transactions
 	s.txSub = s.eventMux.Subscribe(core.TxPreEvent{})
@@ -268,7 +283,9 @@ func (s *Ethereum) Stop() {
 	s.txPool.Stop()
 	s.eventMux.Stop()
 	s.blockPool.Stop()
-	s.whisper.Stop()
+	if s.whisper != nil {
+		s.whisper.Stop()
+	}
 
 	logger.Infoln("Server stopped")
 	close(s.shutdownChan)
@@ -285,16 +302,16 @@ func (self *Ethereum) txBroadcastLoop() {
 	// automatically stops if unsubscribe
 	for obj := range self.txSub.Chan() {
 		event := obj.(core.TxPreEvent)
-		self.net.Broadcast("eth", TxMsg, []interface{}{event.Tx.RlpData()})
+		self.net.Broadcast("eth", TxMsg, event.Tx.RlpData())
 	}
 }
 
 func (self *Ethereum) blockBroadcastLoop() {
 	// automatically stops if unsubscribe
-	for obj := range self.txSub.Chan() {
+	for obj := range self.blockSub.Chan() {
 		switch ev := obj.(type) {
 		case core.NewMinedBlockEvent:
-			self.net.Broadcast("eth", NewBlockMsg, ev.Block.RlpData())
+			self.net.Broadcast("eth", NewBlockMsg, ev.Block.RlpData(), ev.Block.Td)
 		}
 	}
 }
diff --git a/eth/block_pool.go b/eth/block_pool.go
index 7cfbc63f8..519c9fc13 100644
--- a/eth/block_pool.go
+++ b/eth/block_pool.go
@@ -1,6 +1,7 @@
 package eth
 
 import (
+	"fmt"
 	"math"
 	"math/big"
 	"math/rand"
@@ -19,37 +20,45 @@ var poolLogger = ethlogger.NewLogger("Blockpool")
 const (
 	blockHashesBatchSize       = 256
 	blockBatchSize             = 64
-	blocksRequestInterval      = 10 // seconds
+	blocksRequestInterval      = 500 // ms
 	blocksRequestRepetition    = 1
-	blockHashesRequestInterval = 10 // seconds
-	blocksRequestMaxIdleRounds = 10
+	blockHashesRequestInterval = 500 // ms
+	blocksRequestMaxIdleRounds = 100
 	cacheTimeout               = 3 // minutes
 	blockTimeout               = 5 // minutes
 )
 
 type poolNode struct {
-	lock        sync.RWMutex
-	hash        []byte
-	block       *types.Block
-	child       *poolNode
-	parent      *poolNode
-	section     *section
-	knownParent bool
-	peer        string
-	source      string
-	complete    bool
+	lock    sync.RWMutex
+	hash    []byte
+	td      *big.Int
+	block   *types.Block
+	parent  *poolNode
+	peer    string
+	blockBy string
+}
+
+type poolEntry struct {
+	node    *poolNode
+	section *section
+	index   int
 }
 
 type BlockPool struct {
-	lock sync.RWMutex
-	pool map[string]*poolNode
+	lock      sync.RWMutex
+	chainLock sync.RWMutex
+
+	pool map[string]*poolEntry
 
 	peersLock sync.RWMutex
 	peers     map[string]*peerInfo
 	peer      *peerInfo
 
 	quit    chan bool
+	purgeC  chan bool
+	flushC  chan bool
 	wg      sync.WaitGroup
+	procWg  sync.WaitGroup
 	running bool
 
 	// the minimal interface with blockchain
@@ -70,8 +79,23 @@ type peerInfo struct {
 	peerError          func(int, string, ...interface{})
 
 	sections map[string]*section
-	roots    []*poolNode
-	quitC    chan bool
+
+	quitC chan bool
+}
+
+// structure to store long range links on chain to skip along
+type section struct {
+	lock        sync.RWMutex
+	parent      *section
+	child       *section
+	top         *poolNode
+	bottom      *poolNode
+	nodes       []*poolNode
+	controlC    chan *peerInfo
+	suicideC    chan bool
+	blockChainC chan bool
+	forkC       chan chan bool
+	offC        chan bool
 }
 
 func NewBlockPool(hasBlock func(hash []byte) bool, insertChain func(types.Blocks) error, verifyPoW func(pow.Block) bool,
@@ -92,7 +116,9 @@ func (self *BlockPool) Start() {
 	}
 	self.running = true
 	self.quit = make(chan bool)
-	self.pool = make(map[string]*poolNode)
+	self.flushC = make(chan bool)
+	self.pool = make(map[string]*poolEntry)
+
 	self.lock.Unlock()
 
 	self.peersLock.Lock()
@@ -110,50 +136,116 @@ func (self *BlockPool) Stop() {
 		return
 	}
 	self.running = false
+
 	self.lock.Unlock()
 
-	poolLogger.Infoln("Stopping")
+	poolLogger.Infoln("Stopping...")
 
 	close(self.quit)
-	self.lock.Lock()
+	self.wg.Wait()
+
 	self.peersLock.Lock()
 	self.peers = nil
-	self.pool = nil
 	self.peer = nil
-	self.wg.Wait()
-	self.lock.Unlock()
 	self.peersLock.Unlock()
+
+	self.lock.Lock()
+	self.pool = nil
+	self.lock.Unlock()
+
+	poolLogger.Infoln("Stopped")
+}
+
+func (self *BlockPool) Purge() {
+	self.lock.Lock()
+	if !self.running {
+		self.lock.Unlock()
+		return
+	}
+	self.lock.Unlock()
+
+	poolLogger.Infoln("Purging...")
+
+	close(self.purgeC)
+	self.wg.Wait()
+
+	self.purgeC = make(chan bool)
+
 	poolLogger.Infoln("Stopped")
 
 }
 
+func (self *BlockPool) Wait(t time.Duration) {
+	self.lock.Lock()
+	if !self.running {
+		self.lock.Unlock()
+		return
+	}
+	self.lock.Unlock()
+
+	poolLogger.Infoln("Waiting for processes to complete...")
+	close(self.flushC)
+	w := make(chan bool)
+	go func() {
+		self.procWg.Wait()
+		close(w)
+	}()
+
+	select {
+	case <-w:
+		poolLogger.Infoln("Processes complete")
+	case <-time.After(t):
+		poolLogger.Warnf("Timeout")
+	}
+	self.flushC = make(chan bool)
+}
+
 // AddPeer is called by the eth protocol instance running on the peer after
 // the status message has been received with total difficulty and current block hash
 // AddPeer can only be used once, RemovePeer needs to be called when the peer disconnects
 func (self *BlockPool) AddPeer(td *big.Int, currentBlock []byte, peerId string, requestBlockHashes func([]byte) error, requestBlocks func([][]byte) error, peerError func(int, string, ...interface{})) bool {
+
 	self.peersLock.Lock()
 	defer self.peersLock.Unlock()
-	if self.peers[peerId] != nil {
-		panic("peer already added")
-	}
-	peer := &peerInfo{
-		td:                 td,
-		currentBlock:       currentBlock,
-		id:                 peerId, //peer.Identity().Pubkey()
-		requestBlockHashes: requestBlockHashes,
-		requestBlocks:      requestBlocks,
-		peerError:          peerError,
-	}
-	self.peers[peerId] = peer
-	poolLogger.Debugf("add new peer %v with td %v", peerId, td)
+	peer, ok := self.peers[peerId]
+	if ok {
+		poolLogger.Debugf("Update peer %v with td %v and current block %x", peerId, td, currentBlock[:4])
+		peer.td = td
+		peer.currentBlock = currentBlock
+	} else {
+		peer = &peerInfo{
+			td:                 td,
+			currentBlock:       currentBlock,
+			id:                 peerId, //peer.Identity().Pubkey()
+			requestBlockHashes: requestBlockHashes,
+			requestBlocks:      requestBlocks,
+			peerError:          peerError,
+			sections:           make(map[string]*section),
+		}
+		self.peers[peerId] = peer
+		poolLogger.Debugf("add new peer %v with td %v and current block %x", peerId, td, currentBlock[:4])
+	}
+	// check peer current head
+	if self.hasBlock(currentBlock) {
+		// peer not ahead
+		return false
+	}
+
+	if self.peer == peer {
+		// new block update
+		// peer is already active best peer, request hashes
+		poolLogger.Debugf("[%s] already the best peer. request hashes from %s", peerId, name(currentBlock))
+		peer.requestBlockHashes(currentBlock)
+		return true
+	}
+
 	currentTD := ethutil.Big0
 	if self.peer != nil {
 		currentTD = self.peer.td
 	}
 	if td.Cmp(currentTD) > 0 {
-		self.peer.stop(peer)
-		peer.start(self.peer)
-		poolLogger.Debugf("peer %v promoted to best peer", peerId)
+		poolLogger.Debugf("peer %v promoted best peer", peerId)
+		self.switchPeer(self.peer, peer)
 		self.peer = peer
 		return true
 	}
@@ -164,15 +256,15 @@ func (self *BlockPool) AddPeer(td *big.Int, currentBlock []byte, peerId string,
 func (self *BlockPool) RemovePeer(peerId string) {
 	self.peersLock.Lock()
 	defer self.peersLock.Unlock()
-	peer := self.peers[peerId]
-	if peer == nil {
+	peer, ok := self.peers[peerId]
+	if !ok {
 		return
 	}
-	self.peers[peerId] = nil
-	poolLogger.Debugf("remove peer %v", peerId[0:4])
+	delete(self.peers, peerId)
+	poolLogger.Debugf("remove peer %v", peerId)
 
 	// if current best peer is removed, need find a better one
-	if self.peer != nil && peerId == self.peer.id {
+	if self.peer == peer {
 		var newPeer *peerInfo
 		max := ethutil.Big0
 		// peer with the highest self-acclaimed TD is chosen
@@ -182,12 +274,12 @@ func (self *BlockPool) RemovePeer(peerId string) {
 				newPeer = info
 			}
 		}
-		self.peer.stop(peer)
-		peer.start(self.peer)
+		self.peer = newPeer
+		self.switchPeer(peer, newPeer)
 		if newPeer != nil {
-			poolLogger.Debugf("peer %v with td %v promoted to best peer", newPeer.id[0:4], newPeer.td)
+			poolLogger.Debugf("peer %v with td %v promoted to best peer", newPeer.id, newPeer.td)
 		} else {
-			poolLogger.Warnln("no peers left")
+			poolLogger.Warnln("no peers")
 		}
 	}
 }
@@ -200,97 +292,132 @@ func (self *BlockPool) RemovePeer(peerId string) {
 // this function needs to run asynchronously for one peer since the message is discarded???
 func (self *BlockPool) AddBlockHashes(next func() ([]byte, bool), peerId string) {
 
-	// check if this peer is the best
+	// register with peer manager loop
+
 	peer, best := self.getPeer(peerId)
 	if !best {
 		return
 	}
 	// peer is still the best
+	poolLogger.Debugf("adding hashes for best peer %s", peerId)
 
-	var child *poolNode
-	var depth int
+	var size, n int
+	var hash []byte
+	var ok bool
+	var section, child, parent *section
+	var entry *poolEntry
+	var nodes []*poolNode
 
+LOOP:
 	// iterate using next (rlp stream lazy decoder) feeding hashesC
-	self.wg.Add(1)
-	go func() {
-		for {
-			select {
-			case <-self.quit:
-				return
-			case <-peer.quitC:
-				// if the peer is demoted, no more hashes taken
-				break
-			default:
-				hash, ok := next()
-				if !ok {
-					// message consumed chain skeleton built
-					break
-				}
-				// check if known block connecting the downloaded chain to our blockchain
-				if self.hasBlock(hash) {
-					poolLogger.Infof("known block (%x...)\n", hash[0:4])
-					if child != nil {
-						child.Lock()
-						// mark child as absolute pool root with parent known to blockchain
-						child.knownParent = true
-						child.Unlock()
-					}
-					break
-				}
-				//
-				var parent *poolNode
-				// look up node in pool
-				parent = self.get(hash)
-				if parent != nil {
-					// reached a known chain in the pool
-					// request blocks on the newly added part of the chain
-					if child != nil {
-						self.link(parent, child)
-
-						// activate the current chain
-						self.activateChain(parent, peer, true)
-						poolLogger.Debugf("potential chain of %v blocks added, reached blockpool, activate chain", depth)
-						break
-					}
-					// if this is the first hash, we expect to find it
-					parent.RLock()
-					grandParent := parent.parent
-					parent.RUnlock()
-					if grandParent != nil {
-						// activate the current chain
-						self.activateChain(parent, peer, true)
-						poolLogger.Debugf("block hash found, activate chain")
-						break
-					}
-					// the first node is the root of a chain in the pool, rejoice and continue
-				}
-				// if node does not exist, create it and index in the pool
-				section := &section{}
-				if child == nil {
-					section.top = parent
-				}
-				parent = &poolNode{
-					hash:    hash,
-					child:   child,
-					section: section,
-					peer:    peerId,
+	for hash, ok = next(); ok; hash, ok = next() {
+		n++
+		select {
+		case <-self.quit:
+			return
+		case <-peer.quitC:
+			// if the peer is demoted, no more hashes taken
+			peer = nil
+			break LOOP
+		default:
+		}
+		if self.hasBlock(hash) {
+			// check if known block connecting the downloaded chain to our blockchain
+			poolLogger.DebugDetailf("[%s] known block", name(hash))
+			// mark child as absolute pool root with parent known to blockchain
+			if section != nil {
+				self.connectToBlockChain(section)
+			} else {
+				if child != nil {
+					self.connectToBlockChain(child)
 				}
-				self.set(hash, parent)
-				poolLogger.Debugf("create potential block for %x...", hash[0:4])
-
-				depth++
-				child = parent
 			}
+			break LOOP
 		}
-		if child != nil {
-			poolLogger.Debugf("chain of %v hashes added", depth)
-			// start a processSection on the last node, but switch off asking
-			// hashes and blocks until next peer confirms this chain
-			section := self.processSection(child)
-			peer.addSection(child.hash, section)
-			section.start()
+		// look up node in pool
+		entry = self.get(hash)
+		if entry != nil {
+			// reached a known chain in the pool
+			if entry.node == entry.section.bottom && n == 1 {
+				// the first block hash received is an orphan in the pool, so rejoice and continue
+				child = entry.section
+				continue LOOP
+			}
+			poolLogger.DebugDetailf("[%s] reached blockpool chain", name(hash))
+			parent = entry.section
+			break LOOP
 		}
-	}()
+		// if node for block hash does not exist, create it and index in the pool
+		node := &poolNode{
+			hash: hash,
+			peer: peerId,
+		}
+		if size == 0 {
+			section = newSection()
+		}
+		nodes = append(nodes, node)
+		size++
+	} //for
+
+	self.chainLock.Lock()
+
+	poolLogger.DebugDetailf("added %v hashes sent by %s", n, peerId)
+
+	if parent != nil && entry != nil && entry.node != parent.top {
+		poolLogger.DebugDetailf("[%s] split section at fork", sectionName(parent))
+		parent.controlC <- nil
+		waiter := make(chan bool)
+		parent.forkC <- waiter
+		chain := parent.nodes
+		parent.nodes = chain[entry.index:]
+		parent.top = parent.nodes[0]
+		orphan := newSection()
+		self.link(orphan, parent.child)
+		self.processSection(orphan, chain[0:entry.index])
+		orphan.controlC <- nil
+		close(waiter)
+	}
+
+	if size > 0 {
+		self.processSection(section, nodes)
+		poolLogger.DebugDetailf("[%s]->[%s](%v)->[%s] new chain section", sectionName(parent), sectionName(section), size, sectionName(child))
+		self.link(parent, section)
+		self.link(section, child)
+	} else {
+		poolLogger.DebugDetailf("[%s]->[%s] connecting known sections", sectionName(parent), sectionName(child))
+		self.link(parent, child)
+	}
+
+	self.chainLock.Unlock()
+
+	if parent != nil && peer != nil {
+		self.activateChain(parent, peer)
+		poolLogger.Debugf("[%s] activate parent section [%s]", name(parent.top.hash), sectionName(parent))
+	}
+
+	if section != nil {
+		peer.addSection(section.top.hash, section)
+		section.controlC <- peer
+		poolLogger.Debugf("[%s] activate new section", sectionName(section))
+	}
+}
+
+func name(hash []byte) (name string) {
+	if hash == nil {
+		name = ""
+	} else {
+		name = fmt.Sprintf("%x", hash[:4])
+	}
+	return
+}
+
+func sectionName(section *section) (name string) {
+	if section == nil {
+		name = ""
+	} else {
+		name = fmt.Sprintf("%x-%x", section.bottom.hash[:4], section.top.hash[:4])
+	}
+	return
 }
 
 // AddBlock is the entry point for the eth protocol when blockmsg is received upon requests
@@ -299,67 +426,114 @@ func (self *BlockPool) AddBlockHashes(next func() ([]byte, bool), peerId string)
 // only the first PoW-valid block for a hash is considered legit
 func (self *BlockPool) AddBlock(block *types.Block, peerId string) {
 	hash := block.Hash()
-	node := self.get(hash)
-	node.RLock()
-	b := node.block
-	node.RUnlock()
-	if b != nil {
+	if self.hasBlock(hash) {
+		poolLogger.DebugDetailf("block [%s] already known", name(hash))
 		return
 	}
-	if node == nil && !self.hasBlock(hash) {
+	entry := self.get(hash)
+	if entry == nil {
+		poolLogger.Warnf("unrequested block [%x] by peer %s", hash, peerId)
 		self.peerError(peerId, ErrUnrequestedBlock, "%x", hash)
 		return
 	}
+
+	node := entry.node
+	node.lock.Lock()
+	defer node.lock.Unlock()
+
+	// check if block already present
+	if node.block != nil {
+		poolLogger.DebugDetailf("block [%x] already sent by %s", name(hash), node.blockBy)
+		return
+	}
+
 	// validate block for PoW
 	if !self.verifyPoW(block) {
+		poolLogger.Warnf("invalid pow on block [%x] by peer %s", hash, peerId)
 		self.peerError(peerId, ErrInvalidPoW, "%x", hash)
+		return
 	}
-	node.Lock()
+
+	poolLogger.Debugf("added block [%s] sent by peer %s", name(hash), peerId)
 	node.block = block
-	node.source = peerId
-	node.Unlock()
+	node.blockBy = peerId
+
 }
 
-// iterates down a known poolchain and activates fetching processes
-// on each chain section for the peer
-// stops if the peer is demoted
-// registers last section root as root for the peer (in case peer is promoted a second time, to remember)
-func (self *BlockPool) activateChain(node *poolNode, peer *peerInfo, on bool) {
-	self.wg.Add(1)
-	go func() {
-		for {
-			node.sectionRLock()
-			bottom := node.section.bottom
-			if bottom == nil { // the chain section is being created or killed
-				break
-			}
-			// register this section with the peer
-			if peer != nil {
-				peer.addSection(bottom.hash, bottom.section)
-				if on {
-					bottom.section.start()
-				} else {
-					bottom.section.start()
-				}
-			}
-			if bottom.parent == nil {
-				node = bottom
-				break
-			}
-			// if peer demoted stop activation
-			select {
-			case <-peer.quitC:
-				break
-			default:
-			}
+func (self *BlockPool) connectToBlockChain(section *section) {
+	select {
+	case <-section.offC:
+		self.addSectionToBlockChain(section)
+	case <-section.blockChainC:
+	default:
+		close(section.blockChainC)
+	}
+}
 
-			node = bottom.parent
-			bottom.sectionRUnlock()
+func (self *BlockPool) addSectionToBlockChain(section *section) (rest int, err error) {
+
+	var blocks types.Blocks
+	var node *poolNode
+	var keys []string
+	rest = len(section.nodes)
+	for rest > 0 {
+		rest--
+		node = section.nodes[rest]
+		node.lock.RLock()
+		block := node.block
+		node.lock.RUnlock()
+		if block == nil {
+			break
 		}
-		// remember root for this peer
-		peer.addRoot(node)
-		self.wg.Done()
-	}()
+		keys = append(keys, string(node.hash))
+		blocks = append(blocks, block)
+	}
+
+	self.lock.Lock()
+	for _, key := range keys {
+		delete(self.pool, key)
+	}
+	self.lock.Unlock()
+
+	poolLogger.Infof("insert %v blocks into blockchain", len(blocks))
+	err = self.insertChain(blocks)
+	if err != nil {
+		// TODO: not clear which peer we need to address
+		// peerError should dispatch to peer if still connected and disconnect
+		self.peerError(node.blockBy, ErrInvalidBlock, "%v", err)
+		poolLogger.Warnf("invalid block %x", node.hash)
+		poolLogger.Warnf("penalise peers %v (hash), %v (block)", node.peer, node.blockBy)
+		// penalise peer in node.blockBy
+		// self.disconnect()
+	}
+	return
+}
+
+func (self *BlockPool) activateChain(section *section, peer *peerInfo) {
+	poolLogger.DebugDetailf("[%s] activate known chain for peer %s", sectionName(section), peer.id)
+	i := 0
+LOOP:
+	for section != nil {
+		// register this section with the peer and quit if registered
+		poolLogger.DebugDetailf("[%s] register section with peer %s", sectionName(section), peer.id)
+		if peer.addSection(section.top.hash, section) == section {
+			return
+		}
+		poolLogger.DebugDetailf("[%s] activate section process", sectionName(section))
+		select {
+		case section.controlC <- peer:
+		case <-section.offC:
+		}
+		i++
+		section = self.getParent(section)
+		select {
+		case <-peer.quitC:
+			break LOOP
+		case <-self.quit:
+			break LOOP
+		default:
+		}
+	}
 }
 
 // main worker thread on each section in the poolchain
@@ -370,261 +544,315 @@ func (self *BlockPool) activateChain(node *poolNode, peer *peerInfo, on bool) {
 // - when turned off (if peer disconnects and new peer connects with alternative chain), no blockrequests are made but absolute expiry timer is ticking
 // - when turned back on it recursively calls itself on the root of the next chain section
 // - when exits, signals to
-func (self *BlockPool) processSection(node *poolNode) *section {
-	// absolute time after which sub-chain is killed if not complete (some blocks are missing)
-	suicideTimer := time.After(blockTimeout * time.Minute)
-	var blocksRequestTimer, blockHashesRequestTimer <-chan time.Time
-	var nodeC, missingC, processC chan *poolNode
-	controlC := make(chan bool)
-	resetC := make(chan bool)
-	var hashes [][]byte
-	var i, total, missing, lastMissing, depth int
-	var blockHashesRequests, blocksRequests int
-	var idle int
-	var init, alarm, done, same, running, once bool
-	orignode := node
-	hash := node.hash
-
-	node.sectionLock()
-	defer node.sectionUnlock()
-	section := &section{controlC: controlC, resetC: resetC}
-	node.section = section
+func (self *BlockPool) processSection(section *section, nodes []*poolNode) {
+
+	for i, node := range nodes {
+		entry := &poolEntry{node: node, section: section, index: i}
+		self.set(node.hash, entry)
+	}
 
+	section.bottom = nodes[len(nodes)-1]
+	section.top = nodes[0]
+	section.nodes = nodes
+	poolLogger.DebugDetailf("[%s] setup section process", sectionName(section))
+
+	self.wg.Add(1)
 	go func() {
-		self.wg.Add(1)
+
+		// absolute time after which sub-chain is killed if not complete (some blocks are missing)
+		suicideTimer := time.After(blockTimeout * time.Minute)
+
+		var peer, newPeer *peerInfo
+
+		var blocksRequestTimer, blockHashesRequestTimer <-chan time.Time
+		var blocksRequestTime, blockHashesRequestTime bool
+		var blocksRequests, blockHashesRequests int
+		var blocksRequestsComplete, blockHashesRequestsComplete bool
+
+		// node channels for the section
+		var missingC, processC, offC chan *poolNode
+		// container for missing block hashes
+		var hashes [][]byte
+
+		var i, missing, lastMissing, depth int
+		var idle int
+		var init, done, same, ready bool
+		var insertChain bool
+		var quitC chan bool
+
+		var blockChainC = section.blockChainC
+
+	LOOP:
 		for {
-			node.sectionRLock()
-			controlC = node.section.controlC
-			node.sectionRUnlock()
-
-			if init {
-				// missing blocks read from nodeC
-				// initialized section
-				if depth == 0 {
-					break
+
+			if insertChain {
+				insertChain = false
+				rest, err := self.addSectionToBlockChain(section)
+				if err != nil {
+					close(section.suicideC)
+					continue LOOP
 				}
-				// enable select case to read missing block when ready
-				processC = missingC
-				missingC = make(chan *poolNode, lastMissing)
-				nodeC = nil
-				// only do once
-				init = false
-			} else {
-				if !once {
-					missingC = nil
-					processC = nil
-					i = 0
-					total = 0
-					lastMissing = 0
+				if rest == 0 {
+					blocksRequestsComplete = true
+					child := self.getChild(section)
+					if child != nil {
+						self.connectToBlockChain(child)
+					}
 				}
 			}
 
-			// went through all blocks in section
-			if i != 0 && i == lastMissing {
-				if len(hashes) > 0 {
-					// send block requests to peers
-					self.requestBlocks(blocksRequests, hashes)
-				}
-				blocksRequests++
-				poolLogger.Debugf("[%x] block request attempt %v: missing %v/%v/%v", hash[0:4], blocksRequests, missing, total, depth)
-				if missing == lastMissing {
-					// idle round
-					if same {
-						// more than once
-						idle++
-						// too many idle rounds
-						if idle > blocksRequestMaxIdleRounds {
-							poolLogger.Debugf("[%x] block requests had %v idle rounds (%v total attempts): missing %v/%v/%v\ngiving up...", hash[0:4], idle, blocksRequests, missing, total, depth)
-							self.killChain(node, nil)
-							break
+			if blockHashesRequestsComplete && blocksRequestsComplete {
+				// not waiting for hashes any more
+				poolLogger.Debugf("[%s] section complete %v blocks retrieved (%v attempts), hash requests complete on root (%v attempts)", sectionName(section), depth, blocksRequests, blockHashesRequests)
+				break LOOP
+			} // otherwise suicide if no hashes coming
+
+			if done {
+				// went through all blocks in section
+				if missing == 0 {
+					// no missing blocks
+					poolLogger.DebugDetailf("[%s] got all blocks. process complete (%v total blocksRequests): missing %v/%v/%v", sectionName(section), blocksRequests, missing, lastMissing, depth)
+					blocksRequestsComplete = true
+					blocksRequestTimer = nil
+					blocksRequestTime = false
+				} else {
+					// some missing blocks
+					blocksRequests++
+					if len(hashes) > 0 {
+						// send block requests to peers
+						self.requestBlocks(blocksRequests, hashes)
+						hashes = nil
+					}
+					if missing == lastMissing {
+						// idle round
+						if same {
+							// more than once
+							idle++
+							// too many idle rounds
+							if idle >= blocksRequestMaxIdleRounds {
+								poolLogger.DebugDetailf("[%s] block requests had %v idle rounds (%v total attempts): missing %v/%v/%v\ngiving up...", sectionName(section), idle, blocksRequests, missing, lastMissing, depth)
+								close(section.suicideC)
+							}
+						} else {
+							idle = 0
 						}
+						same = true
 					} else {
-						idle = 0
+						same = false
 					}
-					same = true
-				} else {
-					if missing == 0 {
-						// no missing nodes
-						poolLogger.Debugf("block request process complete on section %x... (%v total blocksRequests): missing %v/%v/%v", hash[0:4], blockHashesRequests, blocksRequests, missing, total, depth)
-						node.Lock()
-						orignode.complete = true
-						node.Unlock()
-						blocksRequestTimer = nil
-						if blockHashesRequestTimer == nil {
-							// not waiting for hashes any more
-							poolLogger.Debugf("hash request on root %x... successful (%v total attempts)\nquitting...", hash[0:4], blockHashesRequests)
-							break
-						} // otherwise suicide if no hashes coming
-					}
-					same = false
 				}
 				lastMissing = missing
-				i = 0
-				missing = 0
-				// ready for next round
-				done = true
-			}
-			if done && alarm {
-				poolLogger.Debugf("start checking if new blocks arrived (attempt %v): missing %v/%v/%v", blocksRequests, missing, total, depth)
-				blocksRequestTimer = time.After(blocksRequestInterval * time.Second)
-				alarm = false
+				ready = true
 				done = false
-				// processC supposed to be empty and never closed so just swap,  no need to allocate
-				tempC := processC
-				processC = missingC
-				missingC = tempC
+				// save a new processC (blocks still missing)
+				offC = missingC
+				missingC = processC
+				// put processC offline
+				processC = nil
 			}
-			select {
-			case <-self.quit:
-				break
-			case <-suicideTimer:
-				self.killChain(node, nil)
-				poolLogger.Warnf("[%x] timeout. (%v total attempts): missing %v/%v/%v", hash[0:4], blocksRequests, missing, total, depth)
-				break
-			case <-blocksRequestTimer:
-				alarm = true
-			case <-blockHashesRequestTimer:
-				orignode.RLock()
-				parent := orignode.parent
-				orignode.RUnlock()
-				if parent != nil {
+			//
+
+			if ready && blocksRequestTime && !blocksRequestsComplete {
+				poolLogger.DebugDetailf("[%s] check if new blocks arrived (attempt %v): missing %v/%v/%v", sectionName(section), blocksRequests, missing, lastMissing, depth)
+				blocksRequestTimer = time.After(blocksRequestInterval * time.Millisecond)
+				blocksRequestTime = false
+				processC = offC
+			}
+
+			if blockHashesRequestTime {
+				if self.getParent(section) != nil {
 					// if not root of chain, switch off
-					poolLogger.Debugf("[%x] parent found, hash requests deactivated (after %v total attempts)\n", hash[0:4], blockHashesRequests)
+					poolLogger.DebugDetailf("[%s] parent found, hash requests deactivated (after %v total attempts)\n", sectionName(section), blockHashesRequests)
 					blockHashesRequestTimer = nil
+					blockHashesRequestsComplete = true
 				} else {
 					blockHashesRequests++
-					poolLogger.Debugf("[%x] hash request on root (%v total attempts)\n", hash[0:4], blockHashesRequests)
-					self.requestBlockHashes(parent.hash)
-					blockHashesRequestTimer = time.After(blockHashesRequestInterval * time.Second)
+					poolLogger.Debugf("[%s] hash request on root (%v total attempts)\n", sectionName(section), blockHashesRequests)
+					peer.requestBlockHashes(section.bottom.hash)
+					blockHashesRequestTimer = time.After(blockHashesRequestInterval * time.Millisecond)
 				}
-			case r, ok := <-controlC:
-				if !ok {
-					break
+				blockHashesRequestTime = false
+			}
+
+			select {
+			case <-self.quit:
+				break LOOP
+
+			case <-quitC:
+				// peer quit or demoted, put section in idle mode
+				quitC = nil
+				go func() {
+					section.controlC <- nil
+				}()
+
+			case <-self.purgeC:
+				suicideTimer = time.After(0)
+
+			case <-suicideTimer:
+				close(section.suicideC)
+				poolLogger.Debugf("[%s] timeout. (%v total attempts): missing %v/%v/%v", sectionName(section), blocksRequests, missing, lastMissing, depth)
+
+			case <-section.suicideC:
+				poolLogger.Debugf("[%s] suicide", sectionName(section))
+
+				// first delink from child and parent under chainlock
+				self.chainLock.Lock()
+				self.link(nil, section)
+				self.link(section, nil)
+				self.chainLock.Unlock()
+				// delete node entries from pool index under pool lock
+				self.lock.Lock()
+				for _, node := range section.nodes {
+					delete(self.pool, string(node.hash))
 				}
-				if running && !r {
-					poolLogger.Debugf("process on section %x... (%v total attempts): missing %v/%v/%v", hash[0:4], blocksRequests, missing, total, depth)
+				self.lock.Unlock()
+
+				break LOOP
+
+			case <-blocksRequestTimer:
+				poolLogger.DebugDetailf("[%s] block request time", sectionName(section))
+				blocksRequestTime = true
+
+			case <-blockHashesRequestTimer:
+				poolLogger.DebugDetailf("[%s] hash request time", sectionName(section))
+				blockHashesRequestTime = true
+
+			case newPeer = <-section.controlC:
 
-					alarm = false
+				// active -> idle
+				if peer != nil && newPeer == nil {
+					self.procWg.Done()
+					if init {
+						poolLogger.Debugf("[%s] idle mode (%v total attempts): missing %v/%v/%v", sectionName(section), blocksRequests, missing, lastMissing, depth)
+					}
+					blocksRequestTime = false
 					blocksRequestTimer = nil
+					blockHashesRequestTime = false
 					blockHashesRequestTimer = nil
-					processC = nil
+					if processC != nil {
+						offC = processC
+						processC = nil
+					}
 				}
-				if !running && r {
-					poolLogger.Debugf("[%x] on", hash[0:4])
-
-					orignode.RLock()
-					parent := orignode.parent
-					complete := orignode.complete
-					knownParent := orignode.knownParent
-					orignode.RUnlock()
-					if !complete {
-						poolLogger.Debugf("[%x] activate block requests", hash[0:4])
-						blocksRequestTimer = time.After(0)
+
+				// idle -> active
+				if peer == nil && newPeer != nil {
+					self.procWg.Add(1)
+
+					poolLogger.Debugf("[%s] active mode", sectionName(section))
+					if !blocksRequestsComplete {
+						blocksRequestTime = true
 					}
-					if parent == nil && !knownParent {
-						// if no parent but not connected to blockchain
-						poolLogger.Debugf("[%x] activate block hashes requests", hash[0:4])
-						blockHashesRequestTimer = time.After(0)
-					} else {
-						blockHashesRequestTimer = nil
+					if !blockHashesRequestsComplete {
+						blockHashesRequestTime = true
 					}
-					alarm = true
-					processC = missingC
-					if !once {
+					if !init {
+						processC = make(chan *poolNode, blockHashesBatchSize)
+						missingC = make(chan *poolNode, blockHashesBatchSize)
+						i = 0
+						missing = 0
+						self.wg.Add(1)
+						self.procWg.Add(1)
+						depth = len(section.nodes)
+						lastMissing = depth
 						// if not run at least once fully, launch iterator
-						processC = make(chan *poolNode)
-						missingC = make(chan *poolNode)
-						self.foldUp(orignode, processC)
-						once = true
+						go func() {
+							var node *poolNode
+						IT:
+							for _, node = range section.nodes {
+								select {
+								case processC <- node:
+								case <-self.quit:
+									break IT
+								}
+							}
+							close(processC)
+							self.wg.Done()
+							self.procWg.Done()
+						}()
+					} else {
+						poolLogger.Debugf("[%s] restore earlier state", sectionName(section))
+						processC = offC
 					}
 				}
-				total = lastMissing
-			case <-resetC:
-				once = false
+				// reset quitC to current best peer
+				if newPeer != nil {
+					quitC = newPeer.quitC
+				}
+				peer = newPeer
+
+			case waiter := <-section.forkC:
+				// this case just blocks the process until section is split at the fork
+				<-waiter
 				init = false
 				done = false
+				ready = false
+
 			case node, ok := <-processC:
-				if !ok {
+				if !ok && !init {
 					// channel closed, first iteration finished
 					init = true
-					once = true
-					continue
+					done = true
+					processC = make(chan *poolNode, missing)
+					poolLogger.DebugDetailf("[%s] section initalised: missing %v/%v/%v", sectionName(section), missing, lastMissing, depth)
+					continue LOOP
+				}
+				if ready {
+					i = 0
+					missing = 0
+					ready = false
 				}
 				i++
 				// if node has no block
-				node.RLock()
+				node.lock.RLock()
 				block := node.block
-				nhash := node.hash
-				knownParent := node.knownParent
-				node.RUnlock()
-				if !init {
-					depth++
-				}
+				node.lock.RUnlock()
 				if block == nil {
 					missing++
-					if !init {
-						total++
-					}
-					hashes = append(hashes, nhash)
+					hashes = append(hashes, node.hash)
 					if len(hashes) == blockBatchSize {
+						poolLogger.Debugf("[%s] request %v missing blocks", sectionName(section), len(hashes))
 						self.requestBlocks(blocksRequests, hashes)
 						hashes = nil
 					}
 					missingC <- node
 				} else {
-					// block is found
-					if knownParent {
-						// connected to the blockchain, insert the longest chain of blocks
-						var blocks types.Blocks
-						child := node
-						parent := node
-						node.sectionRLock()
-						for child != nil && child.block != nil {
-							parent = child
-							blocks = append(blocks, parent.block)
-							child = parent.child
-						}
-						node.sectionRUnlock()
-						poolLogger.Debugf("[%x] insert %v blocks into blockchain", hash[0:4], len(blocks))
-						if err := self.insertChain(blocks); err != nil {
-							// TODO: not clear which peer we need to address
-							// peerError should dispatch to peer if still connected and disconnect
-							self.peerError(node.source, ErrInvalidBlock, "%v", err)
-							poolLogger.Debugf("invalid block %v", node.hash)
-							poolLogger.Debugf("penalise peers %v (hash), %v (block)", node.peer, node.source)
-							// penalise peer in node.source
-							self.killChain(node, nil)
-							// self.disconnect()
-							break
-						}
-						// if suceeded mark the next one (no block yet) as connected to blockchain
-						if child != nil {
-							child.Lock()
-							child.knownParent = true
-							child.Unlock()
-						}
-						// reset starting node to first node with missing block
-						orignode = child
-						// pop the inserted ancestors off the channel
-						for i := 1; i < len(blocks); i++ {
-							<-processC
-						}
-						// delink inserted chain section
-						self.killChain(node, parent)
+					if blockChainC == nil && i == lastMissing {
+						insertChain = true
 					}
 				}
-			}
-		}
-		poolLogger.Debugf("[%x] quit after\n%v block hashes requests\n%v block requests: missing %v/%v/%v", hash[0:4], blockHashesRequests, blocksRequests, missing, total, depth)
+				poolLogger.Debugf("[%s] %v/%v/%v/%v", sectionName(section), i, missing, lastMissing, depth)
+				if i == lastMissing && init {
+					done = true
+				}
+
+			case <-blockChainC:
+				// closed blockChain channel indicates that the blockpool is reached
+				// connected to the blockchain, insert the longest chain of blocks
+				poolLogger.Debugf("[%s] reached blockchain", sectionName(section))
+				blockChainC = nil
+				// switch off hash requests in case they were on
+				blockHashesRequestTime = false
+				blockHashesRequestTimer = nil
+				blockHashesRequestsComplete = true
+				// section root has block
+				if len(section.nodes) > 0 && section.nodes[len(section.nodes)-1].block != nil {
+					insertChain = true
+				}
+				continue LOOP
+
+			} // select
+		} // for
+		poolLogger.Debugf("[%s] section complete: %v block hashes requests - %v block requests - missing %v/%v/%v", sectionName(section), blockHashesRequests, blocksRequests, missing, lastMissing, depth)
+
+		close(section.offC)
 
 		self.wg.Done()
-		node.sectionLock()
-		node.section.controlC = nil
-		node.sectionUnlock()
-		// this signals that controller not available
+		if peer != nil {
+			self.procWg.Done()
+		}
 	}()
-	return section
-
+	return
 }
 
 func (self *BlockPool) peerError(peerId string, code int, format string, params ...interface{}) {
@@ -636,39 +864,39 @@ func (self *BlockPool) peerError(peerId string, code int, format string, params
 	}
 }
 
-func (self *BlockPool) requestBlockHashes(hash []byte) {
-	self.peersLock.Lock()
-	defer self.peersLock.Unlock()
-	if self.peer != nil {
-		self.peer.requestBlockHashes(hash)
-	}
-}
-
 func (self *BlockPool) requestBlocks(attempts int, hashes [][]byte) {
-	// distribute block request among known peers
-	self.peersLock.Lock()
-	defer self.peersLock.Unlock()
-	peerCount := len(self.peers)
-	// on first attempt use the best peer
-	if attempts == 0 {
-		self.peer.requestBlocks(hashes)
-		return
-	}
-	repetitions := int(math.Min(float64(peerCount), float64(blocksRequestRepetition)))
-	poolLogger.Debugf("request %v missing blocks from %v/%v peers", len(hashes), repetitions, peerCount)
-	i := 0
-	indexes := rand.Perm(peerCount)[0:(repetitions - 1)]
-	sort.Ints(indexes)
-	for _, peer := range self.peers {
-		if i == indexes[0] {
-			peer.requestBlocks(hashes)
-			indexes = indexes[1:]
-			if len(indexes) == 0 {
-				break
+	self.wg.Add(1)
+	self.procWg.Add(1)
+	go func() {
+		// distribute block request among known peers
+		self.peersLock.Lock()
+		defer self.peersLock.Unlock()
+		peerCount := len(self.peers)
+		// on first attempt use the best peer
+		if attempts == 0 {
+			poolLogger.Debugf("request %v missing blocks from best peer %s", len(hashes), self.peer.id)
+			self.peer.requestBlocks(hashes)
+			return
+		}
+		repetitions := int(math.Min(float64(peerCount), float64(blocksRequestRepetition)))
+		i := 0
+		indexes := rand.Perm(peerCount)[0:repetitions]
+		sort.Ints(indexes)
+		poolLogger.Debugf("request %v missing blocks from %v/%v peers: chosen %v", len(hashes), repetitions, peerCount, indexes)
+		for _, peer := range self.peers {
+			if i == indexes[0] {
+				poolLogger.Debugf("request %v missing blocks from peer %s", len(hashes), peer.id)
+				peer.requestBlocks(hashes)
+				indexes = indexes[1:]
+				if len(indexes) == 0 {
+					break
+				}
 			}
+			i++
 		}
-		i++
-	}
+		self.wg.Done()
+		self.procWg.Done()
+	}()
 }
 
 func (self *BlockPool) getPeer(peerId string) (*peerInfo, bool) {
@@ -679,337 +907,100 @@ func (self *BlockPool) getPeer(peerId string) (*peerInfo, bool) {
 	}
 	info, ok := self.peers[peerId]
 	if !ok {
-		panic("unknown peer")
+		return nil, false
 	}
 	return info, false
 }
 
-func (self *peerInfo) addSection(hash []byte, section *section) {
-	self.lock.Lock()
-	defer self.lock.Unlock()
-	self.sections[string(hash)] = section
-}
-
-func (self *peerInfo) addRoot(node *poolNode) {
+func (self *peerInfo) addSection(hash []byte, section *section) (found *section) {
 	self.lock.Lock()
 	defer self.lock.Unlock()
-	self.roots = append(self.roots, node)
-}
-
-// (re)starts processes registered for this peer (self)
-func (self *peerInfo) start(peer *peerInfo) {
-	self.lock.Lock()
-	defer self.lock.Unlock()
-	self.quitC = make(chan bool)
-	for _, root := range self.roots {
-		root.sectionRLock()
-		if root.section.bottom != nil {
-			if root.parent == nil {
-				self.requestBlockHashes(root.hash)
+	key := string(hash)
+	found = self.sections[key]
+	poolLogger.DebugDetailf("[%s] section process %s registered", sectionName(section), self.id)
+	self.sections[key] = section
+	return
+}
+
+func (self *BlockPool) switchPeer(oldPeer, newPeer *peerInfo) {
+	if newPeer != nil {
+		entry := self.get(newPeer.currentBlock)
+		if entry == nil {
+			poolLogger.Debugf("[%s] head block [%s] not found, requesting hashes", newPeer.id, name(newPeer.currentBlock))
+			newPeer.requestBlockHashes(newPeer.currentBlock)
+		} else {
+			poolLogger.Debugf("[%s] head block [%s] found, activate chain at section [%s]", newPeer.id, name(newPeer.currentBlock), sectionName(entry.section))
+			self.activateChain(entry.section, newPeer)
+		}
+		poolLogger.DebugDetailf("[%s] activate section processes", newPeer.id)
+		for hash, section := range newPeer.sections {
+			// this will block if section process is waiting for peer lock
+			select {
+			case <-section.offC:
+				poolLogger.DebugDetailf("[%s][%x] section process complete - remove", newPeer.id, hash[:4])
+				delete(newPeer.sections, hash)
+			case section.controlC <- newPeer:
+				poolLogger.DebugDetailf("[%s][%x] registered peer with section", newPeer.id, hash[:4])
 			}
 		}
-		root.sectionRUnlock()
+		newPeer.quitC = make(chan bool)
+	}
+	if oldPeer != nil {
+		close(oldPeer.quitC)
 	}
-	self.roots = nil
-	self.controlSections(peer, true)
 }
 
-//  (re)starts process without requests, only suicide timer
-func (self *peerInfo) stop(peer *peerInfo) {
-	self.lock.RLock()
-	defer self.lock.RUnlock()
-	close(self.quitC)
-	self.controlSections(peer, false)
+func (self *BlockPool) getParent(sec *section) *section {
+	self.chainLock.RLock()
+	defer self.chainLock.RUnlock()
+	return sec.parent
 }
 
-func (self *peerInfo) controlSections(peer *peerInfo, on bool) {
-	if peer != nil {
-		peer.lock.RLock()
-		defer peer.lock.RUnlock()
-	}
-	for hash, section := range peer.sections {
-		if section.done() {
-			delete(self.sections, hash)
-		}
-		_, exists := peer.sections[hash]
-		if on || peer == nil || exists {
-			if on {
-				// self is best peer
-				section.start()
-			} else {
-				//  (re)starts process without requests, only suicide timer
-				section.stop()
-			}
-		}
+func (self *BlockPool) getChild(sec *section) *section {
+	self.chainLock.RLock()
+	defer self.chainLock.RUnlock()
+	return sec.child
+}
+
+func newSection() (sec *section) {
+	sec = &section{
+		controlC:    make(chan *peerInfo),
+		suicideC:    make(chan bool),
+		blockChainC: make(chan bool),
+		offC:        make(chan bool),
+		forkC:       make(chan chan bool),
 	}
+	return
 }
 
-// called when parent is found in pool
-// parent and child are guaranteed to be on different sections
-func (self *BlockPool) link(parent, child *poolNode) {
-	var top bool
-	parent.sectionLock()
-	if child != nil {
-		child.sectionLock()
-	}
-	if parent == parent.section.top && parent.section.top != nil {
-		top = true
-	}
-	var bottom bool
-
-	if child == child.section.bottom {
-		bottom = true
-	}
-	if parent.child != child {
-		orphan := parent.child
-		if orphan != nil {
-			// got a fork in the chain
-			if top {
-				orphan.lock.Lock()
-				// make old child orphan
-				orphan.parent = nil
-				orphan.lock.Unlock()
-			} else { // we are under section lock
-				// make old child orphan
-				orphan.parent = nil
-				// reset section objects above the fork
-				nchild := orphan.child
-				node := orphan
-				section := &section{bottom: orphan}
-				for node.section == nchild.section {
-					node = nchild
-					node.section = section
-					nchild = node.child
-				}
-				section.top = node
-				// set up a suicide
-				self.processSection(orphan).stop()
-			}
-		} else {
-			// child is on top of a chain need to close section
-			child.section.bottom = child
-		}
-		// adopt new child
+// link should only be called under chainLock
+func (self *BlockPool) link(parent *section, child *section) {
+	if parent != nil {
+		exChild := parent.child
 		parent.child = child
-		if !top {
-			parent.section.top = parent
-			// restart section process so that shorter section is scanned for blocks
-			parent.section.reset()
+		if exChild != nil && exChild != child {
+			poolLogger.Debugf("[%s] chain fork [%s] -> [%s]", sectionName(parent), sectionName(exChild), sectionName(child))
+			exChild.parent = nil
 		}
 	}
-
 	if child != nil {
-		if child.parent != parent {
-			stepParent := child.parent
-			if stepParent != nil {
-				if bottom {
-					stepParent.Lock()
-					stepParent.child = nil
-					stepParent.Unlock()
-				} else {
-					// we are on the same section
-					// if it is a aberrant reverse fork,
-					stepParent.child = nil
-					node := stepParent
-					nparent := stepParent.child
-					section := &section{top: stepParent}
-					for node.section == nparent.section {
-						node = nparent
-						node.section = section
-						node = node.parent
-					}
-				}
-			} else {
-				// linking to a root node, ie. parent is under the root of a chain
-				parent.section.top = parent
-			}
+		exParent := child.parent
+		if exParent != nil && exParent != parent {
+			poolLogger.Debugf("[%s] chain reverse fork [%s] -> [%s]", sectionName(child), sectionName(exParent), sectionName(parent))
+			exParent.child = nil
 		}
 		child.parent = parent
-		child.section.bottom = child
-	}
-	// this needed if someone lied about the parent before
-	child.knownParent = false
-
-	parent.sectionUnlock()
-	if child != nil {
-		child.sectionUnlock()
-	}
-}
-
-// this immediately kills the chain from node to end (inclusive) section by section
-func (self *BlockPool) killChain(node *poolNode, end *poolNode) {
-	poolLogger.Debugf("kill chain section with root node %v", node)
-
-	node.sectionLock()
-	node.section.abort()
-	self.set(node.hash, nil)
-	child := node.child
-	top := node.section.top
-	i := 1
-	self.wg.Add(1)
-	go func() {
-		var quit bool
-		for node != top && node != end && child != nil {
-			node = child
-			select {
-			case <-self.quit:
-				quit = true
-				break
-			default:
-			}
-			self.set(node.hash, nil)
-			child = node.child
-		}
-		poolLogger.Debugf("killed chain section of %v blocks with root node %v", i, node)
-		if !quit {
-			if node == top {
-				if node != end && child != nil && end != nil {
-					//
-					self.killChain(child, end)
-				}
-			} else {
-				if child != nil {
-					// delink rest of this section if ended midsection
-					child.section.bottom = child
-					child.parent = nil
-				}
-			}
-		}
-		node.section.bottom = nil
-		node.sectionUnlock()
-		self.wg.Done()
-	}()
-}
-
-// structure to store long range links on chain to skip along
-type section struct {
-	lock     sync.RWMutex
-	bottom   *poolNode
-	top      *poolNode
-	controlC chan bool
-	resetC   chan bool
-}
-
-func (self *section) start() {
-	self.lock.RLock()
-	defer self.lock.RUnlock()
-	if self.controlC != nil {
-		self.controlC <- true
-	}
-}
-
-func (self *section) stop() {
-	self.lock.RLock()
-	defer self.lock.RUnlock()
-	if self.controlC != nil {
-		self.controlC <- false
 	}
 }
 
-func (self *section) reset() {
+func (self *BlockPool) get(hash []byte) (node *poolEntry) {
 	self.lock.RLock()
 	defer self.lock.RUnlock()
-	if self.controlC != nil {
-		self.resetC <- true
-		self.controlC <- false
-	}
-}
-
-func (self *section) abort() {
-	self.lock.Lock()
-	defer self.lock.Unlock()
-	if self.controlC != nil {
-		close(self.controlC)
-		self.controlC = nil
-	}
-}
-
-func (self *section) done() bool {
-	self.lock.Lock()
-	defer self.lock.Unlock()
-	if self.controlC != nil {
-		return true
-	}
-	return false
-}
-
-func (self *BlockPool) get(hash []byte) (node *poolNode) {
-	self.lock.Lock()
-	defer self.lock.Unlock()
 	return self.pool[string(hash)]
 }
 
-func (self *BlockPool) set(hash []byte, node *poolNode) {
+func (self *BlockPool) set(hash []byte, node *poolEntry) {
 	self.lock.Lock()
 	defer self.lock.Unlock()
 	self.pool[string(hash)] = node
 }
-
-// first time for block request, this iteration retrieves nodes of the chain
-// from node up to top (all the way if nil) via child links
-// copies the controller
-// and feeds nodeC channel
-// this is performed under section readlock to prevent top from going away
-// when
-func (self *BlockPool) foldUp(node *poolNode, nodeC chan *poolNode) {
-	self.wg.Add(1)
-	go func() {
-		node.sectionRLock()
-		defer node.sectionRUnlock()
-		for node != nil {
-			select {
-			case <-self.quit:
-				break
-			case nodeC <- node:
-				if node == node.section.top {
-					break
-				}
-				node = node.child
-			}
-		}
-		close(nodeC)
-		self.wg.Done()
-	}()
-}
-
-func (self *poolNode) Lock() {
-	self.sectionLock()
-	self.lock.Lock()
-}
-
-func (self *poolNode) Unlock() {
-	self.lock.Unlock()
-	self.sectionUnlock()
-}
-
-func (self *poolNode) RLock() {
-	self.lock.RLock()
-}
-
-func (self *poolNode) RUnlock() {
-	self.lock.RUnlock()
-}
-
-func (self *poolNode) sectionLock() {
-	self.lock.RLock()
-	defer self.lock.RUnlock()
-	self.section.lock.Lock()
-}
-
-func (self *poolNode) sectionUnlock() {
-	self.lock.RLock()
-	defer self.lock.RUnlock()
-	self.section.lock.Unlock()
-}
-
-func (self *poolNode) sectionRLock() {
-	self.lock.RLock()
-	defer self.lock.RUnlock()
-	self.section.lock.RLock()
-}
-
-func (self *poolNode) sectionRUnlock() {
-	self.lock.RLock()
-	defer self.lock.RUnlock()
-	self.section.lock.RUnlock()
-}
diff --git a/eth/block_pool_test.go b/eth/block_pool_test.go
index 315cc748d..b50a314ea 100644
--- a/eth/block_pool_test.go
+++ b/eth/block_pool_test.go
@@ -1,115 +1,65 @@
 package eth
 
 import (
-	"bytes"
 	"fmt"
 	"log"
+	"math/big"
 	"os"
 	"sync"
 	"testing"
+	"time"
 
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
 	ethlogger "github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/pow"
 )
 
-var sys = ethlogger.NewStdLogSystem(os.Stdout, log.LstdFlags, ethlogger.LogLevel(ethlogger.DebugDetailLevel))
+const waitTimeout = 60 // seconds
 
-type testChainManager struct {
-	knownBlock func(hash []byte) bool
-	addBlock   func(*types.Block) error
-	checkPoW   func(*types.Block) bool
-}
-
-func (self *testChainManager) KnownBlock(hash []byte) bool {
-	if self.knownBlock != nil {
-		return self.knownBlock(hash)
-	}
-	return false
-}
+var logsys = ethlogger.NewStdLogSystem(os.Stdout, log.LstdFlags, ethlogger.LogLevel(ethlogger.DebugLevel))
 
-func (self *testChainManager) AddBlock(block *types.Block) error {
-	if self.addBlock != nil {
-		return self.addBlock(block)
-	}
-	return nil
-}
+var ini = false
 
-func (self *testChainManager) CheckPoW(block *types.Block) bool {
-	if self.checkPoW != nil {
-		return self.checkPoW(block)
+func logInit() {
+	if !ini {
+		ethlogger.AddLogSystem(logsys)
+		ini = true
 	}
-	return false
 }
 
-func knownBlock(hashes ...[]byte) (f func([]byte) bool) {
-	f = func(block []byte) bool {
-		for _, hash := range hashes {
-			if bytes.Compare(block, hash) == 0 {
-				return true
-			}
-		}
+// test helpers
+func arrayEq(a, b []int) bool {
+	if len(a) != len(b) {
 		return false
 	}
-	return
-}
-
-func addBlock(hashes ...[]byte) (f func(*types.Block) error) {
-	f = func(block *types.Block) error {
-		for _, hash := range hashes {
-			if bytes.Compare(block.Hash(), hash) == 0 {
-				return fmt.Errorf("invalid by test")
-			}
-		}
-		return nil
-	}
-	return
-}
-
-func checkPoW(hashes ...[]byte) (f func(*types.Block) bool) {
-	f = func(block *types.Block) bool {
-		for _, hash := range hashes {
-			if bytes.Compare(block.Hash(), hash) == 0 {
-				return false
-			}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
 		}
-		return true
-	}
-	return
-}
-
-func newTestChainManager(knownBlocks [][]byte, invalidBlocks [][]byte, invalidPoW [][]byte) *testChainManager {
-	return &testChainManager{
-		knownBlock: knownBlock(knownBlocks...),
-		addBlock:   addBlock(invalidBlocks...),
-		checkPoW:   checkPoW(invalidPoW...),
 	}
+	return true
 }
 
 type intToHash map[int][]byte
 
 type hashToInt map[string]int
 
+// hashPool is a test helper, that allows random hashes to be referred to by integers
 type testHashPool struct {
 	intToHash
 	hashToInt
+	lock sync.Mutex
 }
 
 func newHash(i int) []byte {
 	return crypto.Sha3([]byte(string(i)))
 }
 
-func newTestBlockPool(knownBlockIndexes []int, invalidBlockIndexes []int, invalidPoWIndexes []int) (hashPool *testHashPool, blockPool *BlockPool) {
-	hashPool = &testHashPool{make(intToHash), make(hashToInt)}
-	knownBlocks := hashPool.indexesToHashes(knownBlockIndexes)
-	invalidBlocks := hashPool.indexesToHashes(invalidBlockIndexes)
-	invalidPoW := hashPool.indexesToHashes(invalidPoWIndexes)
-	blockPool = NewBlockPool(newTestChainManager(knownBlocks, invalidBlocks, invalidPoW))
-	return
-}
-
 func (self *testHashPool) indexesToHashes(indexes []int) (hashes [][]byte) {
+	self.lock.Lock()
+	defer self.lock.Unlock()
 	for _, i := range indexes {
 		hash, found := self.intToHash[i]
 		if !found {
@@ -123,6 +73,8 @@ func (self *testHashPool) indexesToHashes(indexes []int) (hashes [][]byte) {
 }
 
 func (self *testHashPool) hashesToIndexes(hashes [][]byte) (indexes []int) {
+	self.lock.Lock()
+	defer self.lock.Unlock()
 	for _, hash := range hashes {
 		i, found := self.hashToInt[string(hash)]
 		if !found {
@@ -133,66 +85,812 @@ func (self *testHashPool) hashesToIndexes(hashes [][]byte) (indexes []int) {
 	return
 }
 
-type protocolChecker struct {
+// test blockChain is an integer trie
+type blockChain map[int][]int
+
+// blockPoolTester provides the interface between tests and a blockPool
+//
+// refBlockChain is used to guide which blocks will be accepted as valid
+// blockChain gives the current state of the blockchain and
+// accumulates inserts so that we can check the resulting chain
+type blockPoolTester struct {
+	hashPool      *testHashPool
+	lock          sync.RWMutex
+	refBlockChain blockChain
+	blockChain    blockChain
+	blockPool     *BlockPool
+	t             *testing.T
+}
+
+func newTestBlockPool(t *testing.T) (hashPool *testHashPool, blockPool *BlockPool, b *blockPoolTester) {
+	hashPool = &testHashPool{intToHash: make(intToHash), hashToInt: make(hashToInt)}
+	b = &blockPoolTester{
+		t:             t,
+		hashPool:      hashPool,
+		blockChain:    make(blockChain),
+		refBlockChain: make(blockChain),
+	}
+	b.blockPool = NewBlockPool(b.hasBlock, b.insertChain, b.verifyPoW)
+	blockPool = b.blockPool
+	return
+}
+
+func (self *blockPoolTester) Errorf(format string, params ...interface{}) {
+	fmt.Printf(format+"\n", params...)
+	self.t.Errorf(format, params...)
+}
+
+// blockPoolTester implements the 3 callbacks needed by the blockPool:
+// hasBlock, insetChain, verifyPoW
+func (self *blockPoolTester) hasBlock(block []byte) (ok bool) {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+	indexes := self.hashPool.hashesToIndexes([][]byte{block})
+	i := indexes[0]
+	_, ok = self.blockChain[i]
+	fmt.Printf("has block %v (%x...): %v\n", i, block[0:4], ok)
+	return
+}
+
+func (self *blockPoolTester) insertChain(blocks types.Blocks) error {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+	var parent, child int
+	var children, refChildren []int
+	var ok bool
+	for _, block := range blocks {
+		child = self.hashPool.hashesToIndexes([][]byte{block.Hash()})[0]
+		_, ok = self.blockChain[child]
+		if ok {
+			fmt.Printf("block %v already in blockchain\n", child)
+			continue // already in chain
+		}
+		parent = self.hashPool.hashesToIndexes([][]byte{block.ParentHeaderHash})[0]
+		children, ok = self.blockChain[parent]
+		if !ok {
+			return fmt.Errorf("parent %v not in blockchain ", parent)
+		}
+		ok = false
+		var found bool
+		refChildren, found = self.refBlockChain[parent]
+		if found {
+			for _, c := range refChildren {
+				if c == child {
+					ok = true
+				}
+			}
+			if !ok {
+				return fmt.Errorf("invalid block %v", child)
+			}
+		} else {
+			ok = true
+		}
+		if ok {
+			// accept any blocks if parent not in refBlockChain
+			fmt.Errorf("blockchain insert %v -> %v\n", parent, child)
+			self.blockChain[parent] = append(children, child)
+			self.blockChain[child] = nil
+		}
+	}
+	return nil
+}
+
+func (self *blockPoolTester) verifyPoW(pblock pow.Block) bool {
+	return true
+}
+
+// test helper that compares the resulting blockChain to the desired blockChain
+func (self *blockPoolTester) checkBlockChain(blockChain map[int][]int) {
+	for k, v := range self.blockChain {
+		fmt.Printf("got: %v -> %v\n", k, v)
+	}
+	for k, v := range blockChain {
+		fmt.Printf("expected: %v -> %v\n", k, v)
+	}
+	if len(blockChain) != len(self.blockChain) {
+		self.Errorf("blockchain incorrect (zlength differ)")
+	}
+	for k, v := range blockChain {
+		vv, ok := self.blockChain[k]
+		if !ok || !arrayEq(v, vv) {
+			self.Errorf("blockchain incorrect on %v -> %v (!= %v)", k, vv, v)
+		}
+	}
+}
+
+//
+
+// peerTester provides the peer callbacks for the blockPool
+// it registers actual callbacks so that result can be compared to desired behaviour
+// provides helper functions to mock the protocol calls to the blockPool
+type peerTester struct {
 	blockHashesRequests []int
 	blocksRequests      [][]int
-	invalidBlocks       []error
+	blocksRequestsMap   map[int]bool
+	peerErrors          []int
+	blockPool           *BlockPool
 	hashPool            *testHashPool
-	lock                sync.Mutex
+	lock                sync.RWMutex
+	id                  string
+	td                  int
+	currentBlock        int
+	t                   *testing.T
 }
 
-// -1 is special: not found (a hash never seen)
-func (self *protocolChecker) requestBlockHashesCallBack() (requestBlockHashesCallBack func([]byte) error) {
-	requestBlockHashesCallBack = func(hash []byte) error {
-		indexes := self.hashPool.hashesToIndexes([][]byte{hash})
-		self.lock.Lock()
-		defer self.lock.Unlock()
-		self.blockHashesRequests = append(self.blockHashesRequests, indexes[0])
-		return nil
+// peerTester constructor takes hashPool and blockPool from the blockPoolTester
+func (self *blockPoolTester) newPeer(id string, td int, cb int) *peerTester {
+	return &peerTester{
+		id:                id,
+		td:                td,
+		currentBlock:      cb,
+		hashPool:          self.hashPool,
+		blockPool:         self.blockPool,
+		t:                 self.t,
+		blocksRequestsMap: make(map[int]bool),
 	}
-	return
 }
 
-func (self *protocolChecker) requestBlocksCallBack() (requestBlocksCallBack func([][]byte) error) {
-	requestBlocksCallBack = func(hashes [][]byte) error {
-		indexes := self.hashPool.hashesToIndexes(hashes)
-		self.lock.Lock()
-		defer self.lock.Unlock()
-		self.blocksRequests = append(self.blocksRequests, indexes)
-		return nil
+func (self *peerTester) Errorf(format string, params ...interface{}) {
+	fmt.Printf(format+"\n", params...)
+	self.t.Errorf(format, params...)
+}
+
+// helper to compare actual and expected block requests
+func (self *peerTester) checkBlocksRequests(blocksRequests ...[]int) {
+	if len(blocksRequests) > len(self.blocksRequests) {
+		self.Errorf("blocks requests incorrect (length differ)\ngot %v\nexpected %v", self.blocksRequests, blocksRequests)
+	} else {
+		for i, rr := range blocksRequests {
+			r := self.blocksRequests[i]
+			if !arrayEq(r, rr) {
+				self.Errorf("blocks requests incorrect\ngot %v\nexpected %v", self.blocksRequests, blocksRequests)
+			}
+		}
 	}
-	return
 }
 
-func (self *protocolChecker) invalidBlockCallBack() (invalidBlockCallBack func(error)) {
-	invalidBlockCallBack = func(err error) {
-		self.invalidBlocks = append(self.invalidBlocks, err)
+// helper to compare actual and expected block hash requests
+func (self *peerTester) checkBlockHashesRequests(blocksHashesRequests ...int) {
+	rr := blocksHashesRequests
+	self.lock.RLock()
+	r := self.blockHashesRequests
+	self.lock.RUnlock()
+	if len(r) != len(rr) {
+		self.Errorf("block hashes requests incorrect (length differ)\ngot %v\nexpected %v", r, rr)
+	} else {
+		if !arrayEq(r, rr) {
+			self.Errorf("block hashes requests incorrect\ngot %v\nexpected %v", r, rr)
+		}
+	}
+}
+
+// waiter function used by peer.AddBlocks
+// blocking until requests appear
+// since block requests are sent to any random peers
+// block request map is shared between peers
+// times out after a period
+func (self *peerTester) waitBlocksRequests(blocksRequest ...int) {
+	timeout := time.After(waitTimeout * time.Second)
+	rr := blocksRequest
+	for {
+		self.lock.RLock()
+		r := self.blocksRequestsMap
+		fmt.Printf("[%s] blocks request check %v (%v)\n", self.id, rr, r)
+		i := 0
+		for i = 0; i < len(rr); i++ {
+			_, ok := r[rr[i]]
+			if !ok {
+				break
+			}
+		}
+		self.lock.RUnlock()
+
+		if i == len(rr) {
+			return
+		}
+		time.Sleep(100 * time.Millisecond)
+		select {
+		case <-timeout:
+		default:
+		}
 	}
-	return
 }
 
+// waiter function used by peer.AddBlockHashes
+// blocking until requests appear
+// times out after a period
+func (self *peerTester) waitBlockHashesRequests(blocksHashesRequest int) {
+	timeout := time.After(waitTimeout * time.Second)
+	rr := blocksHashesRequest
+	for i := 0; ; {
+		self.lock.RLock()
+		r := self.blockHashesRequests
+		self.lock.RUnlock()
+		fmt.Printf("[%s] block hash request check %v (%v)\n", self.id, rr, r)
+		for ; i < len(r); i++ {
+			if rr == r[i] {
+				return
+			}
+		}
+		time.Sleep(100 * time.Millisecond)
+		select {
+		case <-timeout:
+		default:
+		}
+	}
+}
+
+// mocks a simple blockchain 0 (genesis) ... n (head)
+func (self *blockPoolTester) initRefBlockChain(n int) {
+	for i := 0; i < n; i++ {
+		self.refBlockChain[i] = []int{i + 1}
+	}
+}
+
+// peerTester functions that mimic protocol calls to the blockpool
+//  registers the peer with the blockPool
+func (self *peerTester) AddPeer() bool {
+	hash := self.hashPool.indexesToHashes([]int{self.currentBlock})[0]
+	return self.blockPool.AddPeer(big.NewInt(int64(self.td)), hash, self.id, self.requestBlockHashes, self.requestBlocks, self.peerError)
+}
+
+// peer sends blockhashes if and when gets a request
+func (self *peerTester) AddBlockHashes(indexes ...int) {
+	i := 0
+	fmt.Printf("ready to add block hashes %v\n", indexes)
+
+	self.waitBlockHashesRequests(indexes[0])
+	fmt.Printf("adding block hashes %v\n", indexes)
+	hashes := self.hashPool.indexesToHashes(indexes)
+	next := func() (hash []byte, ok bool) {
+		if i < len(hashes) {
+			hash = hashes[i]
+			ok = true
+			i++
+		}
+		return
+	}
+	self.blockPool.AddBlockHashes(next, self.id)
+}
+
+// peer sends blocks if and when there is a request
+// (in the shared request store, not necessarily to a person)
+func (self *peerTester) AddBlocks(indexes ...int) {
+	hashes := self.hashPool.indexesToHashes(indexes)
+	fmt.Printf("ready to add blocks %v\n", indexes[1:])
+	self.waitBlocksRequests(indexes[1:]...)
+	fmt.Printf("adding blocks %v \n", indexes[1:])
+	for i := 1; i < len(hashes); i++ {
+		fmt.Printf("adding block %v %x\n", indexes[i], hashes[i][:4])
+		self.blockPool.AddBlock(&types.Block{HeaderHash: ethutil.Bytes(hashes[i]), ParentHeaderHash: ethutil.Bytes(hashes[i-1])}, self.id)
+	}
+}
+
+// peer callbacks
+// -1 is special: not found (a hash never seen)
+// records block hashes requests by the blockPool
+func (self *peerTester) requestBlockHashes(hash []byte) error {
+	indexes := self.hashPool.hashesToIndexes([][]byte{hash})
+	fmt.Printf("[%s] blocks hash request %v %x\n", self.id, indexes[0], hash[:4])
+	self.lock.Lock()
+	defer self.lock.Unlock()
+	self.blockHashesRequests = append(self.blockHashesRequests, indexes[0])
+	return nil
+}
+
+// records block requests by the blockPool
+func (self *peerTester) requestBlocks(hashes [][]byte) error {
+	indexes := self.hashPool.hashesToIndexes(hashes)
+	fmt.Printf("blocks request %v %x...\n", indexes, hashes[0][:4])
+	self.lock.Lock()
+	defer self.lock.Unlock()
+	self.blocksRequests = append(self.blocksRequests, indexes)
+	for _, i := range indexes {
+		self.blocksRequestsMap[i] = true
+	}
+	return nil
+}
+
+// records the error codes of all the peerErrors found the blockPool
+func (self *peerTester) peerError(code int, format string, params ...interface{}) {
+	self.peerErrors = append(self.peerErrors, code)
+}
+
+// the actual tests
 func TestAddPeer(t *testing.T) {
-	ethlogger.AddLogSystem(sys)
-	knownBlockIndexes := []int{0, 1}
-	invalidBlockIndexes := []int{2, 3}
-	invalidPoWIndexes := []int{4, 5}
-	hashPool, blockPool := newTestBlockPool(knownBlockIndexes, invalidBlockIndexes, invalidPoWIndexes)
-	// TODO:
-	// hashPool, blockPool, blockChainChecker = newTestBlockPool(knownBlockIndexes, invalidBlockIndexes, invalidPoWIndexes)
-	peer0 := &protocolChecker{
-		// blockHashesRequests: make([]int),
-		// blocksRequests:      make([][]int),
-		// invalidBlocks:       make([]error),
-		hashPool: hashPool,
-	}
-	best := blockPool.AddPeer(ethutil.Big1, newHash(100), "0",
-		peer0.requestBlockHashesCallBack(),
-		peer0.requestBlocksCallBack(),
-		peer0.invalidBlockCallBack(),
-	)
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	peer0 := blockPoolTester.newPeer("peer0", 1, 0)
+	peer1 := blockPoolTester.newPeer("peer1", 2, 1)
+	peer2 := blockPoolTester.newPeer("peer2", 3, 2)
+	var peer *peerInfo
+
+	blockPool.Start()
+
+	// pool
+	best := peer0.AddPeer()
+	if !best {
+		t.Errorf("peer0 (TD=1) not accepted as best")
+	}
+	if blockPool.peer.id != "peer0" {
+		t.Errorf("peer0 (TD=1) not set as best")
+	}
+	peer0.checkBlockHashesRequests(0)
+
+	best = peer2.AddPeer()
+	if !best {
+		t.Errorf("peer2 (TD=3) not accepted as best")
+	}
+	if blockPool.peer.id != "peer2" {
+		t.Errorf("peer2 (TD=3) not set as best")
+	}
+	peer2.checkBlockHashesRequests(2)
+
+	best = peer1.AddPeer()
+	if best {
+		t.Errorf("peer1 (TD=2) accepted as best")
+	}
+	if blockPool.peer.id != "peer2" {
+		t.Errorf("peer2 (TD=3) not set any more as best")
+	}
+	if blockPool.peer.td.Cmp(big.NewInt(int64(3))) != 0 {
+		t.Errorf("peer1 TD not set")
+	}
+
+	peer2.td = 4
+	peer2.currentBlock = 3
+	best = peer2.AddPeer()
 	if !best {
-		t.Errorf("peer not accepted as best")
+		t.Errorf("peer2 (TD=4) not accepted as best")
 	}
+	if blockPool.peer.id != "peer2" {
+		t.Errorf("peer2 (TD=4) not set as best")
+	}
+	if blockPool.peer.td.Cmp(big.NewInt(int64(4))) != 0 {
+		t.Errorf("peer2 TD not updated")
+	}
+	peer2.checkBlockHashesRequests(2, 3)
+
+	peer1.td = 3
+	peer1.currentBlock = 2
+	best = peer1.AddPeer()
+	if best {
+		t.Errorf("peer1 (TD=3) should not be set as best")
+	}
+	if blockPool.peer.id == "peer1" {
+		t.Errorf("peer1 (TD=3) should not be set as best")
+	}
+	peer, best = blockPool.getPeer("peer1")
+	if peer.td.Cmp(big.NewInt(int64(3))) != 0 {
+		t.Errorf("peer1 TD should be updated")
+	}
+
+	blockPool.RemovePeer("peer2")
+	peer, best = blockPool.getPeer("peer2")
+	if peer != nil {
+		t.Errorf("peer2 not removed")
+	}
+
+	if blockPool.peer.id != "peer1" {
+		t.Errorf("existing peer1 (TD=3) should be set as best peer")
+	}
+	peer1.checkBlockHashesRequests(2)
+
+	blockPool.RemovePeer("peer1")
+	peer, best = blockPool.getPeer("peer1")
+	if peer != nil {
+		t.Errorf("peer1 not removed")
+	}
+
+	if blockPool.peer.id != "peer0" {
+		t.Errorf("existing peer0 (TD=1) should be set as best peer")
+	}
+
+	blockPool.RemovePeer("peer0")
+	peer, best = blockPool.getPeer("peer0")
+	if peer != nil {
+		t.Errorf("peer1 not removed")
+	}
+
+	// adding back earlier peer ok
+	peer0.currentBlock = 3
+	best = peer0.AddPeer()
+	if !best {
+		t.Errorf("peer0 (TD=1) should be set as best")
+	}
+
+	if blockPool.peer.id != "peer0" {
+		t.Errorf("peer0 (TD=1) should be set as best")
+	}
+	peer0.checkBlockHashesRequests(0, 0, 3)
+
+	blockPool.Stop()
+
+}
+
+func TestPeerWithKnownBlock(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.refBlockChain[0] = nil
+	blockPoolTester.blockChain[0] = nil
+	// hashPool, blockPool, blockPoolTester := newTestBlockPool()
+	blockPool.Start()
+
+	peer0 := blockPoolTester.newPeer("0", 1, 0)
+	peer0.AddPeer()
+
+	blockPool.Stop()
+	// no request on known block
+	peer0.checkBlockHashesRequests()
+}
+
+func TestSimpleChain(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(2)
+
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 2)
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(2, 1, 0)
+	peer1.AddBlocks(0, 1, 2)
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[2] = []int{}
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+}
+
+func TestInvalidBlock(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(2)
+	blockPoolTester.refBlockChain[2] = []int{}
+
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 3)
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(3, 2, 1, 0)
+	peer1.AddBlocks(0, 1, 2, 3)
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[2] = []int{}
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+	if len(peer1.peerErrors) == 1 {
+		if peer1.peerErrors[0] != ErrInvalidBlock {
+			t.Errorf("wrong error, got %v, expected %v", peer1.peerErrors[0], ErrInvalidBlock)
+		}
+	} else {
+		t.Errorf("expected invalid block error, got nothing")
+	}
+}
+
+func TestVerifyPoW(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(3)
+	first := false
+	blockPoolTester.blockPool.verifyPoW = func(b pow.Block) bool {
+		bb, _ := b.(*types.Block)
+		indexes := blockPoolTester.hashPool.hashesToIndexes([][]byte{bb.Hash()})
+		if indexes[0] == 1 && !first {
+			first = true
+			return false
+		} else {
+			return true
+		}
+
+	}
+
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 2)
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(2, 1, 0)
+	peer1.AddBlocks(0, 1, 2)
+	peer1.AddBlocks(0, 1)
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[2] = []int{}
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+	if len(peer1.peerErrors) == 1 {
+		if peer1.peerErrors[0] != ErrInvalidPoW {
+			t.Errorf("wrong error, got %v, expected %v", peer1.peerErrors[0], ErrInvalidPoW)
+		}
+	} else {
+		t.Errorf("expected invalid pow error, got nothing")
+	}
+}
+
+func TestMultiSectionChain(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(5)
+
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 5)
+
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(5, 4, 3)
+	go peer1.AddBlocks(2, 3, 4, 5)
+	go peer1.AddBlockHashes(3, 2, 1, 0)
+	peer1.AddBlocks(0, 1, 2)
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[5] = []int{}
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+}
+
+func TestNewBlocksOnPartialChain(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(7)
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 5)
+
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(5, 4, 3)
+	peer1.AddBlocks(2, 3) // partially complete section
+	// peer1 found new blocks
+	peer1.td = 2
+	peer1.currentBlock = 7
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(7, 6, 5)
+	go peer1.AddBlocks(3, 4, 5, 6, 7)
+	go peer1.AddBlockHashes(3, 2, 1, 0) // tests that hash request from known chain root is remembered
+	peer1.AddBlocks(0, 1, 2)
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[7] = []int{}
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+}
+
+func TestPeerSwitch(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(6)
+
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 5)
+	peer2 := blockPoolTester.newPeer("peer2", 2, 6)
+	peer2.blocksRequestsMap = peer1.blocksRequestsMap
+
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(5, 4, 3)
+	peer1.AddBlocks(2, 3)               // section partially complete, block 3 will be preserved after peer demoted
+	peer2.AddPeer()                     // peer2 is promoted as best peer, peer1 is demoted
+	go peer2.AddBlockHashes(6, 5)       //
+	go peer2.AddBlocks(4, 5, 6)         // tests that block request for earlier section is remembered
+	go peer1.AddBlocks(3, 4)            // tests that connecting section by demoted peer is remembered and blocks are accepted from demoted peer
+	go peer2.AddBlockHashes(3, 2, 1, 0) // tests that known chain section is activated, hash requests from 3 is remembered
+	peer2.AddBlocks(0, 1, 2)            // final blocks linking to blockchain sent
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[6] = []int{}
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+}
+
+func TestPeerDownSwitch(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(6)
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 4)
+	peer2 := blockPoolTester.newPeer("peer2", 2, 6)
+	peer2.blocksRequestsMap = peer1.blocksRequestsMap
+
+	peer2.AddPeer()
+	go peer2.AddBlockHashes(6, 5, 4)
+	peer2.AddBlocks(5, 6)                  // partially complete, section will be preserved
+	blockPool.RemovePeer("peer2")          // peer2 disconnects
+	peer1.AddPeer()                        // inferior peer1 is promoted as best peer
+	go peer1.AddBlockHashes(4, 3, 2, 1, 0) //
+	go peer1.AddBlocks(3, 4, 5)            // tests that section set by demoted peer is remembered and blocks are accepted
+	peer1.AddBlocks(0, 1, 2, 3)
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[6] = []int{}
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+}
+
+func TestPeerSwitchBack(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(8)
+
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 2, 11)
+	peer2 := blockPoolTester.newPeer("peer2", 1, 8)
+	peer2.blocksRequestsMap = peer1.blocksRequestsMap
+
+	peer2.AddPeer()
+	go peer2.AddBlockHashes(8, 7, 6)
+	go peer2.AddBlockHashes(6, 5, 4)
+	peer2.AddBlocks(4, 5)                  // section partially complete
+	peer1.AddPeer()                        // peer1 is promoted as best peer
+	go peer1.AddBlockHashes(11, 10)        // only gives useless results
+	blockPool.RemovePeer("peer1")          // peer1 disconnects
+	go peer2.AddBlockHashes(4, 3, 2, 1, 0) // tests that asking for hashes from 4 is remembered
+	go peer2.AddBlocks(3, 4, 5, 6, 7, 8)   // tests that section 4, 5, 6 and 7, 8 are remembered for missing blocks
+	peer2.AddBlocks(0, 1, 2, 3)
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[8] = []int{}
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+}
+
+func TestForkSimple(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(9)
+	blockPoolTester.refBlockChain[3] = []int{4, 7}
+	delete(blockPoolTester.refBlockChain, 6)
+
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 9)
+	peer2 := blockPoolTester.newPeer("peer2", 2, 6)
+	peer2.blocksRequestsMap = peer1.blocksRequestsMap
+
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(9, 8, 7, 3, 2)
+	peer1.AddBlocks(1, 2, 3, 7, 8, 9)
+	peer2.AddPeer()                        // peer2 is promoted as best peer
+	go peer2.AddBlockHashes(6, 5, 4, 3, 2) // fork on 3 -> 4 (earlier child: 7)
+	go peer2.AddBlocks(1, 2, 3, 4, 5, 6)
+	go peer2.AddBlockHashes(2, 1, 0)
+	peer2.AddBlocks(0, 1, 2)
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[6] = []int{}
+	blockPoolTester.refBlockChain[3] = []int{4}
+	delete(blockPoolTester.refBlockChain, 7)
+	delete(blockPoolTester.refBlockChain, 8)
+	delete(blockPoolTester.refBlockChain, 9)
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+
+}
+
+func TestForkSwitchBackByNewBlocks(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(11)
+	blockPoolTester.refBlockChain[3] = []int{4, 7}
+	delete(blockPoolTester.refBlockChain, 6)
+
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 9)
+	peer2 := blockPoolTester.newPeer("peer2", 2, 6)
+	peer2.blocksRequestsMap = peer1.blocksRequestsMap
+
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(9, 8, 7, 3, 2)
+	peer1.AddBlocks(8, 9)                  // partial section
+	peer2.AddPeer()                        //
+	go peer2.AddBlockHashes(6, 5, 4, 3, 2) // peer2 forks on block 3
+	peer2.AddBlocks(1, 2, 3, 4, 5, 6)      //
+
+	// peer1 finds new blocks
+	peer1.td = 3
+	peer1.currentBlock = 11
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(11, 10, 9)
+	peer1.AddBlocks(7, 8, 9, 10, 11)
+	go peer1.AddBlockHashes(7, 3) // tests that hash request from fork root is remembered
+	go peer1.AddBlocks(3, 7)      // tests that block requests on earlier fork are remembered
+	// go peer1.AddBlockHashes(1, 0) // tests that hash request from root of connecting chain section (added by demoted peer) is remembered
+	go peer1.AddBlockHashes(2, 1, 0) // tests that hash request from root of connecting chain section (added by demoted peer) is remembered
+	peer1.AddBlocks(0, 1, 2, 3)
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[11] = []int{}
+	blockPoolTester.refBlockChain[3] = []int{7}
+	delete(blockPoolTester.refBlockChain, 6)
+	delete(blockPoolTester.refBlockChain, 5)
+	delete(blockPoolTester.refBlockChain, 4)
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+
+}
+
+func TestForkSwitchBackByPeerSwitchBack(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(9)
+	blockPoolTester.refBlockChain[3] = []int{4, 7}
+	delete(blockPoolTester.refBlockChain, 6)
+
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 9)
+	peer2 := blockPoolTester.newPeer("peer2", 2, 6)
+	peer2.blocksRequestsMap = peer1.blocksRequestsMap
+
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(9, 8, 7, 3, 2)
+	peer1.AddBlocks(8, 9)
+	peer2.AddPeer()                        //
+	go peer2.AddBlockHashes(6, 5, 4, 3, 2) // peer2 forks on block 3
+	peer2.AddBlocks(2, 3, 4, 5, 6)         //
+	blockPool.RemovePeer("peer2")          // peer2 disconnects, peer1 is promoted again as best peer
+	peer1.AddBlockHashes(7, 3)             // tests that hash request from fork root is remembered
+	go peer1.AddBlocks(3, 7, 8)            // tests that block requests on earlier fork are remembered
+	go peer1.AddBlockHashes(2, 1, 0)       //
+	peer1.AddBlocks(0, 1, 2, 3)
+
+	blockPool.Wait(waitTimeout * time.Second)
+	blockPool.Stop()
+	blockPoolTester.refBlockChain[9] = []int{}
+	blockPoolTester.refBlockChain[3] = []int{7}
+	delete(blockPoolTester.refBlockChain, 6)
+	delete(blockPoolTester.refBlockChain, 5)
+	delete(blockPoolTester.refBlockChain, 4)
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
+
+}
+
+func TestForkCompleteSectionSwitchBackByPeerSwitchBack(t *testing.T) {
+	logInit()
+	_, blockPool, blockPoolTester := newTestBlockPool(t)
+	blockPoolTester.blockChain[0] = nil
+	blockPoolTester.initRefBlockChain(9)
+	blockPoolTester.refBlockChain[3] = []int{4, 7}
+	delete(blockPoolTester.refBlockChain, 6)
+
+	blockPool.Start()
+
+	peer1 := blockPoolTester.newPeer("peer1", 1, 9)
+	peer2 := blockPoolTester.newPeer("peer2", 2, 6)
+	peer2.blocksRequestsMap = peer1.blocksRequestsMap
+
+	peer1.AddPeer()
+	go peer1.AddBlockHashes(9, 8, 7)
+	peer1.AddBlocks(3, 7, 8, 9) // make sure this section is complete
+	time.Sleep(1 * time.Second)
+	go peer1.AddBlockHashes(7, 3, 2)       // block 3/7 is section boundary
+	peer1.AddBlocks(2, 3)                  // partially complete sections
+	peer2.AddPeer()                        //
+	go peer2.AddBlockHashes(6, 5, 4, 3, 2) // peer2 forks on block 3
+	peer2.AddBlocks(2, 3, 4, 5, 6)         // block 2 still missing.
+	blockPool.RemovePeer("peer2")          // peer2 disconnects, peer1 is promoted again as best peer
+	peer1.AddBlockHashes(7, 3)             // tests that hash request from fork root is remembered even though section process completed
+	go peer1.AddBlockHashes(2, 1, 0)       //
+	peer1.AddBlocks(0, 1, 2)
+
+	blockPool.Wait(waitTimeout * time.Second)
 	blockPool.Stop()
+	blockPoolTester.refBlockChain[9] = []int{}
+	blockPoolTester.refBlockChain[3] = []int{7}
+	delete(blockPoolTester.refBlockChain, 6)
+	delete(blockPoolTester.refBlockChain, 5)
+	delete(blockPoolTester.refBlockChain, 4)
+	blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
 
 }
diff --git a/eth/error.go b/eth/error.go
index d1daad575..1d9f80638 100644
--- a/eth/error.go
+++ b/eth/error.go
@@ -52,18 +52,17 @@ func ProtocolError(code int, format string, params ...interface{}) (err *protoco
 }
 
 func (self protocolError) Error() (message string) {
-	message = self.message
-	if message == "" {
-		message, ok := errorToString[self.Code]
+	if len(message) == 0 {
+		var ok bool
+		self.message, ok = errorToString[self.Code]
 		if !ok {
 			panic("invalid error code")
 		}
 		if self.format != "" {
-			message += ": " + fmt.Sprintf(self.format, self.params...)
+			self.message += ": " + fmt.Sprintf(self.format, self.params...)
 		}
-		self.message = message
 	}
-	return
+	return self.message
 }
 
 func (self *protocolError) Fatal() bool {
diff --git a/eth/protocol.go b/eth/protocol.go
index 7c5d09489..b67e5aaea 100644
--- a/eth/protocol.go
+++ b/eth/protocol.go
@@ -3,7 +3,7 @@ package eth
 import (
 	"bytes"
 	"fmt"
-	"math"
+	"io"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/core/types"
@@ -95,14 +95,13 @@ func runEthProtocol(txPool txPool, chainManager chainManager, blockPool blockPoo
 		blockPool:    blockPool,
 		rw:           rw,
 		peer:         peer,
-		id:           (string)(peer.Identity().Pubkey()),
+		id:           fmt.Sprintf("%x", peer.Identity().Pubkey()[:8]),
 	}
 	err = self.handleStatus()
 	if err == nil {
 		for {
 			err = self.handle()
 			if err != nil {
-				fmt.Println(err)
 				self.blockPool.RemovePeer(self.id)
 				break
 			}
@@ -117,7 +116,7 @@ func (self *ethProtocol) handle() error {
 		return err
 	}
 	if msg.Size > ProtocolMaxMsgSize {
-		return ProtocolError(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize)
+		return self.protoError(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize)
 	}
 	// make sure that the payload has been fully consumed
 	defer msg.Discard()
@@ -125,76 +124,87 @@ func (self *ethProtocol) handle() error {
 	switch msg.Code {
 
 	case StatusMsg:
-		return ProtocolError(ErrExtraStatusMsg, "")
+		return self.protoError(ErrExtraStatusMsg, "")
 
 	case TxMsg:
 		// TODO: rework using lazy RLP stream
 		var txs []*types.Transaction
 		if err := msg.Decode(&txs); err != nil {
-			return ProtocolError(ErrDecode, "%v", err)
+			return self.protoError(ErrDecode, "msg %v: %v", msg, err)
 		}
 		self.txPool.AddTransactions(txs)
 
 	case GetBlockHashesMsg:
 		var request getBlockHashesMsgData
 		if err := msg.Decode(&request); err != nil {
-			return ProtocolError(ErrDecode, "%v", err)
+			return self.protoError(ErrDecode, "->msg %v: %v", msg, err)
 		}
 		hashes := self.chainManager.GetBlockHashesFromHash(request.Hash, request.Amount)
 		return self.rw.EncodeMsg(BlockHashesMsg, ethutil.ByteSliceToInterface(hashes)...)
 
 	case BlockHashesMsg:
 		// TODO: redo using lazy decode , this way very inefficient on known chains
-		msgStream := rlp.NewListStream(msg.Payload, uint64(msg.Size))
+		msgStream := rlp.NewStream(msg.Payload)
 		var err error
+		var i int
+
 		iter := func() (hash []byte, ok bool) {
 			hash, err = msgStream.Bytes()
 			if err == nil {
+				i++
 				ok = true
+			} else {
+				if err != io.EOF {
+					self.protoError(ErrDecode, "msg %v: after %v hashes : %v", msg, i, err)
+				}
 			}
 			return
 		}
+
 		self.blockPool.AddBlockHashes(iter, self.id)
-		if err != nil && err != rlp.EOL {
-			return ProtocolError(ErrDecode, "%v", err)
-		}
 
 	case GetBlocksMsg:
-		var blockHashes [][]byte
-		if err := msg.Decode(&blockHashes); err != nil {
-			return ProtocolError(ErrDecode, "%v", err)
-		}
-		max := int(math.Min(float64(len(blockHashes)), blockHashesBatchSize))
+		msgStream := rlp.NewStream(msg.Payload)
 		var blocks []interface{}
-		for i, hash := range blockHashes {
-			if i >= max {
-				break
+		var i int
+		for {
+			i++
+			var hash []byte
+			if err := msgStream.Decode(&hash); err != nil {
+				if err == io.EOF {
+					break
+				} else {
+					return self.protoError(ErrDecode, "msg %v: %v", msg, err)
+				}
 			}
 			block := self.chainManager.GetBlock(hash)
 			if block != nil {
-				blocks = append(blocks, block.RlpData())
+				blocks = append(blocks, block)
+			}
+			if i == blockHashesBatchSize {
+				break
 			}
 		}
 		return self.rw.EncodeMsg(BlocksMsg, blocks...)
 
 	case BlocksMsg:
-		msgStream := rlp.NewListStream(msg.Payload, uint64(msg.Size))
+		msgStream := rlp.NewStream(msg.Payload)
 		for {
-			var block *types.Block
+			var block types.Block
 			if err := msgStream.Decode(&block); err != nil {
-				if err == rlp.EOL {
+				if err == io.EOF {
 					break
 				} else {
-					return ProtocolError(ErrDecode, "%v", err)
+					return self.protoError(ErrDecode, "msg %v: %v", msg, err)
 				}
 			}
-			self.blockPool.AddBlock(block, self.id)
+			self.blockPool.AddBlock(&block, self.id)
 		}
 
 	case NewBlockMsg:
 		var request newBlockMsgData
 		if err := msg.Decode(&request); err != nil {
-			return ProtocolError(ErrDecode, "%v", err)
+			return self.protoError(ErrDecode, "msg %v: %v", msg, err)
 		}
 		hash := request.Block.Hash()
 		// to simplify backend interface adding a new block
@@ -202,12 +212,12 @@ func (self *ethProtocol) handle() error {
 		// (or selected as new best peer)
 		if self.blockPool.AddPeer(request.TD, hash, self.id, self.requestBlockHashes, self.requestBlocks, self.protoErrorDisconnect) {
 			called := true
-			iter := func() (hash []byte, ok bool) {
+			iter := func() ([]byte, bool) {
 				if called {
 					called = false
 					return hash, true
 				} else {
-					return
+					return nil, false
 				}
 			}
 			self.blockPool.AddBlockHashes(iter, self.id)
@@ -215,14 +225,14 @@ func (self *ethProtocol) handle() error {
 		}
 
 	default:
-		return ProtocolError(ErrInvalidMsgCode, "%v", msg.Code)
+		return self.protoError(ErrInvalidMsgCode, "%v", msg.Code)
 	}
 	return nil
 }
 
 type statusMsgData struct {
-	ProtocolVersion uint
-	NetworkId       uint
+	ProtocolVersion uint32
+	NetworkId       uint32
 	TD              *big.Int
 	CurrentBlock    []byte
 	GenesisBlock    []byte
@@ -253,56 +263,56 @@ func (self *ethProtocol) handleStatus() error {
 	}
 
 	if msg.Code != StatusMsg {
-		return ProtocolError(ErrNoStatusMsg, "first msg has code %x (!= %x)", msg.Code, StatusMsg)
+		return self.protoError(ErrNoStatusMsg, "first msg has code %x (!= %x)", msg.Code, StatusMsg)
 	}
 
 	if msg.Size > ProtocolMaxMsgSize {
-		return ProtocolError(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize)
+		return self.protoError(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize)
 	}
 
 	var status statusMsgData
 	if err := msg.Decode(&status); err != nil {
-		return ProtocolError(ErrDecode, "%v", err)
+		return self.protoError(ErrDecode, "msg %v: %v", msg, err)
 	}
 
 	_, _, genesisBlock := self.chainManager.Status()
 
 	if bytes.Compare(status.GenesisBlock, genesisBlock) != 0 {
-		return ProtocolError(ErrGenesisBlockMismatch, "%x (!= %x)", status.GenesisBlock, genesisBlock)
+		return self.protoError(ErrGenesisBlockMismatch, "%x (!= %x)", status.GenesisBlock, genesisBlock)
 	}
 
 	if status.NetworkId != NetworkId {
-		return ProtocolError(ErrNetworkIdMismatch, "%d (!= %d)", status.NetworkId, NetworkId)
+		return self.protoError(ErrNetworkIdMismatch, "%d (!= %d)", status.NetworkId, NetworkId)
 	}
 
 	if ProtocolVersion != status.ProtocolVersion {
-		return ProtocolError(ErrProtocolVersionMismatch, "%d (!= %d)", status.ProtocolVersion, ProtocolVersion)
+		return self.protoError(ErrProtocolVersionMismatch, "%d (!= %d)", status.ProtocolVersion, ProtocolVersion)
 	}
 
 	self.peer.Infof("Peer is [eth] capable (%d/%d). TD=%v H=%x\n", status.ProtocolVersion, status.NetworkId, status.TD, status.CurrentBlock[:4])
 
-	//self.blockPool.AddPeer(status.TD, status.CurrentBlock, self.id, self.requestBlockHashes, self.requestBlocks, self.protoErrorDisconnect)
-	self.peer.Infoln("AddPeer(IGNORED)")
+	self.blockPool.AddPeer(status.TD, status.CurrentBlock, self.id, self.requestBlockHashes, self.requestBlocks, self.protoErrorDisconnect)
 
 	return nil
 }
 
 func (self *ethProtocol) requestBlockHashes(from []byte) error {
 	self.peer.Debugf("fetching hashes (%d) %x...\n", blockHashesBatchSize, from[0:4])
-	return self.rw.EncodeMsg(GetBlockHashesMsg, from, blockHashesBatchSize)
+	return self.rw.EncodeMsg(GetBlockHashesMsg, interface{}(from), uint64(blockHashesBatchSize))
 }
 
 func (self *ethProtocol) requestBlocks(hashes [][]byte) error {
 	self.peer.Debugf("fetching %v blocks", len(hashes))
-	return self.rw.EncodeMsg(GetBlocksMsg, ethutil.ByteSliceToInterface(hashes))
+	return self.rw.EncodeMsg(GetBlocksMsg, ethutil.ByteSliceToInterface(hashes)...)
 }
 
 func (self *ethProtocol) protoError(code int, format string, params ...interface{}) (err *protocolError) {
 	err = ProtocolError(code, format, params...)
 	if err.Fatal() {
-		self.peer.Errorln(err)
+		self.peer.Errorln("err %v", err)
+		// disconnect
 	} else {
-		self.peer.Debugln(err)
+		self.peer.Debugf("fyi %v", err)
 	}
 	return
 }
@@ -310,10 +320,10 @@ func (self *ethProtocol) protoError(code int, format string, params ...interface
 func (self *ethProtocol) protoErrorDisconnect(code int, format string, params ...interface{}) {
 	err := ProtocolError(code, format, params...)
 	if err.Fatal() {
-		self.peer.Errorln(err)
+		self.peer.Errorln("err %v", err)
 		// disconnect
 	} else {
-		self.peer.Debugln(err)
+		self.peer.Debugf("fyi %v", err)
 	}
 
 }
diff --git a/eth/protocol_test.go b/eth/protocol_test.go
index 322aec7b7..ab2aa289f 100644
--- a/eth/protocol_test.go
+++ b/eth/protocol_test.go
@@ -1,35 +1,48 @@
 package eth
 
 import (
+	"bytes"
 	"io"
+	"log"
 	"math/big"
+	"os"
 	"testing"
+	"time"
 
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethutil"
+	ethlogger "github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/p2p"
 )
 
+var sys = ethlogger.NewStdLogSystem(os.Stdout, log.LstdFlags, ethlogger.LogLevel(ethlogger.DebugDetailLevel))
+
 type testMsgReadWriter struct {
 	in  chan p2p.Msg
-	out chan p2p.Msg
+	out []p2p.Msg
 }
 
 func (self *testMsgReadWriter) In(msg p2p.Msg) {
 	self.in <- msg
 }
 
-func (self *testMsgReadWriter) Out(msg p2p.Msg) {
-	self.in <- msg
+func (self *testMsgReadWriter) Out() (msg p2p.Msg, ok bool) {
+	if len(self.out) > 0 {
+		msg = self.out[0]
+		self.out = self.out[1:]
+		ok = true
+	}
+	return
 }
 
 func (self *testMsgReadWriter) WriteMsg(msg p2p.Msg) error {
-	self.out <- msg
+	self.out = append(self.out, msg)
 	return nil
 }
 
 func (self *testMsgReadWriter) EncodeMsg(code uint64, data ...interface{}) error {
-	return self.WriteMsg(p2p.NewMsg(code, data))
+	return self.WriteMsg(p2p.NewMsg(code, data...))
 }
 
 func (self *testMsgReadWriter) ReadMsg() (p2p.Msg, error) {
@@ -40,145 +53,83 @@ func (self *testMsgReadWriter) ReadMsg() (p2p.Msg, error) {
 	return msg, nil
 }
 
-func errorCheck(t *testing.T, expCode int, err error) {
-	perr, ok := err.(*protocolError)
-	if ok && perr != nil {
-		if code := perr.Code; code != expCode {
-			ok = false
-		}
-	}
-	if !ok {
-		t.Errorf("expected error code %v, got %v", ErrNoStatusMsg, err)
-	}
-}
-
-type TestBackend struct {
+type testTxPool struct {
 	getTransactions func() []*types.Transaction
 	addTransactions func(txs []*types.Transaction)
-	getBlockHashes  func(hash []byte, amount uint32) (hashes [][]byte)
-	addBlockHashes  func(next func() ([]byte, bool), peerId string)
-	getBlock        func(hash []byte) *types.Block
-	addBlock        func(block *types.Block, peerId string) (err error)
-	addPeer         func(td *big.Int, currentBlock []byte, peerId string, requestHashes func([]byte) error, requestBlocks func([][]byte) error, invalidBlock func(error)) (best bool)
-	removePeer      func(peerId string)
-	status          func() (td *big.Int, currentBlock []byte, genesisBlock []byte)
 }
 
-func (self *TestBackend) GetTransactions() (txs []*types.Transaction) {
-	if self.getTransactions != nil {
-		txs = self.getTransactions()
-	}
-	return
+type testChainManager struct {
+	getBlockHashes func(hash []byte, amount uint64) (hashes [][]byte)
+	getBlock       func(hash []byte) *types.Block
+	status         func() (td *big.Int, currentBlock []byte, genesisBlock []byte)
 }
 
-func (self *TestBackend) AddTransactions(txs []*types.Transaction) {
+type testBlockPool struct {
+	addBlockHashes func(next func() ([]byte, bool), peerId string)
+	addBlock       func(block *types.Block, peerId string) (err error)
+	addPeer        func(td *big.Int, currentBlock []byte, peerId string, requestHashes func([]byte) error, requestBlocks func([][]byte) error, peerError func(int, string, ...interface{})) (best bool)
+	removePeer     func(peerId string)
+}
+
+// func (self *testTxPool) GetTransactions() (txs []*types.Transaction) {
+// 	if self.getTransactions != nil {
+// 		txs = self.getTransactions()
+// 	}
+// 	return
+// }
+
+func (self *testTxPool) AddTransactions(txs []*types.Transaction) {
 	if self.addTransactions != nil {
 		self.addTransactions(txs)
 	}
 }
 
-func (self *TestBackend) GetBlockHashes(hash []byte, amount uint32) (hashes [][]byte) {
+func (self *testChainManager) GetBlockHashesFromHash(hash []byte, amount uint64) (hashes [][]byte) {
 	if self.getBlockHashes != nil {
 		hashes = self.getBlockHashes(hash, amount)
 	}
 	return
 }
 
-<<<<<<< HEAD
-<<<<<<< HEAD
-func (self *TestBackend) AddBlockHashes(next func() ([]byte, bool), peerId string) {
-	if self.addBlockHashes != nil {
-		self.addBlockHashes(next, peerId)
-	}
-}
-
-=======
-func (self *TestBackend) AddHash(hash []byte, peer *p2p.Peer) (more bool) {
-	if self.addHash != nil {
-		more = self.addHash(hash, peer)
-=======
-func (self *TestBackend) AddBlockHashes(next func() ([]byte, bool), peerId string) {
-	if self.addBlockHashes != nil {
-		self.addBlockHashes(next, peerId)
->>>>>>> eth protocol changes
+func (self *testChainManager) Status() (td *big.Int, currentBlock []byte, genesisBlock []byte) {
+	if self.status != nil {
+		td, currentBlock, genesisBlock = self.status()
 	}
+	return
 }
-<<<<<<< HEAD
->>>>>>> initial commit for eth-p2p integration
-=======
 
->>>>>>> eth protocol changes
-func (self *TestBackend) GetBlock(hash []byte) (block *types.Block) {
+func (self *testChainManager) GetBlock(hash []byte) (block *types.Block) {
 	if self.getBlock != nil {
 		block = self.getBlock(hash)
 	}
 	return
 }
 
-<<<<<<< HEAD
-<<<<<<< HEAD
-func (self *TestBackend) AddBlock(block *types.Block, peerId string) (err error) {
-	if self.addBlock != nil {
-		err = self.addBlock(block, peerId)
-=======
-func (self *TestBackend) AddBlock(td *big.Int, block *types.Block, peer *p2p.Peer) (fetchHashes bool, err error) {
-	if self.addBlock != nil {
-		fetchHashes, err = self.addBlock(td, block, peer)
->>>>>>> initial commit for eth-p2p integration
-=======
-func (self *TestBackend) AddBlock(block *types.Block, peerId string) (err error) {
+func (self *testBlockPool) AddBlockHashes(next func() ([]byte, bool), peerId string) {
+	if self.addBlockHashes != nil {
+		self.addBlockHashes(next, peerId)
+	}
+}
+
+func (self *testBlockPool) AddBlock(block *types.Block, peerId string) {
 	if self.addBlock != nil {
-		err = self.addBlock(block, peerId)
->>>>>>> eth protocol changes
+		self.addBlock(block, peerId)
 	}
-	return
 }
 
-<<<<<<< HEAD
-<<<<<<< HEAD
-func (self *TestBackend) AddPeer(td *big.Int, currentBlock []byte, peerId string, requestBlockHashes func([]byte) error, requestBlocks func([][]byte) error, invalidBlock func(error)) (best bool) {
-	if self.addPeer != nil {
-		best = self.addPeer(td, currentBlock, peerId, requestBlockHashes, requestBlocks, invalidBlock)
-=======
-func (self *TestBackend) AddPeer(td *big.Int, currentBlock []byte, peer *p2p.Peer) (fetchHashes bool) {
+func (self *testBlockPool) AddPeer(td *big.Int, currentBlock []byte, peerId string, requestBlockHashes func([]byte) error, requestBlocks func([][]byte) error, peerError func(int, string, ...interface{})) (best bool) {
 	if self.addPeer != nil {
-		fetchHashes = self.addPeer(td, currentBlock, peer)
->>>>>>> initial commit for eth-p2p integration
-=======
-func (self *TestBackend) AddPeer(td *big.Int, currentBlock []byte, peerId string, requestBlockHashes func([]byte) error, requestBlocks func([][]byte) error, invalidBlock func(error)) (best bool) {
-	if self.addPeer != nil {
-		best = self.addPeer(td, currentBlock, peerId, requestBlockHashes, requestBlocks, invalidBlock)
->>>>>>> eth protocol changes
+		best = self.addPeer(td, currentBlock, peerId, requestBlockHashes, requestBlocks, peerError)
 	}
 	return
 }
 
-<<<<<<< HEAD
-<<<<<<< HEAD
-=======
->>>>>>> eth protocol changes
-func (self *TestBackend) RemovePeer(peerId string) {
+func (self *testBlockPool) RemovePeer(peerId string) {
 	if self.removePeer != nil {
 		self.removePeer(peerId)
 	}
 }
 
-<<<<<<< HEAD
-=======
->>>>>>> initial commit for eth-p2p integration
-=======
->>>>>>> eth protocol changes
-func (self *TestBackend) Status() (td *big.Int, currentBlock []byte, genesisBlock []byte) {
-	if self.status != nil {
-		td, currentBlock, genesisBlock = self.status()
-	}
-	return
-}
-
-<<<<<<< HEAD
-<<<<<<< HEAD
-=======
->>>>>>> eth protocol changes
 // TODO: refactor this into p2p/client_identity
 type peerId struct {
 	pubkey []byte
@@ -201,32 +152,119 @@ func testPeer() *p2p.Peer {
 	return p2p.NewPeer(&peerId{}, []p2p.Cap{})
 }
 
-func TestErrNoStatusMsg(t *testing.T) {
-<<<<<<< HEAD
-=======
-func TestEth(t *testing.T) {
->>>>>>> initial commit for eth-p2p integration
-=======
->>>>>>> eth protocol changes
-	quit := make(chan bool)
-	rw := &testMsgReadWriter{make(chan p2p.Msg, 10), make(chan p2p.Msg, 10)}
-	testBackend := &TestBackend{}
-	var err error
-	go func() {
-<<<<<<< HEAD
-<<<<<<< HEAD
-		err = runEthProtocol(testBackend, testPeer(), rw)
-=======
-		err = runEthProtocol(testBackend, nil, rw)
->>>>>>> initial commit for eth-p2p integration
-=======
-		err = runEthProtocol(testBackend, testPeer(), rw)
->>>>>>> eth protocol changes
-		close(quit)
-	}()
+type ethProtocolTester struct {
+	quit         chan error
+	rw           *testMsgReadWriter // p2p.MsgReadWriter
+	txPool       *testTxPool        // txPool
+	chainManager *testChainManager  // chainManager
+	blockPool    *testBlockPool     // blockPool
+	t            *testing.T
+}
+
+func newEth(t *testing.T) *ethProtocolTester {
+	return &ethProtocolTester{
+		quit:         make(chan error),
+		rw:           &testMsgReadWriter{in: make(chan p2p.Msg, 10)},
+		txPool:       &testTxPool{},
+		chainManager: &testChainManager{},
+		blockPool:    &testBlockPool{},
+		t:            t,
+	}
+}
+
+func (self *ethProtocolTester) reset() {
+	self.rw = &testMsgReadWriter{in: make(chan p2p.Msg, 10)}
+	self.quit = make(chan error)
+}
+
+func (self *ethProtocolTester) checkError(expCode int, delay time.Duration) (err error) {
+	var timer = time.After(delay)
+	select {
+	case err = <-self.quit:
+	case <-timer:
+		self.t.Errorf("no error after %v, expected %v", delay, expCode)
+		return
+	}
+	perr, ok := err.(*protocolError)
+	if ok && perr != nil {
+		if code := perr.Code; code != expCode {
+			self.t.Errorf("expected protocol error (code %v), got %v (%v)", expCode, code, err)
+		}
+	} else {
+		self.t.Errorf("expected protocol error (code %v), got %v", expCode, err)
+	}
+	return
+}
+
+func (self *ethProtocolTester) In(msg p2p.Msg) {
+	self.rw.In(msg)
+}
+
+func (self *ethProtocolTester) Out() (p2p.Msg, bool) {
+	return self.rw.Out()
+}
+
+func (self *ethProtocolTester) checkMsg(i int, code uint64, val interface{}) (msg p2p.Msg) {
+	if i >= len(self.rw.out) {
+		self.t.Errorf("expected at least %v msgs, got %v", i, len(self.rw.out))
+		return
+	}
+	msg = self.rw.out[i]
+	if msg.Code != code {
+		self.t.Errorf("expected msg code %v, got %v", code, msg.Code)
+	}
+	if val != nil {
+		if err := msg.Decode(val); err != nil {
+			self.t.Errorf("rlp encoding error: %v", err)
+		}
+	}
+	return
+}
+
+func (self *ethProtocolTester) run() {
+	err := runEthProtocol(self.txPool, self.chainManager, self.blockPool, testPeer(), self.rw)
+	self.quit <- err
+}
+
+func TestStatusMsgErrors(t *testing.T) {
+	logInit()
+	eth := newEth(t)
+	td := ethutil.Big1
+	currentBlock := []byte{1}
+	genesis := []byte{2}
+	eth.chainManager.status = func() (*big.Int, []byte, []byte) { return td, currentBlock, genesis }
+	go eth.run()
 	statusMsg := p2p.NewMsg(4)
-	rw.In(statusMsg)
-	<-quit
-	errorCheck(t, ErrNoStatusMsg, err)
-	// read(t, remote, []byte("hello, world"), nil)
+	eth.In(statusMsg)
+	delay := 1 * time.Second
+	eth.checkError(ErrNoStatusMsg, delay)
+	var status statusMsgData
+	eth.checkMsg(0, StatusMsg, &status) // first outgoing msg should be StatusMsg
+	if status.TD.Cmp(td) != 0 ||
+		status.ProtocolVersion != ProtocolVersion ||
+		status.NetworkId != NetworkId ||
+		status.TD.Cmp(td) != 0 ||
+		bytes.Compare(status.CurrentBlock, currentBlock) != 0 ||
+		bytes.Compare(status.GenesisBlock, genesis) != 0 {
+		t.Errorf("incorrect outgoing status")
+	}
+
+	eth.reset()
+	go eth.run()
+	statusMsg = p2p.NewMsg(0, uint32(48), uint32(0), td, currentBlock, genesis)
+	eth.In(statusMsg)
+	eth.checkError(ErrProtocolVersionMismatch, delay)
+
+	eth.reset()
+	go eth.run()
+	statusMsg = p2p.NewMsg(0, uint32(49), uint32(1), td, currentBlock, genesis)
+	eth.In(statusMsg)
+	eth.checkError(ErrNetworkIdMismatch, delay)
+
+	eth.reset()
+	go eth.run()
+	statusMsg = p2p.NewMsg(0, uint32(49), uint32(0), td, currentBlock, []byte{3})
+	eth.In(statusMsg)
+	eth.checkError(ErrGenesisBlockMismatch, delay)
+
 }
diff --git a/eth/test/README.md b/eth/test/README.md
new file mode 100644
index 000000000..65728efa5
--- /dev/null
+++ b/eth/test/README.md
@@ -0,0 +1,27 @@
+= Integration tests for eth protocol and blockpool 
+
+This is a simple suite of tests to fire up a local test node with peers to test blockchain synchronisation and download. 
+The scripts call ethereum (assumed to be compiled in go-ethereum root). 
+
+To run a test:
+
+    . run.sh 00 02
+
+Without arguments, all tests are run. 
+
+Peers are launched with preloaded imported chains. In order to prevent them from synchronizing with each other they are set with `-dial=false` and `-maxpeer 1` options. They log into `/tmp/eth.test/nodes/XX` where XX is the last two digits of their port. 
+
+Chains to import can be bootstrapped by letting nodes mine for some time. This is done with 
+
+    . bootstrap.sh 
+
+Only the relative timing and forks matter so they should work if the bootstrap script is rerun. 
+The reference blockchain of tests are soft links to these import chains and check at the end of a test run. 
+
+Connecting to peers and exporting blockchain is scripted with JS files executed by the JSRE, see `tests/XX.sh`. 
+
+Each test is set with a timeout. This may vary on different computers so adjust sensibly. 
+If you kill a test before it completes, do not forget to kill all the background processes, since they will impact the result. Use:
+
+    killall ethereum
+
diff --git a/eth/test/bootstrap.sh b/eth/test/bootstrap.sh
new file mode 100644
index 000000000..3da038be8
--- /dev/null
+++ b/eth/test/bootstrap.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+# bootstrap chains - used to regenerate tests/chains/*.chain
+
+mkdir -p chains
+bash ./mine.sh 00 10
+bash ./mine.sh 01 5 00
+bash ./mine.sh 02 10 00
+bash ./mine.sh 03 5 02
+bash ./mine.sh 04 10 02
\ No newline at end of file
diff --git a/eth/test/chains/00.chain b/eth/test/chains/00.chain
new file mode 100755
index 000000000..ad3c05b24
--- /dev/null
+++ b/eth/test/chains/00.chain
diff --git a/eth/test/chains/01.chain b/eth/test/chains/01.chain
new file mode 100755
index 000000000..56c9aef65
--- /dev/null
+++ b/eth/test/chains/01.chain
diff --git a/eth/test/chains/02.chain b/eth/test/chains/02.chain
new file mode 100755
index 000000000..440c92d65
--- /dev/null
+++ b/eth/test/chains/02.chain
diff --git a/eth/test/chains/03.chain b/eth/test/chains/03.chain
new file mode 100755
index 000000000..1cc7570ab
--- /dev/null
+++ b/eth/test/chains/03.chain
diff --git a/eth/test/chains/04.chain b/eth/test/chains/04.chain
new file mode 100755
index 000000000..d4e5b1aa8
--- /dev/null
+++ b/eth/test/chains/04.chain
diff --git a/eth/test/mine.sh b/eth/test/mine.sh
new file mode 100644
index 000000000..0d95db1e4
--- /dev/null
+++ b/eth/test/mine.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+# bash ./mine.sh node_id timeout(sec) [basechain]
+ETH=../../ethereum
+MINE="$ETH -datadir tmp/nodes/$1 -seed=false -port '' -shh=false -id test$1"
+rm -rf tmp/nodes/$1
+echo "Creating chain $1..."
+if [[ "" !=  "$3" ]]; then
+  CHAIN="chains/$3.chain"
+  CHAINARG="-chain $CHAIN"
+  $MINE -mine $CHAINARG -loglevel 3 | grep 'importing'
+fi
+$MINE -mine -loglevel 0 &
+PID=$!
+sleep $2
+kill $PID
+$MINE -loglevel 3 <(echo "eth.export(\"chains/$1.chain\")") > /tmp/eth.test/mine.tmp &
+PID=$!
+sleep 1
+kill $PID
+cat /tmp/eth.test/mine.tmp | grep 'exporting'
diff --git a/eth/test/run.sh b/eth/test/run.sh
new file mode 100644
index 000000000..5229af035
--- /dev/null
+++ b/eth/test/run.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+# bash run.sh (testid0 testid1 ...)
+# runs tests tests/testid0.sh tests/testid1.sh ...
+# without arguments, it runs all tests
+
+. tests/common.sh
+
+TESTS=
+
+if [ "$#" -eq 0 ]; then
+  for NAME in tests/??.sh; do
+    i=`basename $NAME .sh`
+    TESTS="$TESTS $i"
+  done
+else
+  TESTS=$@
+fi
+
+ETH=../../ethereum
+DIR="/tmp/eth.test/nodes"
+TIMEOUT=10
+
+mkdir -p $DIR/js
+
+echo "running tests $TESTS"
+for NAME in $TESTS; do
+  PIDS=
+  CHAIN="tests/$NAME.chain"
+  JSFILE="$DIR/js/$NAME.js"
+  CHAIN_TEST="$DIR/$NAME/chain"
+
+  echo "RUN: test $NAME"
+  cat tests/common.js > $JSFILE
+  . tests/$NAME.sh
+  sleep $TIMEOUT
+  echo "timeout after $TIMEOUT seconds: killing $PIDS"
+  kill $PIDS
+  if [ -r "$CHAIN" ]; then
+    if diff $CHAIN $CHAIN_TEST >/dev/null ; then
+      echo "chain ok: $CHAIN=$CHAIN_TEST"
+    else
+      echo "FAIL: chains differ: expected $CHAIN ; got $CHAIN_TEST"
+      continue
+    fi
+  fi
+  ERRORS=$DIR/errors
+  if [ -r "$ERRORS" ]; then
+    echo "FAIL: "
+    cat $ERRORS
+  else
+    echo PASS
+  fi
+done
\ No newline at end of file
diff --git a/eth/test/tests/00.chain b/eth/test/tests/00.chain
new file mode 120000
index 000000000..9655cb3df
--- /dev/null
+++ b/eth/test/tests/00.chain
@@ -0,0 +1 @@
+../chains/01.chain
\ No newline at end of file
diff --git a/eth/test/tests/00.sh b/eth/test/tests/00.sh
new file mode 100644
index 000000000..9c5077164
--- /dev/null
+++ b/eth/test/tests/00.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+TIMEOUT=4
+
+cat >> $JSFILE <<EOF
+eth.addPeer("localhost:30311");
+sleep(1000)
+eth.export("$CHAIN_TEST");
+EOF
+
+peer 11 01
+test_node $NAME "" -loglevel 5 $JSFILE
+
diff --git a/eth/test/tests/01.chain b/eth/test/tests/01.chain
new file mode 120000
index 000000000..ae65ccb37
--- /dev/null
+++ b/eth/test/tests/01.chain
@@ -0,0 +1 @@
+../chains/02.chain
\ No newline at end of file
diff --git a/eth/test/tests/01.sh b/eth/test/tests/01.sh
new file mode 100644
index 000000000..1601e0dfb
--- /dev/null
+++ b/eth/test/tests/01.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+TIMEOUT=5
+
+cat >> $JSFILE <<EOF
+eth.addPeer("localhost:30311");
+log("added peer localhost:30311");
+sleep(1000);
+log("added peer localhost:30312");
+eth.addPeer("localhost:30312");
+sleep(3000);
+eth.export("$CHAIN_TEST");
+EOF
+
+peer 11 01
+peer 12 02
+test_node $NAME "" -loglevel 5 $JSFILE
+
diff --git a/eth/test/tests/02.chain b/eth/test/tests/02.chain
new file mode 120000
index 000000000..9655cb3df
--- /dev/null
+++ b/eth/test/tests/02.chain
@@ -0,0 +1 @@
+../chains/01.chain
\ No newline at end of file
diff --git a/eth/test/tests/02.sh b/eth/test/tests/02.sh
new file mode 100644
index 000000000..5231dbd78
--- /dev/null
+++ b/eth/test/tests/02.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+TIMEOUT=6
+
+cat >> $JSFILE <<EOF
+eth.addPeer("localhost:30311");
+sleep(200);
+eth.addPeer("localhost:30312");
+sleep(3000);
+eth.export("$CHAIN_TEST");
+EOF
+
+peer 11 01
+peer 12 02
+P13ID=$PID
+test_node $NAME "" -loglevel 5 $JSFILE
+sleep 0.5
+kill $P13ID
+
diff --git a/eth/test/tests/03.chain b/eth/test/tests/03.chain
new file mode 120000
index 000000000..b07c49a30
--- /dev/null
+++ b/eth/test/tests/03.chain
@@ -0,0 +1 @@
+../chains/12k.chain
\ No newline at end of file
diff --git a/eth/test/tests/03.sh b/eth/test/tests/03.sh
new file mode 100644
index 000000000..8c9d6565e
--- /dev/null
+++ b/eth/test/tests/03.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+
+TIMEOUT=35
+
+cat >> $JSFILE <<EOF
+eth.addPeer("localhost:30311");
+sleep(30000);
+eth.export("$CHAIN_TEST");
+EOF
+
+peer 11 12k
+sleep 2
+test_node $NAME "" -loglevel 5 $JSFILE
+
diff --git a/eth/test/tests/04.sh b/eth/test/tests/04.sh
new file mode 100644
index 000000000..d77c360ba
--- /dev/null
+++ b/eth/test/tests/04.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+TIMEOUT=15
+
+cat >> $JSFILE <<EOF
+eth.addPeer("localhost:30311");
+sleep(200);
+eth.addPeer("localhost:30312");
+sleep(13000);
+eth.export("$CHAIN_TEST");
+EOF
+
+peer 11 01 -mine
+peer 12 02
+test_node $NAME "" -loglevel 5 $JSFILE
+sleep 6
+cat $DIR/$NAME/debug.log | grep 'best peer'
diff --git a/eth/test/tests/05.sh b/eth/test/tests/05.sh
new file mode 100644
index 000000000..0a0f94df5
--- /dev/null
+++ b/eth/test/tests/05.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+TIMEOUT=60
+
+cat >> $JSFILE <<EOF
+eth.addPeer("localhost:30311");
+sleep(200);
+eth.addPeer("localhost:30312");
+eth.addPeer("localhost:30313");
+eth.addPeer("localhost:30314");
+sleep(3000);
+eth.export("$CHAIN_TEST");
+EOF
+
+peer 11 01 -mine
+peer 12 02 -mine
+peer 13 03
+peer 14 04
+test_node $NAME "" -loglevel 5 $JSFILE
+
diff --git a/eth/test/tests/common.js b/eth/test/tests/common.js
new file mode 100644
index 000000000..206ebf145
--- /dev/null
+++ b/eth/test/tests/common.js
@@ -0,0 +1,9 @@
+function log(text) {
+  console.log("[JS TEST SCRIPT] " + text);
+}
+
+function sleep(seconds) {
+    var now = new Date().getTime();
+    while(new Date().getTime() < now + seconds){}
+}
+
diff --git a/eth/test/tests/common.sh b/eth/test/tests/common.sh
new file mode 100644
index 000000000..74db073f7
--- /dev/null
+++ b/eth/test/tests/common.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# launched by run.sh
+function test_node {
+  rm -rf $DIR/$1
+  ARGS="-datadir $DIR/$1 -debug debug -seed=false -shh=false -id test$1"
+  if [ "" != "$2" ]; then
+    chain="chains/$2.chain"
+    echo "import chain $chain"
+    $ETH $ARGS -loglevel 3 -chain $chain | grep CLI |grep import
+  fi
+  echo "starting test node $1 with extra args ${@:3}"
+  $ETH $ARGS -port 303$1 ${@:3} &
+  PID=$!
+  PIDS="$PIDS $PID"
+}
+
+function peer {
+  test_node $@ -loglevel 5 -logfile debug.log -maxpeer 1 -dial=false
+}
\ No newline at end of file