package dex
import (
"crypto/ecdsa"
"fmt"
"math/big"
"math/rand"
"reflect"
"sync"
"testing"
"time"
"github.com/tangerine-network/go-tangerine/common"
"github.com/tangerine-network/go-tangerine/common/math"
"github.com/tangerine-network/go-tangerine/consensus/dexcon"
"github.com/tangerine-network/go-tangerine/core"
"github.com/tangerine-network/go-tangerine/core/rawdb"
"github.com/tangerine-network/go-tangerine/core/types"
"github.com/tangerine-network/go-tangerine/core/vm"
"github.com/tangerine-network/go-tangerine/crypto"
"github.com/tangerine-network/go-tangerine/ethdb"
"github.com/tangerine-network/go-tangerine/event"
"github.com/tangerine-network/go-tangerine/rlp"
coreCommon "github.com/tangerine-network/tangerine-consensus/common"
coreCrypto "github.com/tangerine-network/tangerine-consensus/core/crypto"
coreEcdsa "github.com/tangerine-network/tangerine-consensus/core/crypto/ecdsa"
coreTypes "github.com/tangerine-network/tangerine-consensus/core/types"
)
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, rand []byte)
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 ¢er
}
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: coreTypes.GenesisHeight,
}})
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)
config, err := app.gov.RawConfiguration(t.round)
if err != nil {
return fmt.Errorf("unable to get raw configuration: %v", err)
}
blockLimit := config.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, masterKey *ecdsa.PrivateKey,
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, masterKey, 60, 5, 3),
vbTxNonceIncrementTester{}.New(app, masterKey, 70, 5, 3),
vbTxIntrinsicGasTester{}.New(app, masterKey, 80, 5, 3),
vbTxGasTooLowTester{}.New(app, masterKey, 90, 5, 3),
vbTxInvalidGasPriceTester{}.New(app, masterKey, 100, 5, 3),
vbInsufficientFundsTester{}.New(app, 110, 5, 3),
vbBlockLimitTester{}.New(app, 120, 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
key *ecdsa.PrivateKey
}
func (t vbTxNonceSequenceTester) New(app App, key *ecdsa.PrivateKey, 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,
}
t.key = key
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 err error
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, new(big.Int).SetInt64(1e9), nil), signer, t.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
key *ecdsa.PrivateKey
}
func (t vbTxNonceIncrementTester) New(app App, key *ecdsa.PrivateKey, 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,
}
t.key = key
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
var err error
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, new(big.Int).SetInt64(1e9), nil), signer, t.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
key *ecdsa.PrivateKey
}
func (t vbTxIntrinsicGasTester) New(app App, key *ecdsa.PrivateKey, 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,
}
t.key = key
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
var err error
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, new(big.Int).SetInt64(1e9), nil),
signer, t.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
key *ecdsa.PrivateKey
}
func (t vbTxGasTooLowTester) New(app App, key *ecdsa.PrivateKey, 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,
}
t.key = key
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
var err error
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, new(big.Int).SetInt64(1e9), []byte{0x00}), signer, t.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 vbTxInvalidGasPriceTester struct {
baseTester
key *ecdsa.PrivateKey
}
func (t vbTxInvalidGasPriceTester) New(app App, key *ecdsa.PrivateKey, startAt, interval,
threshold int) *vbTxInvalidGasPriceTester {
t.baseTester = baseTester{
App: app,
testTimer: time.NewTimer(time.Duration(startAt) * time.Second),
testInterval: time.Duration(interval) * time.Second,
threshold: threshold,
self: t,
}
t.key = key
return &t
}
func (t *vbTxInvalidGasPriceTester) ViewAndRecord(product Product) {
select {
case <-t.testTimer.C:
switch product.(type) {
case *PrepareWitnessProduct:
t.ready = true
}
t.testTimer.Reset(t.testInterval)
default:
}
}
func (t vbTxInvalidGasPriceTester) InputsForTest(product Product) []reflect.Value {
app := t.App.(*DexconApp)
block := product.(*PrepareWitnessProduct).block
var err error
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, new(big.Int).SetInt64(1e8), nil), signer, t.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 *vbTxInvalidGasPriceTester) 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, new(big.Int).SetInt64(1e9), 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, new(big.Int).SetInt64(1e9), 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())
block.Timestamp = time.Now()
f.stopTimeMu.RLock()
f.App.BlockConfirmed(block)
f.stopTimeMu.RUnlock()
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.Randomness)
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.Randomness)}
}
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
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.Randomness)}
}
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 {
hs, err := f.App.(*DexconApp).gov.GetHeadGovState()
if err != nil {
panic(err)
}
gasPrice := hs.MinGasPrice()
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,
gasPrice,
[]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 TestTangerineApp(t *testing.T) {
masterKey, err := crypto.GenerateKey()
if err != nil {
t.Fatalf("Generate key fail: %v", err)
}
dex, keys, err := newTangerine(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, masterKey, 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 newTangerine(masterKey *ecdsa.PrivateKey, accountNum int) (*Tangerine, []*ecdsa.PrivateKey, error) {
db := ethdb.NewMemDatabase()
genesis := core.DefaultTestnetGenesisBlock()
genesis.Alloc[crypto.PubkeyToAddress(masterKey.PublicKey)] = core.GenesisAccount{
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, 20),
Staked: big.NewInt(0),
}
accounts = append(accounts, key)
}
genesis.Config.Dexcon.BlockGasLimit = 2000000
genesis.Config.Dexcon.RoundLength = 600
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 := &Tangerine{
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
}
