app: new app test flow (#244)

9 files changed, 2289 insertions, 70 deletions

diff --git a/core/blockchain.go b/core/blockchain.go
index aa2326c8d..f829c0e8e 100644
--- a/core/blockchain.go
+++ b/core/blockchain.go
@@ -931,13 +931,6 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 			bytes += batch.ValueSize()
 			batch.Reset()
 		}
-
-		if i == len(blockChain)-1 {
-			err := bc.updateLastRoundNumber(block.Round())
-			if err != nil {
-				return 0, err
-			}
-		}
 	}
 	if batch.ValueSize() > 0 {
 		bytes += batch.ValueSize()
@@ -1664,13 +1657,6 @@ func (bc *BlockChain) insertDexonChain(chain types.Blocks) (int, []interface{},
 
 		cache, _ := bc.stateCache.TrieDB().Size()
 		stats.report(chain, i, cache)
-
-		if i == len(chain)-1 {
-			err = bc.updateLastRoundNumber(block.Round())
-			if err != nil {
-				return 0, nil, nil, err
-			}
-		}
 	}
 	// Append a single chain head event if we've progressed the chain
 	if lastCanon != nil && bc.CurrentBlock().Hash() == lastCanon.Hash() {
@@ -1807,11 +1793,6 @@ func (bc *BlockChain) processBlock(
 	cache, _ := bc.stateCache.TrieDB().Size()
 	stats.report([]*types.Block{newBlock}, 0, cache)
 
-	err = bc.updateLastRoundNumber(newBlock.Round())
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
 	return &root, events, coalescedLogs, nil
 }
 
@@ -1894,11 +1875,6 @@ func (bc *BlockChain) ProcessEmptyBlock(block *types.Block) (*common.Hash, error
 	cache, _ := bc.stateCache.TrieDB().Size()
 	stats.report([]*types.Block{newBlock}, 0, cache)
 
-	err = bc.updateLastRoundNumber(newBlock.Round())
-	if err != nil {
-		return nil, err
-	}
-
 	bc.PostChainEvents([]interface{}{ChainEvent{newBlock, newBlock.Hash(), nil},
 		ChainHeadEvent{newBlock}}, nil)
 
@@ -2327,19 +2303,3 @@ func (bc *BlockChain) GetRoundHeight(round uint64) (uint64, bool) {
 func (bc *BlockChain) storeRoundHeight(round uint64, height uint64) {
 	bc.roundHeightMap.Store(round, height)
 }
-
-func (bc *BlockChain) updateLastRoundNumber(round uint64) error {
-	currentLastRound, err := rawdb.ReadLastRoundNumber(bc.db)
-	if err != nil {
-		return err
-	}
-
-	if round > currentLastRound {
-		err = rawdb.WriteLastRoundNumber(bc.db, round)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
diff --git a/core/blockchain_test.go b/core/blockchain_test.go
index f972eb0b2..f8956da46 100644
--- a/core/blockchain_test.go
+++ b/core/blockchain_test.go
@@ -654,9 +654,6 @@ func TestFastVsFullChains(t *testing.T) {
 	// Fast import the chain as a non-archive node to test
 	fastDb := ethdb.NewMemDatabase()
 	gspec.MustCommit(fastDb)
-	if err := rawdb.WriteLastRoundNumber(fastDb, 0); err != nil {
-		t.Fatalf("failed to write last round: %v", err)
-	}
 	fast, _ := NewBlockChain(fastDb, nil, gspec.Config, ethash.NewFaker(), vm.Config{}, nil)
 	defer fast.Stop()
 
@@ -748,9 +745,6 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) {
 	// Import the chain as a non-archive node and ensure all pointers are updated
 	fastDb := ethdb.NewMemDatabase()
 	gspec.MustCommit(fastDb)
-	if err := rawdb.WriteLastRoundNumber(fastDb, 0); err != nil {
-		t.Fatalf("failed to write last round: %v", err)
-	}
 	fast, _ := NewBlockChain(fastDb, nil, gspec.Config, ethash.NewFaker(), vm.Config{}, nil)
 	defer fast.Stop()
 
diff --git a/core/genesis.go b/core/genesis.go
index 7f2cafbf5..f2df4f62f 100644
--- a/core/genesis.go
+++ b/core/genesis.go
@@ -169,8 +169,6 @@ func SetupGenesisBlock(db ethdb.Database, genesis *Genesis) (*params.ChainConfig
 	return SetupGenesisBlockWithOverride(db, genesis, nil)
 }
 func SetupGenesisBlockWithOverride(db ethdb.Database, genesis *Genesis, constantinopleOverride *big.Int) (*params.ChainConfig, common.Hash, error) {
-	rawdb.WriteLastRoundNumber(db, 0)
-
 	if genesis != nil && genesis.Config == nil {
 		return params.AllEthashProtocolChanges, common.Hash{}, errGenesisNoConfig
 	}
diff --git a/core/rawdb/accessors_chain.go b/core/rawdb/accessors_chain.go
index 5e23bef8f..801ad9362 100644
--- a/core/rawdb/accessors_chain.go
+++ b/core/rawdb/accessors_chain.go
@@ -348,21 +348,6 @@ func WriteBlock(db DatabaseWriter, block *types.Block) {
 	WriteHeader(db, block.Header())
 }
 
-// ReadLastRoundNumber get current round number.
-func ReadLastRoundNumber(db DatabaseReader) (uint64, error) {
-	number, err := db.Get(lastRoundNum)
-	if err != nil {
-		return 0, err
-	}
-
-	return new(big.Int).SetBytes(number).Uint64(), nil
-}
-
-// WriteLastRoundNumber write current round number.
-func WriteLastRoundNumber(db DatabaseWriter, number uint64) error {
-	return db.Put(lastRoundNum, new(big.Int).SetUint64(number).Bytes())
-}
-
 // DeleteBlock removes all block data associated with a hash.
 func DeleteBlock(db DatabaseDeleter, hash common.Hash, number uint64) {
 	DeleteReceipts(db, hash, number)
diff --git a/core/rawdb/schema.go b/core/rawdb/schema.go
index 954ebfc1d..87a56c0ba 100644
--- a/core/rawdb/schema.go
+++ b/core/rawdb/schema.go
@@ -63,8 +63,6 @@ var (
 	// Chain index prefixes (use `i` + single byte to avoid mixing data types).
 	BloomBitsIndexPrefix = []byte("iB") // BloomBitsIndexPrefix is the data table of a chain indexer to track its progress
 
-	lastRoundNum = []byte("LastRoundNum")
-
 	preimageCounter    = metrics.NewRegisteredCounter("db/preimage/total", nil)
 	preimageHitCounter = metrics.NewRegisteredCounter("db/preimage/hits", nil)
 )
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 1719b4b4e..e7dbab0d2 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -429,6 +429,14 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 	pool.promoteExecutables(nil)
 }
 
+// Reset only for testing.
+func (pool *TxPool) Reset(newHead *types.Header) {
+	pool.mu.Lock()
+	defer pool.mu.Unlock()
+
+	pool.reset(nil, newHead)
+}
+
 // Stop terminates the transaction pool.
 func (pool *TxPool) Stop() {
 	// Unsubscribe all subscriptions registered from txpool
diff --git a/dex/app.go b/dex/app.go
index eabdf52f5..90ffd3d3c 100644
--- a/dex/app.go
+++ b/dex/app.go
@@ -516,7 +516,11 @@ func (d *DexconApp) addConfirmedBlock(block *coreTypes.Block) error {
 		}
 
 		// get latest nonce in block
-		d.addressNonce[msg.From()] = msg.Nonce()
+		if nonce, exist := d.addressNonce[msg.From()]; !exist || nonce < msg.Nonce() {
+			d.addressNonce[msg.From()] = msg.Nonce()
+		} else {
+			return fmt.Errorf("address %v nonce incorrect cached(%d) >= tx(%d)", msg.From(), nonce, msg.Nonce())
+		}
 
 		// calculate max cost in confirmed blocks
 		if d.addressCost[msg.From()] == nil {
diff --git a/dex/app_test.go b/dex/app_test.go
new file mode 100644
index 000000000..59db1cb22
--- /dev/null
+++ b/dex/app_test.go
@@ -0,0 +1,2276 @@
+package dex
+
+import (
+	"crypto/ecdsa"
+	"fmt"
+	"math/big"
+	"math/rand"
+	"reflect"
+	"sync"
+	"testing"
+	"time"
+
+	coreCommon "github.com/dexon-foundation/dexon-consensus/common"
+	coreCrypto "github.com/dexon-foundation/dexon-consensus/core/crypto"
+	coreEcdsa "github.com/dexon-foundation/dexon-consensus/core/crypto/ecdsa"
+	coreTypes "github.com/dexon-foundation/dexon-consensus/core/types"
+	"github.com/dexon-foundation/dexon/common"
+	"github.com/dexon-foundation/dexon/common/math"
+	"github.com/dexon-foundation/dexon/consensus/dexcon"
+	"github.com/dexon-foundation/dexon/core"
+	"github.com/dexon-foundation/dexon/core/rawdb"
+	"github.com/dexon-foundation/dexon/core/types"
+	"github.com/dexon-foundation/dexon/core/vm"
+	"github.com/dexon-foundation/dexon/crypto"
+	"github.com/dexon-foundation/dexon/ethdb"
+	"github.com/dexon-foundation/dexon/event"
+	"github.com/dexon-foundation/dexon/log"
+	"github.com/dexon-foundation/dexon/rlp"
+)
+
+type singnal int
+
+const (
+	runFail singnal = iota
+	runSuccess
+)
+
+type App interface {
+	PreparePayload(position coreTypes.Position) (payload []byte, err error)
+	PrepareWitness(height uint64) (witness coreTypes.Witness, err error)
+	VerifyBlock(block *coreTypes.Block) coreTypes.BlockVerifyStatus
+	BlockConfirmed(block coreTypes.Block)
+	BlockDelivered(blockHash coreCommon.Hash, position coreTypes.Position, result coreTypes.FinalizationResult)
+	SubscribeNewFinalizedBlockEvent(ch chan<- core.NewFinalizedBlockEvent) event.Subscription
+	Stop()
+}
+
+type Product interface{}
+
+type Tester interface {
+	// Name the name of tester
+	Name() string
+
+	// ViewAndRecord view the data and record then start when requirement is ready.
+	ViewAndRecord(product Product)
+
+	// ReadyToTest check tester is ready or not.
+	ReadyToTest() bool
+
+	// InputsForTest return the inputs which we want to test, it will be called only when it is get ready.
+	InputsForTest(product Product) []reflect.Value
+
+	// ValidateResults validate the results what we expected.
+	ValidateResults(results []reflect.Value) error
+
+	// Done return true when tester finish it job.
+	Done() bool
+
+	// StopTime lock all working jobs for test and rollback data if necessary.
+	StopTime() bool
+
+	// Rollback rollback data in the final.
+	Rollback() error
+}
+
+type baseTester struct {
+	App
+
+	ready bool
+
+	testTimer    *time.Timer
+	testInterval time.Duration
+
+	counter   int
+	threshold int
+
+	self interface{}
+}
+
+func (t baseTester) Name() string {
+	return reflect.TypeOf(t.self).Name()
+}
+
+func (t baseTester) ReadyToTest() bool {
+	return t.ready
+}
+
+func (t baseTester) Done() bool {
+	return t.counter >= t.threshold
+}
+
+func (t baseTester) StopTime() bool {
+	return false
+}
+
+func (t *baseTester) Rollback() error {
+	return nil
+}
+
+func (t *baseTester) ViewAndRecord(product Product) {
+	panic("need to implement")
+}
+
+func (t baseTester) InputsForTest(product Product) []reflect.Value {
+	panic("need to implement")
+}
+
+func (t *baseTester) ValidateResults(results []reflect.Value) error {
+	panic("need to implement")
+}
+
+type takerName string
+
+type makerName string
+
+type ProductCenter struct {
+	takerChan map[takerName]chan Product
+
+	takerList map[makerName]map[takerName]struct{}
+}
+
+// RequestProduct make a blocking request the product from maker.
+func (center *ProductCenter) RequestProduct(tName takerName) Product {
+	p := <-center.takerChan[tName]
+	return p
+}
+
+// DeliverProduct deliver product for takers.
+func (center *ProductCenter) DeliverProduct(mName makerName, product Product) {
+	for tName := range center.takerList[mName] {
+		center.takerChan[tName] <- product
+	}
+}
+
+// Register build the connection between taker and maker.
+func (center *ProductCenter) Register(tName takerName, mName ...makerName) {
+	center.takerChan[tName] = make(chan Product, 1000)
+
+	for _, n := range mName {
+		if _, exist := center.takerList[n]; !exist {
+			center.takerList[n] = make(map[takerName]struct{})
+			center.takerList[n][tName] = struct{}{}
+		} else {
+			center.takerList[n][tName] = struct{}{}
+		}
+	}
+}
+
+func (center ProductCenter) New() *ProductCenter {
+	center.takerChan = map[takerName]chan Product{}
+	center.takerList = map[makerName]map[takerName]struct{}{}
+	return &center
+}
+
+type FactoryBase struct {
+	App
+
+	targetFunc interface{}
+
+	name string
+
+	center *ProductCenter
+
+	testers []Tester
+
+	status chan map[singnal]interface{}
+
+	stopTimeMu *sync.RWMutex
+}
+
+func (base *FactoryBase) testerDoWork(product Product) error {
+	for _, t := range base.testers {
+		if t.Done() {
+			continue
+		}
+
+		if err := func() (tErr error) {
+			var returns []reflect.Value
+			defer func() {
+				r := recover()
+				if r != nil {
+					returns = append(returns, reflect.ValueOf(fmt.Errorf("%v", r)))
+				}
+
+				if t.ReadyToTest() {
+					err := t.ValidateResults(returns)
+					if err != nil {
+						tErr = err
+						return
+					}
+
+					err = t.Rollback()
+					if err != nil {
+						tErr = fmt.Errorf("recover fail: %v", tErr)
+						return
+					}
+				} else if r != nil {
+					tErr = fmt.Errorf("%v", r)
+				}
+
+				if t.StopTime() {
+					base.stopTimeMu.Unlock()
+				} else {
+					base.stopTimeMu.RUnlock()
+				}
+			}()
+
+			if t.StopTime() {
+				base.stopTimeMu.Lock()
+			} else {
+				base.stopTimeMu.RLock()
+			}
+			t.ViewAndRecord(product)
+			if t.ReadyToTest() {
+				inputs := t.InputsForTest(product)
+				returns = reflect.ValueOf(base.targetFunc).Call(inputs)
+			}
+			return
+		}(); err != nil {
+			return fmt.Errorf("%s: %v", t.Name(), err)
+		}
+	}
+
+	return nil
+}
+
+func (base *FactoryBase) testerAllDone() bool {
+	for _, t := range base.testers {
+		if !t.Done() {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (base *FactoryBase) notifySuccess() {
+	base.status <- map[singnal]interface{}{runSuccess: nil}
+}
+
+func (base *FactoryBase) notifyFail(msg interface{}) {
+	base.status <- map[singnal]interface{}{runFail: msg}
+}
+
+type ConfigFactory struct {
+	FactoryBase
+
+	initialized bool
+
+	sleepTime time.Duration
+
+	masterKey *ecdsa.PrivateKey
+}
+
+func (f *ConfigFactory) Run() {
+	for {
+		if !f.initialized {
+			// Initial block for first round.
+			go f.center.DeliverProduct(makerName(f.name),
+				&PositionProduct{position: coreTypes.Position{
+					Round:  0,
+					Height: 0,
+				}})
+
+			f.initialized = true
+			continue
+		}
+
+		time.Sleep(f.sleepTime)
+
+		product := f.center.RequestProduct(takerName(f.name))
+		position := f.covertProduct(product)
+		position.Height++
+
+		if f.roundStartAt(position.Round+1) == position.Height {
+			position.Round = position.Round + 1
+		}
+
+		go f.center.DeliverProduct(makerName(f.name), &PositionProduct{
+			position: position,
+		})
+	}
+}
+
+func (f ConfigFactory) covertProduct(product interface{}) coreTypes.Position {
+	var position coreTypes.Position
+	switch product.(type) {
+	case *BlockConfirmedProduct:
+		position = product.(*BlockConfirmedProduct).block.Position
+	default:
+		panic(fmt.Errorf("unexpected type %T", product))
+	}
+
+	return position
+}
+
+func (f *ConfigFactory) roundStartAt(round uint64) uint64 {
+	dexonApp := f.App.(*DexconApp)
+	start := uint64(0)
+	for i := uint64(0); i < round; i++ {
+		start += dexonApp.gov.Configuration(i).RoundLength
+	}
+
+	return start - 1
+}
+
+func (f ConfigFactory) New(app App, center *ProductCenter, stopTimeMu *sync.RWMutex, masterKey *ecdsa.PrivateKey) *ConfigFactory {
+	f.FactoryBase = FactoryBase{
+		App:        app,
+		name:       reflect.TypeOf(f).Name(),
+		center:     center,
+		stopTimeMu: stopTimeMu,
+	}
+	f.sleepTime = 250 * time.Millisecond
+	f.masterKey = masterKey
+	f.center.Register(takerName(f.name), makerName(reflect.TypeOf(BlockConfirmedFactory{}).Name()))
+	return &f
+}
+
+type PositionProduct struct {
+	position coreTypes.Position
+}
+
+type PreparePayloadFactory struct {
+	FactoryBase
+}
+
+func (f *PreparePayloadFactory) Run() {
+	defer func() {
+		if r := recover(); r != nil {
+			f.notifyFail(r)
+		}
+	}()
+
+	for {
+		product := f.center.RequestProduct(takerName(f.name))
+
+		if len(f.testers) > 0 && f.testerAllDone() {
+			f.notifySuccess()
+			f.testers = nil
+		} else if err := f.testerDoWork(product); err != nil {
+			panic(fmt.Errorf("test fail: %v", err))
+		}
+
+		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					f.notifyFail(r)
+				}
+			}()
+
+			position := f.covertProduct(product)
+			f.stopTimeMu.RLock()
+			payload, err := f.App.PreparePayload(position)
+			if err != nil {
+				panic(err)
+			}
+			f.stopTimeMu.RUnlock()
+
+			go f.center.DeliverProduct(makerName(f.name), &PreparePayloadProduct{
+				position: position,
+				payload:  payload,
+			})
+		}()
+	}
+}
+
+func (f PreparePayloadFactory) covertProduct(product interface{}) coreTypes.Position {
+	var position coreTypes.Position
+	switch product.(type) {
+	case *PositionProduct:
+		position = product.(*PositionProduct).position
+	default:
+		panic(fmt.Errorf("unexpected type %T", product))
+	}
+
+	return position
+}
+
+func (f PreparePayloadFactory) New(app App, center *ProductCenter, stopTimeMu *sync.RWMutex) *PreparePayloadFactory {
+	f.FactoryBase = FactoryBase{
+		App:        app,
+		name:       reflect.TypeOf(f).Name(),
+		center:     center,
+		targetFunc: app.PreparePayload,
+		status:     make(chan map[singnal]interface{}, 1),
+		stopTimeMu: stopTimeMu,
+	}
+	f.center.Register(takerName(f.name), makerName(reflect.TypeOf(ConfigFactory{}).Name()))
+	return &f
+}
+
+func (f PreparePayloadFactory) NewWithTester(app App, center *ProductCenter, stopTimeMu *sync.RWMutex) *PreparePayloadFactory {
+	factory := f.New(app, center, stopTimeMu)
+	factory.testers = []Tester{
+		ppBlockLimitTester{}.New(app, 10, 3, 3),
+		ppBlockHeightTester{}.New(app, 20, 3, 3),
+	}
+	return factory
+}
+
+type PreparePayloadProduct struct {
+	position coreTypes.Position
+	payload  []byte
+}
+
+type ppBlockLimitTester struct {
+	baseTester
+
+	round uint64
+}
+
+func (t ppBlockLimitTester) New(app App, startAt, interval, threshold int) *ppBlockLimitTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *ppBlockLimitTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PositionProduct:
+			t.round = product.(*PositionProduct).position.Round
+			t.ready = true
+		}
+
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t ppBlockLimitTester) InputsForTest(product Product) []reflect.Value {
+	return []reflect.Value{reflect.ValueOf(product.(*PositionProduct).position)}
+}
+
+func (t *ppBlockLimitTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 2 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[1].Interface().(type) {
+	case nil:
+	case error:
+		return fmt.Errorf("result[1] must nil: %v", results[1].Interface())
+	default:
+		return fmt.Errorf("unexpect results[1] return type %T", results[1].Interface())
+	}
+
+	switch results[0].Interface().(type) {
+	case []byte:
+		if results[0].Bytes() != nil {
+			var txs []*types.Transaction
+			err := rlp.DecodeBytes(results[0].Bytes(), &txs)
+			if err != nil {
+				return fmt.Errorf("rlp decode error: %v", err)
+			}
+
+			app := t.App.(*DexconApp)
+			blockLimit := app.gov.DexconConfiguration(t.round).BlockGasLimit
+			totalGas := uint64(0)
+			for _, tx := range txs {
+				totalGas += tx.Gas()
+			}
+
+			if blockLimit < totalGas {
+				return fmt.Errorf("total cost larger than block limit %d < %d", blockLimit, totalGas)
+			}
+
+			t.counter++
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.ready = false
+	return nil
+}
+
+type ppBlockHeightTester struct {
+	baseTester
+
+	height uint64
+}
+
+func (t ppBlockHeightTester) New(app App, startAt, interval, threshold int) *ppBlockHeightTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *ppBlockHeightTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PositionProduct:
+			t.height = product.(*PositionProduct).position.Height
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t ppBlockHeightTester) InputsForTest(product Product) []reflect.Value {
+	position := product.(*PositionProduct).position
+	position.Height--
+	return []reflect.Value{reflect.ValueOf(position)}
+}
+
+func (t *ppBlockHeightTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 2 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[1].Interface().(type) {
+	case error:
+		expectErr := fmt.Sprintf("expected height %d but get %d", t.height, t.height-1)
+		if results[1].Interface().(error).Error() != expectErr {
+			return fmt.Errorf("unexpected error msg: %v", results[1].Interface())
+		}
+	default:
+		return fmt.Errorf("unexpect results[1] return type %T", results[1].Interface())
+	}
+
+	switch results[0].Interface().(type) {
+	case []byte:
+		if results[0].Bytes() != nil {
+			return fmt.Errorf("payload should be nil")
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.ready = false
+	t.counter++
+	return nil
+}
+
+type PrepareWitnessFactory struct {
+	FactoryBase
+}
+
+func (f *PrepareWitnessFactory) Run() {
+	defer func() {
+		if r := recover(); r != nil {
+			f.notifyFail(r)
+		}
+	}()
+
+	for {
+		product := f.center.RequestProduct(takerName(f.name))
+
+		if len(f.testers) > 0 && f.testerAllDone() {
+			f.notifySuccess()
+			f.testers = nil
+		} else if err := f.testerDoWork(product); err != nil {
+			panic(fmt.Errorf("test fail: %v", err))
+		}
+
+		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					f.notifyFail(r)
+				}
+			}()
+
+			f.stopTimeMu.RLock()
+			witness, err := f.App.PrepareWitness(f.App.(*DexconApp).blockchain.CurrentBlock().NumberU64())
+			if err != nil {
+				panic(err)
+			}
+			f.stopTimeMu.RUnlock()
+
+			position, payload := f.convertProduct(product)
+			go f.center.DeliverProduct(makerName(f.name), &PrepareWitnessProduct{
+				block: coreTypes.Block{
+					Hash:        coreCommon.NewRandomHash(),
+					ProposerID:  coreTypes.NodeID{coreCommon.Hash{1, 2, 3}},
+					Position:    position,
+					Witness:     witness,
+					Payload:     payload,
+					PayloadHash: coreCrypto.Keccak256Hash(payload),
+				},
+			})
+		}()
+	}
+}
+
+func (f PrepareWitnessFactory) convertProduct(product Product) (coreTypes.Position, []byte) {
+	var (
+		position coreTypes.Position
+		payload  []byte
+	)
+	switch product.(type) {
+	case *PreparePayloadProduct:
+		realProduct := product.(*PreparePayloadProduct)
+		position = realProduct.position
+		payload = realProduct.payload
+	default:
+		panic(fmt.Errorf("unexpected type %T", product))
+	}
+
+	return position, payload
+}
+
+func (f PrepareWitnessFactory) New(app App, center *ProductCenter, stopTimeMu *sync.RWMutex) *PrepareWitnessFactory {
+	f.FactoryBase = FactoryBase{
+		App:        app,
+		name:       reflect.TypeOf(f).Name(),
+		center:     center,
+		targetFunc: app.PrepareWitness,
+		status:     make(chan map[singnal]interface{}, 1),
+		stopTimeMu: stopTimeMu,
+	}
+	f.center.Register(takerName(f.name), makerName(reflect.TypeOf(PreparePayloadFactory{}).Name()))
+	return &f
+}
+
+func (f PrepareWitnessFactory) NewWithTester(app App, center *ProductCenter, stopTimeMu *sync.RWMutex) *PrepareWitnessFactory {
+	factory := f.New(app, center, stopTimeMu)
+	factory.testers = []Tester{
+		pwConsensusHeightTester{}.New(app, 10, 10, 3),
+	}
+
+	return factory
+}
+
+type PrepareWitnessProduct struct {
+	block coreTypes.Block
+}
+
+type pwConsensusHeightTester struct {
+	baseTester
+}
+
+func (t pwConsensusHeightTester) New(app App, startAt, interval, threshold int) *pwConsensusHeightTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *pwConsensusHeightTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		t.ready = true
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t pwConsensusHeightTester) InputsForTest(product Product) []reflect.Value {
+	return []reflect.Value{reflect.ValueOf(uint64(99999))}
+}
+
+func (t *pwConsensusHeightTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 2 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[1].Interface().(type) {
+	case nil:
+		return fmt.Errorf("results[1] must not nil")
+	case error:
+		if results[1].Interface().(error).Error() != "current height < consensus height" {
+			return fmt.Errorf("unexpected error: %v", results[1].Interface())
+		}
+	default:
+		return fmt.Errorf("unexpect results[1] return type %T", results[1].Interface())
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.Witness:
+		witness := results[0].Interface().(coreTypes.Witness)
+		if witness.Height != 0 || len(witness.Data) > 0 {
+			return fmt.Errorf("unexpected results[1] return %+v", results[0].Interface())
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type VerifyBlockFactory struct {
+	FactoryBase
+}
+
+func (f *VerifyBlockFactory) Run() {
+	defer func() {
+		if r := recover(); r != nil {
+			f.notifyFail(r)
+		}
+	}()
+
+	for {
+		product := f.center.RequestProduct(takerName(f.name))
+
+		if len(f.testers) > 0 && f.testerAllDone() {
+			f.notifySuccess()
+			f.testers = nil
+		} else if err := f.testerDoWork(product); err != nil {
+			panic(fmt.Errorf("test fail: %v", err))
+		}
+
+		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					f.notifyFail(r)
+				}
+			}()
+
+			block := f.convertProduct(product)
+
+			f.stopTimeMu.RLock()
+			if status := f.App.VerifyBlock(&block); status != coreTypes.VerifyOK {
+				panic(fmt.Errorf("verify block fail: status %v", status))
+			}
+			f.stopTimeMu.RUnlock()
+
+			go f.center.DeliverProduct(makerName(f.name), &VerifyBlockProduct{
+				block: block,
+			})
+		}()
+	}
+}
+
+func (f VerifyBlockFactory) convertProduct(product Product) coreTypes.Block {
+	var block coreTypes.Block
+	switch product.(type) {
+	case *PrepareWitnessProduct:
+		block = product.(*PrepareWitnessProduct).block
+	default:
+		panic(fmt.Errorf("unexpected type %T", product))
+	}
+
+	return block
+}
+
+func (f VerifyBlockFactory) New(app App, center *ProductCenter, stopTimeMu *sync.RWMutex) *VerifyBlockFactory {
+	f.FactoryBase = FactoryBase{
+		App:        app,
+		name:       reflect.TypeOf(f).Name(),
+		center:     center,
+		targetFunc: app.VerifyBlock,
+		status:     make(chan map[singnal]interface{}, 1),
+		stopTimeMu: stopTimeMu,
+	}
+	f.center.Register(takerName(f.name), makerName(reflect.TypeOf(PrepareWitnessFactory{}).Name()))
+	return &f
+}
+
+func (f VerifyBlockFactory) NewWithTester(app App, center *ProductCenter, stopTimeMu *sync.RWMutex) *VerifyBlockFactory {
+	factory := f.New(app, center, stopTimeMu)
+	factory.testers = []Tester{
+		vbWitnessDataDecodeTester{}.New(app, 10, 5, 3),
+		vbWitnessHeightTester{}.New(app, 20, 5, 3),
+		vbWitnessDataTester{}.New(app, 30, 5, 3),
+		vbBlockHeightTester{}.New(app, 40, 3, 3),
+		vbPayloadDecodeTester{}.New(app, 50, 5, 3),
+		vbTxNonceSequenceTester{}.New(app, 60, 5, 3),
+		vbTxNonceIncrementTester{}.New(app, 70, 5, 3),
+		vbTxIntrinsicGasTester{}.New(app, 80, 5, 3),
+		vbTxGasTooLowTester{}.New(app, 90, 5, 3),
+		vbInsufficientFundsTester{}.New(app, 100, 5, 3),
+		vbBlockLimitTester{}.New(app, 110, 5, 3),
+	}
+
+	return factory
+}
+
+type VerifyBlockProduct struct {
+	block coreTypes.Block
+}
+
+type vbWitnessDataDecodeTester struct {
+	baseTester
+}
+
+func (t vbWitnessDataDecodeTester) New(app App, startAt, interval, threshold int) *vbWitnessDataDecodeTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbWitnessDataDecodeTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbWitnessDataDecodeTester) InputsForTest(product Product) []reflect.Value {
+	block := product.(*PrepareWitnessProduct).block
+	block.Witness.Data = make([]byte, 100)
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbWitnessDataDecodeTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		if results[0].Interface().(coreTypes.BlockVerifyStatus) != coreTypes.VerifyInvalidBlock {
+			return fmt.Errorf("unexpected status %v", results[0].Interface())
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type vbWitnessHeightTester struct {
+	baseTester
+}
+
+func (t vbWitnessHeightTester) New(app App, startAt, interval, threshold int) *vbWitnessHeightTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbWitnessHeightTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbWitnessHeightTester) InputsForTest(product Product) []reflect.Value {
+	block := product.(*PrepareWitnessProduct).block
+	block.Witness.Height += uint64(rand.New(rand.NewSource(time.Now().UnixNano())).Intn(10) + 1)
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbWitnessHeightTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		if results[0].Interface().(coreTypes.BlockVerifyStatus) != coreTypes.VerifyRetryLater {
+			return fmt.Errorf("unexpected status %v", results[0].Interface())
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type vbWitnessDataTester struct {
+	baseTester
+}
+
+func (t vbWitnessDataTester) New(app App, startAt, interval, threshold int) *vbWitnessDataTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbWitnessDataTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbWitnessDataTester) InputsForTest(product Product) []reflect.Value {
+	block := product.(*PrepareWitnessProduct).block
+	randNum := big.NewInt(rand.New(rand.NewSource(time.Now().UnixNano())).Int63())
+	var err error
+	block.Witness.Data, err = rlp.EncodeToBytes(common.BigToHash(randNum))
+	if err != nil {
+		panic(err)
+	}
+
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbWitnessDataTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		if results[0].Interface().(coreTypes.BlockVerifyStatus) != coreTypes.VerifyInvalidBlock {
+			return fmt.Errorf("unexpected status %v", results[0].Interface())
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type vbBlockHeightTester struct {
+	baseTester
+}
+
+func (t vbBlockHeightTester) New(app App, startAt, interval, threshold int) *vbBlockHeightTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbBlockHeightTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbBlockHeightTester) InputsForTest(product Product) []reflect.Value {
+	block := product.(*PrepareWitnessProduct).block
+	block.Position.Height--
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbBlockHeightTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		if results[0].Interface().(coreTypes.BlockVerifyStatus) != coreTypes.VerifyRetryLater {
+			return fmt.Errorf("unexpected status %v", results[0].Interface())
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type vbPayloadDecodeTester struct {
+	baseTester
+}
+
+func (t vbPayloadDecodeTester) New(app App, startAt, interval, threshold int) *vbPayloadDecodeTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbPayloadDecodeTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbPayloadDecodeTester) InputsForTest(product Product) []reflect.Value {
+	block := product.(*PrepareWitnessProduct).block
+	block.Payload = []byte{0x00}
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbPayloadDecodeTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		status := results[0].Interface().(coreTypes.BlockVerifyStatus)
+		if status != coreTypes.VerifyInvalidBlock {
+			return fmt.Errorf("unexpect status %v", status)
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type vbTxNonceSequenceTester struct {
+	baseTester
+}
+
+func (t vbTxNonceSequenceTester) New(app App, startAt, interval, threshold int) *vbTxNonceSequenceTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbTxNonceSequenceTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbTxNonceSequenceTester) InputsForTest(product Product) []reflect.Value {
+	app := t.App.(*DexconApp)
+	block := product.(*PrepareWitnessProduct).block
+	var key *ecdsa.PrivateKey
+	var err error
+	key, err = crypto.GenerateKey()
+	if err != nil {
+		panic(err)
+	}
+
+	blockchain := app.blockchain
+	signer := types.NewEIP155Signer(blockchain.Config().ChainID)
+	var txs []*types.Transaction
+	for i := uint64(0); i < 3; i++ {
+		if i == 1 {
+			continue
+		}
+
+		tx, err := types.SignTx(types.NewTransaction(i, common.Address{}, nil, 21000, nil, nil), signer, key)
+		if err != nil {
+			panic(err)
+		}
+		txs = append(txs, tx)
+	}
+
+	block.Payload, err = rlp.EncodeToBytes(txs)
+	if err != nil {
+		panic(err)
+	}
+
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbTxNonceSequenceTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		status := results[0].Interface().(coreTypes.BlockVerifyStatus)
+		if status != coreTypes.VerifyInvalidBlock {
+			return fmt.Errorf("unexpect status %v", status)
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type vbTxNonceIncrementTester struct {
+	baseTester
+}
+
+func (t vbTxNonceIncrementTester) New(app App, startAt, interval, threshold int) *vbTxNonceIncrementTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbTxNonceIncrementTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbTxNonceIncrementTester) InputsForTest(product Product) []reflect.Value {
+	app := t.App.(*DexconApp)
+	block := product.(*PrepareWitnessProduct).block
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		panic(err)
+	}
+
+	blockchain := app.blockchain
+	signer := types.NewEIP155Signer(blockchain.Config().ChainID)
+	var txs []*types.Transaction
+	for i := uint64(1); i < 4; i++ {
+		tx, err := types.SignTx(types.NewTransaction(i, common.Address{}, nil, 21000, nil, nil), signer, key)
+		if err != nil {
+			panic(err)
+		}
+		txs = append(txs, tx)
+	}
+
+	block.Payload, err = rlp.EncodeToBytes(txs)
+	if err != nil {
+		panic(err)
+	}
+
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbTxNonceIncrementTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		status := results[0].Interface().(coreTypes.BlockVerifyStatus)
+		if status != coreTypes.VerifyInvalidBlock {
+			return fmt.Errorf("unexpect status %v", status)
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type vbTxIntrinsicGasTester struct {
+	baseTester
+}
+
+func (t vbTxIntrinsicGasTester) New(app App, startAt, interval, threshold int) *vbTxIntrinsicGasTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbTxIntrinsicGasTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbTxIntrinsicGasTester) InputsForTest(product Product) []reflect.Value {
+	app := t.App.(*DexconApp)
+	block := product.(*PrepareWitnessProduct).block
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		panic(err)
+	}
+
+	blockchain := app.blockchain
+	signer := types.NewEIP155Signer(blockchain.Config().ChainID)
+	var txs []*types.Transaction
+	for i := uint64(0); i < 3; i++ {
+		tx, err := types.SignTx(types.NewTransaction(i, common.Address{}, nil, 10000, nil, nil), signer, key)
+		if err != nil {
+			panic(err)
+		}
+		txs = append(txs, tx)
+	}
+
+	block.Payload, err = rlp.EncodeToBytes(txs)
+	if err != nil {
+		panic(err)
+	}
+
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbTxIntrinsicGasTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		status := results[0].Interface().(coreTypes.BlockVerifyStatus)
+		if status != coreTypes.VerifyInvalidBlock {
+			return fmt.Errorf("unexpect status %v", status)
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type vbTxGasTooLowTester struct {
+	baseTester
+}
+
+func (t vbTxGasTooLowTester) New(app App, startAt, interval, threshold int) *vbTxGasTooLowTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbTxGasTooLowTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbTxGasTooLowTester) InputsForTest(product Product) []reflect.Value {
+	app := t.App.(*DexconApp)
+	block := product.(*PrepareWitnessProduct).block
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		panic(err)
+	}
+
+	blockchain := app.blockchain
+	signer := types.NewEIP155Signer(blockchain.Config().ChainID)
+	var txs []*types.Transaction
+	for i := uint64(0); i < 3; i++ {
+		tx, err := types.SignTx(types.NewTransaction(i, common.Address{}, nil, 21000, nil, []byte{0x00}), signer, key)
+		if err != nil {
+			panic(err)
+		}
+		txs = append(txs, tx)
+	}
+
+	block.Payload, err = rlp.EncodeToBytes(txs)
+	if err != nil {
+		panic(err)
+	}
+
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbTxGasTooLowTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		status := results[0].Interface().(coreTypes.BlockVerifyStatus)
+		if status != coreTypes.VerifyInvalidBlock {
+			return fmt.Errorf("unexpect status %v", status)
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type vbInsufficientFundsTester struct {
+	baseTester
+}
+
+func (t vbInsufficientFundsTester) New(app App, startAt, interval, threshold int) *vbInsufficientFundsTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbInsufficientFundsTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbInsufficientFundsTester) InputsForTest(product Product) []reflect.Value {
+	app := t.App.(*DexconApp)
+	block := product.(*PrepareWitnessProduct).block
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		panic(err)
+	}
+
+	blockchain := app.blockchain
+	signer := types.NewEIP155Signer(blockchain.Config().ChainID)
+	var txs []*types.Transaction
+	for i := uint64(0); i < 3; i++ {
+		tx, err := types.SignTx(types.NewTransaction(i, common.Address{}, big.NewInt(1), 21000, nil, nil), signer, key)
+		if err != nil {
+			panic(err)
+		}
+		txs = append(txs, tx)
+	}
+
+	block.Payload, err = rlp.EncodeToBytes(txs)
+	if err != nil {
+		panic(err)
+	}
+
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbInsufficientFundsTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		status := results[0].Interface().(coreTypes.BlockVerifyStatus)
+		if status != coreTypes.VerifyInvalidBlock {
+			return fmt.Errorf("unexpect status %v", status)
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type vbBlockLimitTester struct {
+	baseTester
+}
+
+func (t vbBlockLimitTester) New(app App, startAt, interval, threshold int) *vbBlockLimitTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *vbBlockLimitTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *PrepareWitnessProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t vbBlockLimitTester) InputsForTest(product Product) []reflect.Value {
+	app := t.App.(*DexconApp)
+	block := product.(*PrepareWitnessProduct).block
+	key, err := crypto.GenerateKey()
+	if err != nil {
+		panic(err)
+	}
+
+	blockchain := app.blockchain
+	signer := types.NewEIP155Signer(blockchain.Config().ChainID)
+	var txs []*types.Transaction
+	for i := uint64(0); i < 3; i++ {
+		tx, err := types.SignTx(types.NewTransaction(i, common.Address{}, nil, 10e10, nil, nil), signer, key)
+		if err != nil {
+			panic(err)
+		}
+		txs = append(txs, tx)
+	}
+
+	block.Payload, err = rlp.EncodeToBytes(txs)
+	if err != nil {
+		panic(err)
+	}
+
+	return []reflect.Value{reflect.ValueOf(&block)}
+}
+
+func (t *vbBlockLimitTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case coreTypes.BlockVerifyStatus:
+		status := results[0].Interface().(coreTypes.BlockVerifyStatus)
+		if status != coreTypes.VerifyInvalidBlock {
+			return fmt.Errorf("unexpect status %v", status)
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type BlockConfirmedFactory struct {
+	FactoryBase
+
+	masterKey *coreEcdsa.PrivateKey
+}
+
+func (f *BlockConfirmedFactory) Run() {
+	defer func() {
+		if r := recover(); r != nil {
+			f.notifyFail(r)
+		}
+	}()
+
+	for {
+		product := f.center.RequestProduct(takerName(f.name))
+
+		if len(f.testers) > 0 && f.testerAllDone() {
+			f.notifySuccess()
+			f.testers = nil
+		} else if err := f.testerDoWork(product); err != nil {
+			panic(fmt.Errorf("test fail: %v", err))
+		}
+
+		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					f.notifyFail(r)
+				}
+			}()
+
+			block := f.convertProduct(product)
+			block.ProposerID = coreTypes.NewNodeID(f.masterKey.PublicKey())
+			f.stopTimeMu.RLock()
+			f.App.BlockConfirmed(block)
+			f.stopTimeMu.RUnlock()
+
+			block.Finalization = coreTypes.FinalizationResult{
+				Timestamp: time.Now(),
+				Height:    block.Position.Height + 1,
+			}
+
+			f.center.DeliverProduct(makerName(f.name), &BlockConfirmedProduct{
+				block: block,
+			})
+		}()
+	}
+}
+
+func (f BlockConfirmedFactory) convertProduct(product Product) coreTypes.Block {
+	var block coreTypes.Block
+	switch product.(type) {
+	case *VerifyBlockProduct:
+		block = product.(*VerifyBlockProduct).block
+	default:
+		panic(fmt.Errorf("unexpected type %T", product))
+	}
+
+	return block
+}
+
+func (f BlockConfirmedFactory) New(app App, center *ProductCenter, stopTimeMu *sync.RWMutex,
+	masterKey *ecdsa.PrivateKey) *BlockConfirmedFactory {
+	f.FactoryBase = FactoryBase{
+		App:        app,
+		name:       reflect.TypeOf(f).Name(),
+		center:     center,
+		targetFunc: app.BlockConfirmed,
+		status:     make(chan map[singnal]interface{}, 1),
+		stopTimeMu: stopTimeMu,
+	}
+	f.masterKey = coreEcdsa.NewPrivateKeyFromECDSA(masterKey)
+	f.center.Register(takerName(f.name), makerName(reflect.TypeOf(VerifyBlockFactory{}).Name()))
+	return &f
+}
+
+func (f BlockConfirmedFactory) NewWithTester(app App, center *ProductCenter, stopTimeMu *sync.RWMutex,
+	masterKey *ecdsa.PrivateKey) *BlockConfirmedFactory {
+	factory := f.New(app, center, stopTimeMu, masterKey)
+	factory.testers = []Tester{
+		bcBlockConfirmedTester{}.New(app, 30, 5, 3),
+	}
+
+	return factory
+}
+
+type BlockConfirmedProduct struct {
+	block coreTypes.Block
+}
+
+type addInfo struct {
+	nonce   *uint64
+	cost    *big.Int
+	counter *uint64
+}
+
+type bcBlockConfirmedTester struct {
+	baseTester
+
+	block          coreTypes.Block
+	originAddrInfo map[common.Address]addInfo
+}
+
+func (t bcBlockConfirmedTester) New(app App, startAt, interval, threshold int) *bcBlockConfirmedTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	t.originAddrInfo = map[common.Address]addInfo{}
+	return &t
+}
+
+func (t *bcBlockConfirmedTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *VerifyBlockProduct:
+			t.block = product.(*VerifyBlockProduct).block
+			var txs []*types.Transaction
+			err := rlp.DecodeBytes(t.block.Payload, &txs)
+			if err != nil {
+				panic(err)
+			} else if len(txs) > 0 {
+				app := t.App.(*DexconApp)
+				blockchain := app.blockchain
+				for _, tx := range txs {
+					msg, err := tx.AsMessage(types.MakeSigner(blockchain.Config(), new(big.Int)))
+					if err != nil {
+						panic(err)
+					}
+
+					if _, exist := t.originAddrInfo[msg.From()]; !exist {
+						info := addInfo{}
+
+						nonce, exist := app.addressNonce[msg.From()]
+						if !exist {
+							info.nonce = nil
+						} else {
+							info.nonce = &nonce
+						}
+
+						cost, exist := app.addressCost[msg.From()]
+						if !exist {
+							info.cost = nil
+						} else {
+							info.cost = cost
+						}
+
+						counter, exist := app.addressCounter[msg.From()]
+						if !exist {
+							info.counter = nil
+						} else {
+							info.counter = &counter
+						}
+
+						t.originAddrInfo[msg.From()] = info
+					}
+				}
+				t.ready = true
+			}
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t bcBlockConfirmedTester) InputsForTest(product Product) []reflect.Value {
+	return []reflect.Value{reflect.ValueOf(product.(*VerifyBlockProduct).block)}
+}
+
+func (t *bcBlockConfirmedTester) ValidateResults(results []reflect.Value) error {
+	if len(results) > 0 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	var expectTxs []*types.Transaction
+	err := rlp.DecodeBytes(t.block.Payload, &expectTxs)
+	if err != nil {
+		return fmt.Errorf("rlp decode error: %v", err)
+	}
+
+	app := t.App.(*DexconApp)
+	blockchain := app.blockchain
+	block, cachedTxs := app.getConfirmedBlockByHash(t.block.Hash)
+	if block == nil {
+		return fmt.Errorf("block can not be nil")
+	}
+
+	if t.block.Hash != block.Hash {
+		return fmt.Errorf("block hash not equal %v vs %v", t.block.Hash, block.Hash)
+	}
+
+	addrInfo := map[common.Address]*addInfo{}
+	for i, tx := range expectTxs {
+		if tx.Hash() != cachedTxs[i].Hash() {
+			return fmt.Errorf("incorrect tx %+v vs %+v", tx, cachedTxs[i])
+		}
+
+		msg, err := tx.AsMessage(types.MakeSigner(blockchain.Config(), new(big.Int)))
+		if err != nil {
+			panic(err)
+		}
+
+		nonce := tx.Nonce()
+		if info, exist := addrInfo[msg.From()]; !exist {
+			counter := uint64(1)
+			addrInfo[msg.From()] = &addInfo{nonce: &nonce, cost: tx.Cost(), counter: &counter}
+		} else {
+			info.nonce = &nonce
+			info.cost = new(big.Int).Add(info.cost, tx.Cost())
+		}
+	}
+
+	for addr, info := range addrInfo {
+
+		var expectCost *big.Int
+		var expectNonce uint64
+		var expectCounter uint64
+		if t.originAddrInfo[addr].cost == nil {
+			expectCost = info.cost
+		} else {
+			expectCost = new(big.Int).Add(t.originAddrInfo[addr].cost, info.cost)
+		}
+
+		expectNonce = *info.nonce
+
+		if t.originAddrInfo[addr].counter == nil {
+			expectCounter = *info.counter
+		} else {
+			expectCounter = *t.originAddrInfo[addr].counter + *info.counter
+		}
+
+		cost, exist := app.addressCost[addr]
+		counter, exist := app.addressCounter[addr]
+		nonce, exist := app.addressNonce[addr]
+		if !exist {
+			return fmt.Errorf("cache in confirmed block is empty %v %v %v", cost, counter, nonce)
+		}
+
+		if cost.Cmp(expectCost) != 0 {
+			return fmt.Errorf("incorrect cost expect %v but %v", expectCost, cost)
+		}
+
+		if counter != expectCounter {
+			return fmt.Errorf("incorrect counter expect %v but %v", expectCounter, counter)
+		}
+
+		if nonce != expectNonce {
+			return fmt.Errorf("incorrect nonce expect %v but %v", expectNonce, nonce)
+		}
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+func (t bcBlockConfirmedTester) StopTime() bool {
+	return true
+}
+
+func (t *bcBlockConfirmedTester) Rollback() error {
+	app := t.App.(*DexconApp)
+	delete(app.confirmedBlocks, t.block.Hash)
+	app.undeliveredNum--
+	for addr, info := range t.originAddrInfo {
+		if info.nonce == nil {
+			delete(app.addressNonce, addr)
+		} else {
+			app.addressNonce[addr] = *info.nonce
+		}
+
+		if info.cost == nil {
+			delete(app.addressCost, addr)
+		} else {
+			app.addressCost[addr] = info.cost
+		}
+
+		if info.cost == nil {
+			delete(app.addressCounter, addr)
+		} else {
+			app.addressCounter[addr] = *info.counter
+		}
+	}
+
+	t.originAddrInfo = map[common.Address]addInfo{}
+	return nil
+}
+
+type BlockDeliveredFactory struct {
+	FactoryBase
+}
+
+func (f *BlockDeliveredFactory) Run() {
+	defer func() {
+		if r := recover(); r != nil {
+			f.notifyFail(r)
+		}
+	}()
+
+	for {
+		product := f.center.RequestProduct(takerName(f.name))
+
+		if len(f.testers) > 0 && f.testerAllDone() {
+			f.notifySuccess()
+			f.testers = nil
+		} else if err := f.testerDoWork(product); err != nil {
+			panic(fmt.Errorf("test fail: %v", err))
+		}
+
+		block := f.convertProduct(product)
+		f.stopTimeMu.RLock()
+		f.App.BlockDelivered(block.Hash, block.Position, block.Finalization)
+		f.stopTimeMu.RUnlock()
+	}
+}
+
+func (f BlockDeliveredFactory) convertProduct(product Product) *coreTypes.Block {
+	var block *coreTypes.Block
+	switch product.(type) {
+	case *BlockConfirmedProduct:
+		block = &product.(*BlockConfirmedProduct).block
+	default:
+		panic(fmt.Errorf("unexpected type %T", product))
+	}
+
+	return block
+}
+
+func (f BlockDeliveredFactory) New(app App, center *ProductCenter, stopTimeMu *sync.RWMutex) *BlockDeliveredFactory {
+	f.FactoryBase = FactoryBase{
+		App:        app,
+		name:       reflect.TypeOf(f).Name(),
+		center:     center,
+		targetFunc: app.BlockDelivered,
+		status:     make(chan map[singnal]interface{}, 1),
+		stopTimeMu: stopTimeMu,
+	}
+	f.center.Register(takerName(f.name), makerName(reflect.TypeOf(BlockConfirmedFactory{}).Name()))
+	return &f
+}
+
+func (f BlockDeliveredFactory) NewWithTester(app App, center *ProductCenter,
+	stopTimeMu *sync.RWMutex) *BlockDeliveredFactory {
+	factory := f.New(app, center, stopTimeMu)
+	factory.testers = []Tester{
+		bdBlockHashTester{}.New(app, 30, 5, 3),
+		bdBlockDeliveredTester{}.New(app, 60, 5, 3),
+	}
+
+	return factory
+}
+
+type bdBlockHashTester struct {
+	baseTester
+}
+
+func (t bdBlockHashTester) New(app App, startAt, interval, threshold int) *bdBlockHashTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *bdBlockHashTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *BlockConfirmedProduct:
+			t.ready = true
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t bdBlockHashTester) InputsForTest(product Product) []reflect.Value {
+	block := product.(*BlockConfirmedProduct).block
+	return []reflect.Value{reflect.ValueOf(coreCommon.Hash{}), reflect.ValueOf(block.Position),
+		reflect.ValueOf(block.Finalization)}
+}
+
+func (t *bdBlockHashTester) ValidateResults(results []reflect.Value) error {
+	if len(results) != 1 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	switch results[0].Interface().(type) {
+	case error:
+		if results[0].Interface().(error).Error() != "Can not get confirmed block" {
+			return fmt.Errorf("unexpected error: %v", results[0].Interface().(error))
+		}
+	default:
+		return fmt.Errorf("unexpect results[0] return type %T", results[0].Interface())
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+type originalCache struct {
+	confirmedBlocks map[coreCommon.Hash]*blockInfo
+	addressNonce    map[common.Address]uint64
+	addressCost     map[common.Address]*big.Int
+	addressCounter  map[common.Address]uint64
+}
+
+type bdBlockDeliveredTester struct {
+	baseTester
+
+	expectHeight  uint64
+	originalCache originalCache
+	blockInfo     *blockInfo
+}
+
+func (t bdBlockDeliveredTester) New(app App, startAt, interval, threshold int) *bdBlockDeliveredTester {
+	t.baseTester = baseTester{
+		App:          app,
+		testTimer:    time.NewTimer(time.Duration(startAt) * time.Second),
+		testInterval: time.Duration(interval) * time.Second,
+		threshold:    threshold,
+		self:         t,
+	}
+	return &t
+}
+
+func (t *bdBlockDeliveredTester) ViewAndRecord(product Product) {
+	select {
+	case <-t.testTimer.C:
+		switch product.(type) {
+		case *BlockConfirmedProduct:
+			app := t.App.(*DexconApp)
+			block := product.(*BlockConfirmedProduct).block
+			t.expectHeight = block.Position.Height + 1
+			var txs []*types.Transaction
+			_, txs = app.getConfirmedBlockByHash(block.Hash)
+
+			if len(txs) > 0 {
+				t.originalCache.confirmedBlocks = map[coreCommon.Hash]*blockInfo{}
+				for k, v := range app.confirmedBlocks {
+					t.originalCache.confirmedBlocks[k] = v
+				}
+
+				t.originalCache.addressNonce = map[common.Address]uint64{}
+				for k, v := range app.addressNonce {
+					t.originalCache.addressNonce[k] = v
+				}
+
+				t.originalCache.addressCounter = map[common.Address]uint64{}
+				for k, v := range app.addressCounter {
+					t.originalCache.addressCounter[k] = v
+				}
+
+				t.originalCache.addressCost = map[common.Address]*big.Int{}
+				for k, v := range app.addressCost {
+					t.originalCache.addressCost[k] = v
+				}
+
+				t.blockInfo = app.confirmedBlocks[block.Hash]
+				t.ready = true
+			}
+		}
+		t.testTimer.Reset(t.testInterval)
+	default:
+	}
+}
+
+func (t bdBlockDeliveredTester) InputsForTest(product Product) []reflect.Value {
+	block := product.(*BlockConfirmedProduct).block
+	return []reflect.Value{reflect.ValueOf(block.Hash), reflect.ValueOf(block.Position),
+		reflect.ValueOf(block.Finalization)}
+}
+
+func (t *bdBlockDeliveredTester) ValidateResults(results []reflect.Value) error {
+	if len(results) != 0 {
+		return fmt.Errorf("unexpected return values: %v", results)
+	}
+
+	app := t.App.(*DexconApp)
+	if app.deliveredHeight != t.expectHeight {
+		return fmt.Errorf("unexpected delivered height: expect %d but %d", t.expectHeight, app.deliveredHeight)
+	}
+
+	for addr, info := range t.blockInfo.addresses {
+		if t.originalCache.addressCounter[addr] == 1 {
+			_, exist := app.addressNonce[addr]
+			if exist {
+				return fmt.Errorf("nonce cache %v should not exist", addr)
+			}
+
+			_, exist = app.addressCost[addr]
+			if exist {
+				return fmt.Errorf("cost cache %v should not exist", addr)
+			}
+
+			_, exist = app.addressCounter[addr]
+			if exist {
+				return fmt.Errorf("counter cache %v should not exist", addr)
+			}
+			continue
+		}
+
+		if app.addressNonce[addr] != t.originalCache.addressNonce[addr] {
+			return fmt.Errorf("nonce should not be affected")
+		}
+
+		expectCost := new(big.Int).Sub(t.originalCache.addressCost[addr], info.cost)
+		if expectCost.Cmp(app.addressCost[addr]) != 0 {
+			return fmt.Errorf("unexpected cost %v %v vs %v", addr, expectCost, app.addressCost[addr])
+		}
+
+		if app.addressCounter[addr]+1 != t.originalCache.addressCounter[addr] {
+			return fmt.Errorf("unexpected counter %v vs %v", app.addressCounter[addr]+1, t.originalCache.addressCounter[addr])
+		}
+	}
+
+	t.counter++
+	t.ready = false
+	return nil
+}
+
+func (t bdBlockDeliveredTester) StopTime() bool {
+	return true
+}
+
+func (t *bdBlockDeliveredTester) Rollback() error {
+	app := t.App.(*DexconApp)
+	block := app.blockchain.CurrentBlock()
+	app.blockchain.Rollback([]common.Hash{app.blockchain.CurrentBlock().Hash()})
+	rawdb.DeleteCanonicalHash(t.App.(*DexconApp).chainDB, block.NumberU64())
+	time.Sleep(100 * time.Millisecond)
+	app.txPool.Reset(app.blockchain.CurrentBlock().Header())
+
+	app.confirmedBlocks = t.originalCache.confirmedBlocks
+	app.addressNonce = t.originalCache.addressNonce
+	app.addressCost = t.originalCache.addressCost
+	app.addressCounter = t.originalCache.addressCounter
+	app.undeliveredNum++
+	app.deliveredHeight--
+	return nil
+}
+
+type TxFactory struct {
+	FactoryBase
+
+	keys []*ecdsa.PrivateKey
+
+	sendInterval time.Duration
+
+	nonce uint64
+}
+
+func (f *TxFactory) Run() {
+	blockchain := f.App.(*DexconApp).blockchain
+	txPool := f.App.(*DexconApp).txPool
+	for {
+		for i, key := range f.keys {
+			go func(at int, nonce uint64, key *ecdsa.PrivateKey) {
+				f.stopTimeMu.RLock()
+				for i := 0; i < len(f.keys); i++ {
+					if i == at {
+						continue
+					}
+
+					tx := types.NewTransaction(
+						nonce,
+						crypto.PubkeyToAddress(f.keys[i].PublicKey),
+						big.NewInt(1),
+						21000,
+						big.NewInt(10e9),
+						[]byte{})
+
+					signer := types.NewEIP155Signer(blockchain.Config().ChainID)
+
+					tx, err := types.SignTx(tx, signer, key)
+					if err != nil {
+						panic(err)
+					}
+
+					err = txPool.AddLocal(tx)
+					if err != nil {
+						panic(err)
+					}
+					nonce++
+				}
+				f.stopTimeMu.RUnlock()
+			}(i, f.nonce, key)
+		}
+
+		f.nonce += uint64(len(f.keys)) - 1
+
+		time.Sleep(f.sendInterval)
+	}
+}
+
+func (f TxFactory) New(app App, center *ProductCenter, stopTimeMu *sync.RWMutex, keys []*ecdsa.PrivateKey) *TxFactory {
+	f.FactoryBase = FactoryBase{
+		App:        app,
+		name:       reflect.TypeOf(f).Name(),
+		center:     center,
+		stopTimeMu: stopTimeMu,
+	}
+	f.keys = keys
+	f.sendInterval = 1000 * time.Millisecond
+	return &f
+}
+
+func TestDexonApp(t *testing.T) {
+	log.Root().SetHandler(log.LvlFilterHandler(log.LvlDebug, log.StdoutHandler))
+
+	masterKey, err := crypto.GenerateKey()
+	if err != nil {
+		t.Fatalf("Generate key fail: %v", err)
+	}
+
+	dex, keys, err := newDexon(masterKey, 15)
+	if err != nil {
+		t.Fatalf("New dexon fail: %v", err)
+	}
+
+	stopTimeMu := &sync.RWMutex{}
+
+	center := ProductCenter{}.New()
+	configFactory := ConfigFactory{}.New(dex.app, center, stopTimeMu, masterKey)
+	preparePayloadFactory := PreparePayloadFactory{}.NewWithTester(dex.app, center, stopTimeMu)
+	prepareWitnessFactory := PrepareWitnessFactory{}.NewWithTester(dex.app, center, stopTimeMu)
+	verifyBlockFactory := VerifyBlockFactory{}.NewWithTester(dex.app, center, stopTimeMu)
+	blockConfirmedFactory := BlockConfirmedFactory{}.NewWithTester(dex.app, center, stopTimeMu, masterKey)
+	blockDeliveredFactory := BlockDeliveredFactory{}.NewWithTester(dex.app, center, stopTimeMu)
+	txFactory := TxFactory{}.New(dex.app, center, stopTimeMu, keys)
+
+	go configFactory.Run()
+	go preparePayloadFactory.Run()
+	go prepareWitnessFactory.Run()
+	go verifyBlockFactory.Run()
+	go blockConfirmedFactory.Run()
+	go blockDeliveredFactory.Run()
+	go txFactory.Run()
+
+	timer := time.NewTimer(300 * time.Second)
+	successRecord := make(map[string]struct{})
+	for {
+		select {
+		case sig := <-preparePayloadFactory.status:
+			if _, exist := sig[runSuccess]; exist {
+				successRecord[reflect.TypeOf(*preparePayloadFactory).Name()] = struct{}{}
+			} else if msg, exist := sig[runFail]; exist {
+				t.Fatalf("preparePayloadFactory error: %v", msg)
+			}
+		case sig := <-prepareWitnessFactory.status:
+			if _, exist := sig[runSuccess]; exist {
+				successRecord[reflect.TypeOf(*prepareWitnessFactory).Name()] = struct{}{}
+			} else if msg, exist := sig[runFail]; exist {
+				t.Fatalf("prepareWitnessFactory error: %v", msg)
+			}
+		case sig := <-verifyBlockFactory.status:
+			if _, exist := sig[runSuccess]; exist {
+				successRecord[reflect.TypeOf(*verifyBlockFactory).Name()] = struct{}{}
+			} else if msg, exist := sig[runFail]; exist {
+				t.Fatalf("verifyBlockFactory error: %v", msg)
+			}
+		case sig := <-blockConfirmedFactory.status:
+			if _, exist := sig[runSuccess]; exist {
+				successRecord[reflect.TypeOf(*blockConfirmedFactory).Name()] = struct{}{}
+			} else if msg, exist := sig[runFail]; exist {
+				t.Fatalf("blockConfirmedFactory error: %v", msg)
+			}
+		case sig := <-blockDeliveredFactory.status:
+			if _, exist := sig[runSuccess]; exist {
+				successRecord[reflect.TypeOf(*blockDeliveredFactory).Name()] = struct{}{}
+			} else if msg, exist := sig[runFail]; exist {
+				t.Fatalf("blockDeliveredFactory error: %v", msg)
+			}
+		case <-timer.C:
+			t.Fatalf("time's up and all test is not finish yet: %v", successRecord)
+		}
+
+		leftTesterCount := len(preparePayloadFactory.testers) + len(prepareWitnessFactory.testers) +
+			len(verifyBlockFactory.testers) + len(blockConfirmedFactory.testers) + len(blockDeliveredFactory.testers)
+		if leftTesterCount == 0 {
+			t.Logf("tests all pass")
+			break
+		}
+
+		time.Sleep(1 * time.Second)
+	}
+}
+
+func newDexon(masterKey *ecdsa.PrivateKey, accountNum int) (*Dexon, []*ecdsa.PrivateKey, error) {
+	db := ethdb.NewMemDatabase()
+
+	genesis := core.DefaultTestnetGenesisBlock()
+	genesis.Alloc = core.GenesisAlloc{
+		crypto.PubkeyToAddress(masterKey.PublicKey): {
+			Balance:   big.NewInt(100000000000000000),
+			Staked:    big.NewInt(50000000000000000),
+			PublicKey: crypto.FromECDSAPub(&masterKey.PublicKey),
+		},
+	}
+
+	var accounts []*ecdsa.PrivateKey
+	for i := 0; i < accountNum; i++ {
+		key, err := crypto.GenerateKey()
+		if err != nil {
+			panic(err)
+		}
+
+		genesis.Alloc[crypto.PubkeyToAddress(key.PublicKey)] = core.GenesisAccount{
+			Balance: math.BigPow(10, 18),
+			Staked:  big.NewInt(0),
+		}
+		accounts = append(accounts, key)
+	}
+
+	genesis.Config.Dexcon.BlockGasLimit = 2000000
+	genesis.Config.Dexcon.RoundLength = 60
+	genesis.Config.Dexcon.Owner = crypto.PubkeyToAddress(masterKey.PublicKey)
+
+	chainConfig, _, err := core.SetupGenesisBlock(db, genesis)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	config := Config{PrivateKey: masterKey}
+	vmConfig := vm.Config{IsBlockProposer: true}
+
+	engine := dexcon.New()
+
+	dex := &Dexon{
+		chainDb:     db,
+		chainConfig: chainConfig,
+		networkID:   config.NetworkId,
+		engine:      engine,
+	}
+
+	dex.blockchain, err = core.NewBlockChain(db, nil, chainConfig, engine, vmConfig, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	txPoolConfig := core.DefaultTxPoolConfig
+	dex.txPool = core.NewTxPool(txPoolConfig, chainConfig, dex.blockchain)
+
+	dex.APIBackend = &DexAPIBackend{dex, nil}
+	dex.governance = NewDexconGovernance(dex.APIBackend, dex.chainConfig, config.PrivateKey)
+	engine.SetGovStateFetcher(dex.governance)
+	dex.app = NewDexconApp(dex.txPool, dex.blockchain, dex.governance, db, &config)
+
+	return dex, accounts, nil
+}
diff --git a/eth/helper_test.go b/eth/helper_test.go
index e4d7a28fb..9a30afef3 100644
--- a/eth/helper_test.go
+++ b/eth/helper_test.go
@@ -30,7 +30,6 @@ import (
 	"github.com/dexon-foundation/dexon/common"
 	"github.com/dexon-foundation/dexon/consensus/ethash"
 	"github.com/dexon-foundation/dexon/core"
-	"github.com/dexon-foundation/dexon/core/rawdb"
 	"github.com/dexon-foundation/dexon/core/types"
 	"github.com/dexon-foundation/dexon/core/vm"
 	"github.com/dexon-foundation/dexon/crypto"
@@ -62,9 +61,6 @@ func newTestProtocolManager(mode downloader.SyncMode, blocks int, generator func
 		genesis       = gspec.MustCommit(db)
 		blockchain, _ = core.NewBlockChain(db, nil, gspec.Config, engine, vm.Config{}, nil)
 	)
-	if err := rawdb.WriteLastRoundNumber(db, 0); err != nil {
-		panic(err)
-	}
 	chain, _ := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, blocks, generator)
 	if _, err := blockchain.InsertChain(chain); err != nil {
 		panic(err)