updatat unit test

plugin/dapp/x2ethereum/ebrelayer/relayer/ethereum/ethereum_test.go

@@ -4,20 +4,29 @@ import (
 	"context"
 	"flag"
 	"fmt"
+	"github.com/33cn/plugin/plugin/dapp/x2ethereum/ebrelayer/ethcontract/generated"
+	"github.com/33cn/plugin/plugin/dapp/x2ethereum/ebrelayer/ethcontract/test/setup"
+	"github.com/33cn/plugin/plugin/dapp/x2ethereum/ebrelayer/ethtxs"
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+	"github.com/ethereum/go-ethereum/consensus/ethash"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/eth"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/params"
 	"math/big"
 	"os"
 	"testing"
 	"time"
 
 	dbm "github.com/33cn/chain33/common/db"
-	"github.com/33cn/plugin/plugin/dapp/x2ethereum/ebrelayer/ethcontract/generated"
-	"github.com/33cn/plugin/plugin/dapp/x2ethereum/ebrelayer/ethcontract/test/setup"
-	"github.com/33cn/plugin/plugin/dapp/x2ethereum/ebrelayer/ethtxs"
+
 	relayerTypes "github.com/33cn/plugin/plugin/dapp/x2ethereum/ebrelayer/types"
 	tml "github.com/BurntSushi/toml"
-	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/stretchr/testify/suite"
@@ -29,15 +38,21 @@ var (
 	chain33AccountAddr   = "1GTxrmuWiXavhcvsaH5w9whgVxUrWsUMdV"
 
 	passphrase = "123456hzj"
+
+	testKey, _  = crypto.HexToECDSA("8656d2bc732a8a816a461ba5e2d8aac7c7f85c26a813df30d5327210465eb230")
+	testAddr    = crypto.PubkeyToAddress(testKey.PublicKey)
+	testBalance = big.NewInt(2e18)
 )
 
 type suiteEthRelayer struct {
 	suite.Suite
 	ethRelayer *Relayer4Ethereum
+
 	sim             *backends.SimulatedBackend
 	x2EthContracts  *ethtxs.X2EthContracts
 	x2EthDeployInfo *ethtxs.X2EthDeployInfo
 	para            *ethtxs.DeployPara
+	backend         bind.ContractBackend
 }
 
 func TestRunSuiteX2Ethereum(t *testing.T) {
@@ -73,8 +88,6 @@ func (r *suiteEthRelayer) Test_1_ImportPrivateKey() {
 	validators, err = r.ethRelayer.GetValidatorAddr()
 	r.NoError(err)
 	r.Equal(validators.Chain33Validator, chain33AccountAddr)
-
-	time.Sleep(5 * time.Second)
 }
 
 func (r *suiteEthRelayer) Test_2_RestorePrivateKeys() {
@@ -87,6 +100,7 @@ func (r *suiteEthRelayer) Test_2_RestorePrivateKeys() {
 }
 
 func (r *suiteEthRelayer) Test_3_IsValidatorActive() {
+	return
 	is, err := r.ethRelayer.IsValidatorActive("0x92c8b16afd6d423652559c6e266cbe1c29bfd84f")
 	r.Equal(is, true)
 	r.NoError(err)
@@ -95,166 +109,63 @@ func (r *suiteEthRelayer) Test_3_IsValidatorActive() {
 	r.Equal(is, false)
 	r.NoError(err)
 
-	/*
-		re := regexp.MustCompile("^0x[0-9a-fA-F]{40}$")
-			if !re.MatchString(addr) {
-				return false, errors.New("this address is not an ethereum address")
-			}
-	*/
-
 	is, err = r.ethRelayer.IsValidatorActive("123")
 	r.Error(err)
 }
 
-func (r *suiteEthRelayer) Test_Relayer4Ethereum_GetAccount() {
+//func (r *suiteEthRelayer) Test_4_DeployContrcts() {
+//	bridgeRegistry, err := r.ethRelayer.DeployContrcts()
+//	r.NoError(err)
+//	r.ethRelayer.bridgeRegistryAddr = common.HexToAddress(bridgeRegistry)
+//
+//	//time.Sleep(50 * time.Second)
+//}
+
+func (r *suiteEthRelayer) Test_4_LockEth() {
+	ctx := context.Background()
+	bridgeBankBalance, err := r.sim.BalanceAt(ctx, r.x2EthDeployInfo.BridgeBank.Address, nil)
+	fmt.Println(bridgeBankBalance, err)
+	r.NoError(err)
+
+	userOneAuth, err := ethtxs.PrepareAuth(r.backend, r.para.ValidatorPriKey[0], r.para.InitValidators[0])
+	r.NoError(err)
+	ethAmount := big.NewInt(50)
+	userOneAuth.Value = ethAmount
+
+	//lock 50 eth
+	chain33Sender := []byte("14KEKbYtKKQm4wMthSK9J4La4nAiidGozt")
+	_, err = r.x2EthContracts.BridgeBank.Lock(userOneAuth, chain33Sender, common.Address{}, ethAmount)
+	r.NoError(err)
+	r.sim.Commit()
+
+	bridgeBankBalance, err = r.sim.BalanceAt(ctx, r.x2EthDeployInfo.BridgeBank.Address, nil)
+	r.NoError(err)
+	//require.Equal(t, bridgeBankBalance.Int64(), ethAmount.Int64())
+	fmt.Println(bridgeBankBalance, err)
+	time.Sleep(1 * time.Second)
 
+	query := ethereum.FilterQuery{
+		Addresses: []common.Address{r.ethRelayer.bridgeBankAddr},
+	}
+	logs, err := r.sim.FilterLogs(context.Background(), query)
+	if err != nil {
+		errinfo := fmt.Sprintf("Failed to filterLogEvents due to:%s", err.Error())
+		fmt.Println(errinfo)
+	}
+
+	for _, logv := range logs {
+		if err := r.ethRelayer.setEthTxEvent(logv); nil != err {
+			//	panic(err.Error())
+		}
+	}
+
+	time.Sleep(5 * time.Second)
 }
 
 //func (r *suiteEthRelayer) TestRelayer4Ethereum_ApproveAllowance(t *testing.T) {
 //	r.ethRelayer.ApproveAllowance()
 //}
 
-//
-//func TestEthRelayerNewRelayerManager(t *testing.T) {
-//	ctx := context.Background()
-//	println("TEST:BridgeToken creation (Chain33 assets)")
-//	//1st部署相关合约
-//	backend, para := setup.PrepareTestEnv()
-//	sim := backend.(*backends.SimulatedBackend)
-//
-//	balance, _ := sim.BalanceAt(ctx, para.Deployer, nil)
-//	fmt.Println("deployer addr,", para.Deployer.String(), "balance =", balance.String())
-//
-//	/////////////////////////EstimateGas///////////////////////////
-//	callMsg := ethereum.CallMsg{
-//		From: para.Deployer,
-//		Data: common.FromHex(generated.BridgeBankBin),
-//	}
-//
-//	gas, err := sim.EstimateGas(ctx, callMsg)
-//	if nil != err {
-//		panic("failed to estimate gas due to:" + err.Error())
-//	}
-//	fmt.Printf("\nThe estimated gas=%d", gas)
-//	////////////////////////////////////////////////////
-//
-//	x2EthContracts, x2EthDeployInfo, err := ethtxs.DeployAndInit(backend, para)
-//	if nil != err {
-//		t.Fatalf("DeployAndInit failed due to:%s", err.Error())
-//	}
-//	sim.Commit()
-//	fmt.Println("x2EthDeployInfo.BridgeBank.Address is:", x2EthDeployInfo.BridgeBank.Address.String(), x2EthContracts.BridgeBank)
-//	fmt.Println("x2EthDeployInfo.BridgeRegistry.Address is:", x2EthDeployInfo.BridgeRegistry.Address.String())
-//	///////////////////////
-//
-//	//defer func() {
-//	fmt.Println("defer remove datadir")
-//	err4 := os.RemoveAll("./datadir")
-//	if err4 != nil {
-//		fmt.Println(err4)
-//	}
-//	//}()
-//
-//	var ret = types.ReplySubTxReceipt{IsOk: true}
-//	var he = types.Header{Height: 10000}
-//
-//	mockapi := &mocks.QueueProtocolAPI{}
-//	// 这里对需要mock的方法打桩,Close是必须的，其它方法根据需要
-//	mockapi.On("Close").Return()
-//	mockapi.On("AddSubscribeTxReceipt", mock.Anything).Return(&ret, nil)
-//	mockapi.On("GetLastHeader", mock.Anything).Return(&he, nil)
-//	mockapi.On("GetConfig", mock.Anything).Return(chainTestCfg, nil)
-//
-//	mock33 := testnode.New("", mockapi)
-//	defer mock33.Close()
-//	rpcCfg := mock33.GetCfg().RPC
-//	// 这里必须设置监听端口，默认的是无效值
-//	rpcCfg.JrpcBindAddr = "127.0.0.1:8801"
-//	mock33.GetRPC().Listen()
-//
-//	if *configPath == "" {
-//		*configPath = "./../relayer.toml"
-//	}
-//	cfg := initCfg(*configPath)
-//	db := dbm.NewDB("relayer_db_service", cfg.SyncTxConfig.Dbdriver, cfg.SyncTxConfig.DbPath, cfg.SyncTxConfig.DbCache)
-//	cfg.SyncTxConfig.Chain33Host = "http://127.0.0.1:8801"
-//	cfg.SyncTxConfig.PushBind = "127.0.0.1:20000"
-//	cfg.SyncTxConfig.FetchHeightPeriodMs = 50
-//	cfg.BridgeRegistry = "" //x2EthDeployInfo.BridgeRegistry.Address.String()
-//
-//	//cfg.EthProvider = "http://127.0.0.1:1080/"
-//	//_, err = ethtxs.SetupWebsocketEthClient(cfg.EthProvider)
-//	//assert.NoError(t, err)
-//	//return
-//
-//	ctx, cancel := context.WithCancel(context.Background())
-//
-//	chain33RelayerService := ethRelayer.StartChain33Relayer(ctx, cfg.SyncTxConfig, cfg.BridgeRegistry, cfg.EthProvider, db)
-//	ethRelayerService := ethRelayer.StartEthereumRelayer(cfg.SyncTxConfig.Chain33Host, db, cfg.EthProvider, cfg.BridgeRegistry, cfg.Deploy, cfg.EthMaturityDegree, cfg.EthBlockFetchPeriod)
-//	//ethRelayer.SetClient(ethRelayerService, sim)
-//	relayerManager := NewRelayerManager(chain33RelayerService, ethRelayerService, db)
-//
-//	var result interface{}
-//
-//	setPasswdReq := relayerTypes.ReqChangePasswd{
-//		OldPassphase: "kk",
-//		NewPassphase: "123456hzj",
-//	}
-//
-//	err = relayerManager.SetPassphase(setPasswdReq, &result)
-//	//assert.NoError(t, err)
-//
-//	err = relayerManager.Unlock("123456hzj", &result)
-//	assert.NoError(t, err)
-//	fmt.Println(result)
-//
-//	err = relayerManager.ImportChain33PrivateKey4EthRelayer("0xd627968e445f2a41c92173225791bae1ba42126ae96c32f28f97ff8f226e5c68", &result)
-//	assert.NoError(t, err)
-//
-//	time.Sleep(1 * time.Second)
-//	ethRelayer.Setx2EthContractsDeployInfo(ethRelayerService, x2EthContracts, x2EthDeployInfo)
-//	fmt.Println("***************")
-//	// do something
-//	{
-//		bridgeBankBalance, err := sim.BalanceAt(ctx, x2EthDeployInfo.BridgeBank.Address, nil)
-//		require.Nil(t, err)
-//		t.Logf("origin eth bridgeBankBalance is:%d", bridgeBankBalance.Int64())
-//
-//		userOneAuth, err := ethtxs.PrepareAuth(backend, para.ValidatorPriKey[0], para.InitValidators[0])
-//		require.Nil(t, err)
-//		ethAmount := big.NewInt(50)
-//		userOneAuth.Value = ethAmount
-//
-//		fmt.Println("origin eth bridgeBankBalance is:", bridgeBankBalance.Int64())
-//		//lock 50 eth
-//		chain33Sender := []byte("14KEKbYtKKQm4wMthSK9J4La4nAiidGozt")
-//		_, err = x2EthContracts.BridgeBank.Lock(userOneAuth, chain33Sender, common.Address{}, ethAmount)
-//		require.Nil(t, err)
-//		sim.Commit()
-//
-//		bridgeBankBalance, err = sim.BalanceAt(ctx, x2EthDeployInfo.BridgeBank.Address, nil)
-//		require.Nil(t, err)
-//		require.Equal(t, bridgeBankBalance.Int64(), ethAmount.Int64())
-//		t.Logf("eth bridgeBankBalance changes to:%d", bridgeBankBalance.Int64())
-//		fmt.Println("eth bridgeBankBalance is:", bridgeBankBalance.Int64())
-//	}
-//
-//	time.Sleep(5000 * time.Second)
-//
-//	//os.Exit(0)
-//
-//	var wg sync.WaitGroup
-//
-//	ch := make(chan os.Signal, 1)
-//	signal.Notify(ch, syscall.SIGTERM)
-//	go func() {
-//		<-ch
-//		cancel()
-//		wg.Wait()
-//		os.Exit(0)
-//	}()
-//}
-
 func (r *suiteEthRelayer) newEthRelayer() *Relayer4Ethereum {
 	cfg := initCfg(*configPath)
 	cfg.SyncTxConfig.Chain33Host = "http://127.0.0.1:8801"
@@ -305,9 +216,22 @@ func (r *suiteEthRelayer) newEthRelayer() *Relayer4Ethereum {
 }
 
 func (r *suiteEthRelayer) proc() {
-	r.ethRelayer.backend = r.sim
+	backend, chain := newTestBackend(r.T())
+	client, _ := backend.Attach()
+	defer backend.Stop()
+	defer client.Close()
+
+	//r.ethRelayer.backend = r.sim
 	r.ethRelayer.clientChainID = new(big.Int)
 
+	ec := ethclient.NewClient(client)
+	r.ethRelayer.backend = ec
+	_ = chain
+
+	ctx1 := context.Background()
+	balance, _ := ec.BalanceAt(ctx1, testAddr, nil)
+	fmt.Println("deployer addr,", testAddr, "balance =", balance.String())
+
 	//等待用户导入
 	relayerLog.Info("Please unlock or import private key for Ethereum relayer")
 	nilAddr := common.Address{}
@@ -333,7 +257,7 @@ func (r *suiteEthRelayer) proc() {
 			r.ethRelayer.prePareSubscribeEvent()
 			//向bridgeBank订阅事件
 			r.ethRelayer.subscribeEvent()
-			r.filterLogEvents()
+			r.ethRelayer.filterLogEvents()
 			relayerLog.Info("Ethereum relayer starts to process online log event...")
 			timer = time.NewTicker(time.Duration(r.ethRelayer.fetchHeightPeriodMs) * time.Millisecond)
 			goto latter
@@ -353,37 +277,37 @@ latter:
 	}
 }
 
-func Test3(t *testing.T) {
-	i := 1
-	j := 1
-	for i > 0 {
-		i++
-		fmt.Println("i", i)
-		time.Sleep(time.Second)
-		goto aaa
-	}
-
-	fmt.Println("--00--")
-
-aaa:
-	for j > 0 {
-		j++
-		fmt.Println("j", j)
-		time.Sleep(time.Second)
-		if j > 3 {
-			j = 1
-			break
-		}
-	}
-
-	fmt.Println("--00--")
-}
+//func Test3(t *testing.T) {
+//	i := 1
+//	j := 1
+//	for i > 0 {
+//		i++
+//		fmt.Println("i", i)
+//		time.Sleep(time.Second)
+//		goto aaa
+//	}
+//
+//	fmt.Println("--00--")
+//
+//aaa:
+//	for j > 0 {
+//		j++
+//		fmt.Println("j", j)
+//		time.Sleep(time.Second)
+//		if j > 3 {
+//			j = 1
+//			break
+//		}
+//	}
+//
+//	fmt.Println("--00--")
+//}
 
 func (r *suiteEthRelayer) deployContracts() {
 	ctx := context.Background()
-	var backend bind.ContractBackend
-	backend, r.para = setup.PrepareTestEnvironment()
-	r.sim = backend.(*backends.SimulatedBackend)
+	//var backend bind.ContractBackend
+	r.backend, r.para = setup.PrepareTestEnvironment()
+	r.sim = r.backend.(*backends.SimulatedBackend)
 
 	balance, _ := r.sim.BalanceAt(ctx, r.para.Deployer, nil)
 	fmt.Println("deployer addr,", r.para.Deployer.String(), "balance =", balance.String())
@@ -399,42 +323,117 @@ func (r *suiteEthRelayer) deployContracts() {
 	fmt.Printf("\nThe estimated gas=%d\n", gas)
 	////////////////////////////////////////////////////
 
-	r.x2EthContracts, r.x2EthDeployInfo, err = ethtxs.DeployAndInit(backend, r.para)
+	r.x2EthContracts, r.x2EthDeployInfo, err = ethtxs.DeployAndInit(r.backend, r.para)
 	r.NoError(err)
 	r.sim.Commit()
 }
 
-func (r *suiteEthRelayer) filterLogEvents() {
-	deployHeight := int64(0)
-	height4BridgeBankLogAt := int64(r.ethRelayer.getHeight4BridgeBankLogAt())
-
-	if height4BridgeBankLogAt < deployHeight {
-		height4BridgeBankLogAt = deployHeight
-	}
-
-	curHeight := int64(0)
-	relayerLog.Info("filterLogEvents", "curHeight:", curHeight)
-
-	bridgeBankSig := make(map[string]bool)
-	bridgeBankSig[r.ethRelayer.bridgeBankEventLockSig] = true
-	bridgeBankSig[r.ethRelayer.bridgeBankEventBurnSig] = true
-	bridgeBankLog := make(chan types.Log)
-	done := make(chan int)
-	go r.ethRelayer.filterLogEventsProc(bridgeBankLog, done, "bridgeBank", curHeight, height4BridgeBankLogAt, r.ethRelayer.bridgeBankAddr, bridgeBankSig)
+//func (r *suiteEthRelayer) filterLogEvents() {
+//	deployHeight := int64(0)
+//	height4BridgeBankLogAt := int64(r.ethRelayer.getHeight4BridgeBankLogAt())
+//
+//	if height4BridgeBankLogAt < deployHeight {
+//		height4BridgeBankLogAt = deployHeight
+//	}
+//
+//	curHeight := int64(0)
+//	relayerLog.Info("filterLogEvents", "curHeight:", curHeight)
+//
+//	bridgeBankSig := make(map[string]bool)
+//	bridgeBankSig[r.ethRelayer.bridgeBankEventLockSig] = true
+//	bridgeBankSig[r.ethRelayer.bridgeBankEventBurnSig] = true
+//	bridgeBankLog := make(chan types.Log)
+//	done := make(chan int)
+//	go r.ethRelayer.filterLogEventsProc(bridgeBankLog, done, "bridgeBank", curHeight, height4BridgeBankLogAt, r.ethRelayer.bridgeBankAddr, bridgeBankSig)
+//
+//	for {
+//		select {
+//		case vLog := <-bridgeBankLog:
+//			r.ethRelayer.storeBridgeBankLogs(vLog, true)
+//		case vLog := <-r.ethRelayer.bridgeBankLog:
+//			//因为此处是同步保存信息，防止未同步完成出现panic时，直接将其设置为最新高度，中间出现部分信息不同步的情况
+//			r.ethRelayer.storeBridgeBankLogs(vLog, false)
+//		case <-done:
+//			relayerLog.Info("Finshed offline logs processed")
+//			return
+//		}
+//	}
+//}
 
-	for {
-		select {
-		case vLog := <-bridgeBankLog:
-			r.ethRelayer.storeBridgeBankLogs(vLog, true)
-		case vLog := <-r.ethRelayer.bridgeBankLog:
-			//因为此处是同步保存信息，防止未同步完成出现panic时，直接将其设置为最新高度，中间出现部分信息不同步的情况
-			r.ethRelayer.storeBridgeBankLogs(vLog, false)
-		case <-done:
-			relayerLog.Info("Finshed offline logs processed")
-			return
-		}
-	}
-}
+//func (r *suiteEthRelayer) procNewHeight(ctx context.Context, continueFailCount *int32) {
+//	*continueFailCount = 0
+//
+//	currentHeight := uint64(20)
+//	relayerLog.Info("procNewHeight", "currentHeight", currentHeight)
+//	//一次最大只获取10个logEvent进行处理
+//	fetchCnt := int32(10)
+//	for r.ethRelayer.eventLogIndex.Height+uint64(r.ethRelayer.maturityDegree)+1 <= currentHeight {
+//		logs, err := r.ethRelayer.getNextValidEthTxEventLogs(r.ethRelayer.eventLogIndex.Height, r.ethRelayer.eventLogIndex.Index, fetchCnt)
+//		if nil != err {
+//			relayerLog.Error("Failed to get ethereum height", "getNextValidEthTxEventLogs err", err.Error())
+//			return
+//		}
+//
+//		for i, vLog := range logs {
+//			if vLog.BlockNumber+uint64(r.ethRelayer.maturityDegree)+1 > currentHeight {
+//				logs = logs[:i]
+//				break
+//			}
+//			//r.ethRelayer.procBridgeBankLogs(*vLog)
+//
+//			if r.ethRelayer.checkTxProcessed(vLog.TxHash.Bytes()) {
+//				relayerLog.Info("procBridgeBankLogs", "Tx has been already Processed with hash:", vLog.TxHash.Hex(),
+//					"height", vLog.BlockNumber, "index", vLog.Index)
+//				return
+//			}
+//
+//			defer func() {
+//				if err := r.ethRelayer.setTxProcessed(vLog.TxHash.Bytes()); nil != err {
+//					panic(err.Error())
+//				}
+//			}()
+//			//lock,用于捕捉 (ETH/ERC20----->chain33) 跨链转移
+//			if vLog.Topics[0].Hex() == r.ethRelayer.bridgeBankEventLockSig {
+//				eventName := events.LogLock.String()
+//				relayerLog.Info("Relayer4Ethereum proc", "Going to process", eventName,
+//					"Block number:", vLog.BlockNumber, "Tx hash:", vLog.TxHash.Hex())
+//				err := r.ethRelayer.handleLogLockEvent(r.ethRelayer.clientChainID, r.ethRelayer.bridgeBankAbi, eventName, vLog)
+//				if err != nil {
+//					errinfo := fmt.Sprintf("Failed to handleLogLockEvent due to:%s", err.Error())
+//					relayerLog.Info("Relayer4Ethereum procBridgeBankLogs", "errinfo", errinfo)
+//					panic(errinfo)
+//				}
+//			} else if vLog.Topics[0].Hex() == r.ethRelayer.bridgeBankEventBurnSig {
+//				//burn,用于捕捉 (chain33 token----->chain33) 实现chain33资产withdraw操作，之后在chain33上实现unlock操作
+//				eventName := events.LogChain33TokenBurn.String()
+//				relayerLog.Info("Relayer4Ethereum proc", "Going to process", eventName,
+//					"Block number:", vLog.BlockNumber, "Tx hash:", vLog.TxHash.Hex())
+//				err := r.ethRelayer.handleLogBurnEvent(r.ethRelayer.clientChainID, r.ethRelayer.bridgeBankAbi, eventName, vLog)
+//				if err != nil {
+//					errinfo := fmt.Sprintf("Failed to handleLogBurnEvent due to:%s", err.Error())
+//					relayerLog.Info("Relayer4Ethereum procBridgeBankLogs", "errinfo", errinfo)
+//					panic(errinfo)
+//				}
+//			}
+//		}
+//
+//		cnt := int32(len(logs))
+//		if len(logs) > 0 {
+//			//firstHeight := logs[0].BlockNumber
+//			lastHeight := logs[cnt-1].BlockNumber
+//			index := logs[cnt-1].TxIndex
+//			//获取的数量小于批量获取数量，则认为直接
+//			r.ethRelayer.setBridgeBankProcessedHeight(lastHeight, uint32(index))
+//			r.ethRelayer.eventLogIndex.Height = lastHeight
+//			r.ethRelayer.eventLogIndex.Index = uint32(index)
+//		}
+//
+//		//当前需要处理的event数量已经少于10个，直接返回
+//		if cnt < fetchCnt {
+//			return
+//		}
+//	}
+//}
 
 func initCfg(path string) *relayerTypes.RelayerConfig {
 	var cfg relayerTypes.RelayerConfig
@@ -444,3 +443,47 @@ func initCfg(path string) *relayerTypes.RelayerConfig {
 	}
 	return &cfg
 }
+
+func newTestBackend(t *testing.T) (*node.Node, []*types.Block) {
+	// Generate test chain.
+	genesis, blocks := generateTestChain()
+
+	// Start Ethereum service.
+	var ethservice *eth.Ethereum
+	n, err := node.New(&node.Config{})
+	n.Register(func(ctx *node.ServiceContext) (node.Service, error) {
+		config := &eth.Config{Genesis: genesis}
+		config.Ethash.PowMode = ethash.ModeFake
+		ethservice, err = eth.New(ctx, config)
+		return ethservice, err
+	})
+
+	// Import the test chain.
+	if err := n.Start(); err != nil {
+		t.Fatalf("can't start test node: %v", err)
+	}
+	if _, err := ethservice.BlockChain().InsertChain(blocks[1:]); err != nil {
+		t.Fatalf("can't import test blocks: %v", err)
+	}
+	return n, blocks
+}
+
+func generateTestChain() (*core.Genesis, []*types.Block) {
+	db := rawdb.NewMemoryDatabase()
+	config := params.AllEthashProtocolChanges
+	genesis := &core.Genesis{
+		Config:    config,
+		Alloc:     core.GenesisAlloc{testAddr: {Balance: testBalance}},
+		ExtraData: []byte("test genesis"),
+		Timestamp: 9000,
+	}
+	generate := func(i int, g *core.BlockGen) {
+		g.OffsetTime(1)
+		g.SetExtra([]byte("test"))
+	}
+	gblock := genesis.ToBlock(db)
+	engine := ethash.NewFaker()
+	blocks, _ := core.GenerateChain(config, gblock, engine, db, 20, generate)
+	blocks = append([]*types.Block{gblock}, blocks...)
+	return genesis, blocks
+}

plugin/dapp/x2ethereum/executor/exec_test.go

@@ -91,8 +91,8 @@ func (x *suiteX2Ethereum) Test_1_SetConsensus() {
 	msg, err := x.x2eth.Query_GetConsensusThreshold(&types2.QueryConsensusThresholdParams{})
 	x.NoError(err)
 
-	reply := msg.(*types2.ReceiptSetConsensusThreshold)
-	x.Equal(reply.NowConsensusThreshold, int64(80))
+	reply := msg.(*types2.ReceiptQueryConsensusThreshold)
+	x.Equal(reply.ConsensusThreshold, int64(80))
 }
 
 func (x *suiteX2Ethereum) Test_2_AddValidator() {