fix linter issue

plugin/dapp/x2Ethereum/ebcli/chain33RelayerCmd.go

@@ -51,7 +51,7 @@ func importPrivatekey(cmd *cobra.Command, args []string) {
 	}
 
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ImportChain33RelayerPrivateKey", importKeyReq, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ImportChain33RelayerPrivateKey", importKeyReq, &res)
 	ctx.Run()
 }
 
@@ -67,7 +67,7 @@ func ShowValidatorAddrCmd() *cobra.Command {
 func showValidatorAddr(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 	var res string
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowChain33RelayerValidator", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowChain33RelayerValidator", nil, &res)
 	ctx.Run()
 }
 
@@ -84,7 +84,7 @@ func showChain33Relayer2EthTxs(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 
 	var res ebTypes.Txhashes
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowChain33Relayer2EthTxs", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowChain33Relayer2EthTxs", nil, &res)
 	if _, err := ctx.RunResult(); nil != err {
 		errInfo := err.Error()
 		fmt.Println("errinfo:" + errInfo)
@@ -108,6 +108,6 @@ func showChain33RelayerStatus(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 
 	var res ebTypes.RelayerRunStatus
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowChain33RelayerStatus", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowChain33RelayerStatus", nil, &res)
 	ctx.Run()
 }

plugin/dapp/x2Ethereum/ebcli/command.go

@@ -57,7 +57,7 @@ func setPwd(cmd *cobra.Command, args []string) {
 		NewPassphase: newPwd,
 	}
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.SetPassphase", params, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.SetPassphase", params, &res)
 	ctx.Run()
 }
 
@@ -74,7 +74,7 @@ func LockCmd() *cobra.Command {
 func lock(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.Lock", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.Lock", nil, &res)
 	ctx.Run()
 }
 
@@ -100,6 +100,6 @@ func unLock(cmd *cobra.Command, args []string) {
 
 	params := pwd
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.Unlock", params, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.Unlock", params, &res)
 	ctx.Run()
 }

plugin/dapp/x2Ethereum/ebcli/ethereumRelayerCmd.go

@@ -76,7 +76,7 @@ func importChain33Privatekey(cmd *cobra.Command, args []string) {
 	params := privateKey
 
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ImportChain33PrivateKey4EthRelayer", params, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ImportChain33PrivateKey4EthRelayer", params, &res)
 	ctx.Run()
 }
 
@@ -96,7 +96,7 @@ func importEthValidtorPrivatekey(cmd *cobra.Command, args []string) {
 	params := privateKey
 
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ImportEthValidatorPrivateKey", params, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ImportEthValidatorPrivateKey", params, &res)
 	ctx.Run()
 }
 
@@ -113,7 +113,7 @@ func generateEthereumPrivateKey(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 
 	var res ebTypes.Account4Show
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.GenerateEthereumPrivateKey", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.GenerateEthereumPrivateKey", nil, &res)
 	ctx.Run()
 }
 
@@ -129,7 +129,7 @@ func ShowValidatorsAddrCmd() *cobra.Command {
 func showValidatorsAddr(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 	var res ebTypes.ValidatorAddr4EthRelayer
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowEthRelayerValidator", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowEthRelayerValidator", nil, &res)
 	ctx.Run()
 }
 
@@ -146,7 +146,7 @@ func showChain33Txs(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 
 	var res ebTypes.Txhashes
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowEthRelayer2Chain33Txs", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowEthRelayer2Chain33Txs", nil, &res)
 	if _, err := ctx.RunResult(); nil != err {
 		errInfo := err.Error()
 		fmt.Println("errinfo:" + errInfo)
@@ -170,7 +170,7 @@ func showEthTxs(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 
 	var res ebTypes.Txhashes
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowEthRelayer2Chain33Txs", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowEthRelayer2Chain33Txs", nil, &res)
 	if _, err := ctx.RunResult(); nil != err {
 		errInfo := err.Error()
 		fmt.Println("errinfo:" + errInfo)
@@ -194,7 +194,7 @@ func showEthRelayerStatus(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 
 	var res ebTypes.RelayerRunStatus
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowEthRelayerStatus", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowEthRelayerStatus", nil, &res)
 	ctx.Run()
 }
 
@@ -219,7 +219,7 @@ func IsValidatorActive(cmd *cobra.Command, args []string) {
 
 	params := addr
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.IsValidatorActive", params, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.IsValidatorActive", params, &res)
 	ctx.Run()
 }
 
@@ -235,7 +235,7 @@ func ShowOperatorCmd() *cobra.Command {
 func ShowOperator(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 	var res string
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowOperator", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowOperator", nil, &res)
 	ctx.Run()
 }
 
@@ -251,7 +251,7 @@ func DeployContrctsCmd() *cobra.Command {
 func DeployContrcts(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.DeployContrcts", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.DeployContrcts", nil, &res)
 	ctx.Run()
 }
 
@@ -275,7 +275,7 @@ func ShowTxReceipt(cmd *cobra.Command, args []string) {
 	txhash, _ := cmd.Flags().GetString("hash")
 	para := txhash
 	var res ethTypes.Receipt
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowTxReceipt", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowTxReceipt", para, &res)
 	ctx.Run()
 }
 
@@ -299,7 +299,7 @@ func CreateBridgeToken(cmd *cobra.Command, args []string) {
 	token, _ := cmd.Flags().GetString("symbol")
 	para := token
 	var res ebTypes.ReplyAddr
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.CreateBridgeToken", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.CreateBridgeToken", para, &res)
 	ctx.Run()
 }
 
@@ -323,7 +323,7 @@ func CreateEthereumTokenToken(cmd *cobra.Command, args []string) {
 	token, _ := cmd.Flags().GetString("symbol")
 	para := token
 	var res ebTypes.ReplyAddr
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.CreateERC20Token", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.CreateERC20Token", para, &res)
 	ctx.Run()
 }
 
@@ -365,7 +365,7 @@ func MintErc20(cmd *cobra.Command, args []string) {
 		Amount:    realAmount.String(),
 	}
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.MintErc20", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.MintErc20", para, &res)
 	ctx.Run()
 }
 
@@ -408,7 +408,7 @@ func ApproveAllowance(cmd *cobra.Command, args []string) {
 		Amount:    realAmount.String(),
 	}
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ApproveAllowance", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ApproveAllowance", para, &res)
 	ctx.Run()
 }
 
@@ -463,7 +463,7 @@ func Burn(cmd *cobra.Command, args []string) {
 		Chain33Receiver: receiver,
 	}
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.Burn", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.Burn", para, &res)
 	ctx.Run()
 }
 
@@ -487,7 +487,7 @@ func BurnAsync(cmd *cobra.Command, args []string) {
 		Chain33Receiver: receiver,
 	}
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.BurnAsync", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.BurnAsync", para, &res)
 	ctx.Run()
 }
 
@@ -544,7 +544,7 @@ func LockEthErc20Asset(cmd *cobra.Command, args []string) {
 		Chain33Receiver: receiver,
 	}
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.LockEthErc20Asset", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.LockEthErc20Asset", para, &res)
 	ctx.Run()
 }
 
@@ -571,7 +571,7 @@ func LockEthErc20AssetAsync(cmd *cobra.Command, args []string) {
 		Chain33Receiver: receiver,
 	}
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.LockEthErc20AssetAsync", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.LockEthErc20AssetAsync", para, &res)
 	ctx.Run()
 }
 
@@ -587,7 +587,7 @@ func ShowBridgeBankAddrCmd() *cobra.Command {
 func ShowBridgeBankAddr(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 	var res ebTypes.ReplyAddr
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowBridgeBankAddr", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowBridgeBankAddr", nil, &res)
 	ctx.Run()
 }
 
@@ -603,7 +603,7 @@ func ShowBridgeRegistryAddrCmd() *cobra.Command {
 func ShowBridgeRegistryAddr(cmd *cobra.Command, args []string) {
 	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
 	var res ebTypes.ReplyAddr
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowBridgeRegistryAddr", nil, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowBridgeRegistryAddr", nil, &res)
 	ctx.Run()
 }
 
@@ -667,7 +667,7 @@ func MakeNewProphecyClaim(cmd *cobra.Command, args []string) {
 		TxHash:        txhash,
 	}
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.MakeNewProphecyClaim", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.MakeNewProphecyClaim", para, &res)
 	ctx.Run()
 }
 
@@ -697,7 +697,7 @@ func GetBalance(cmd *cobra.Command, args []string) {
 		TokenAddr: tokenAddr,
 	}
 	var res ebTypes.ReplyBalance
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.GetBalance", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.GetBalance", para, &res)
 	ctx.Run()
 }
 
@@ -722,7 +722,7 @@ func IsProphecyPending(cmd *cobra.Command, args []string) {
 	para := common.HexToHash(id)
 
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.IsProphecyPending", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.IsProphecyPending", para, &res)
 	ctx.Run()
 }
 
@@ -770,7 +770,7 @@ func TransferToken(cmd *cobra.Command, args []string) {
 		Amount:    realAmount.String(),
 	}
 	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.TransferToken", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.TransferToken", para, &res)
 	ctx.Run()
 }
 
@@ -798,6 +798,6 @@ func GetToken2address(cmd *cobra.Command, args []string) {
 		TokenAddr: tokenSymbol,
 	}
 	var res ebTypes.ReplyAddr
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowTokenAddrBySymbol", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowTokenAddrBySymbol", para, &res)
 	ctx.Run()
 }

plugin/dapp/x2Ethereum/ebcli/statics.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"github.com/33cn/chain33/rpc/jsonclient"
-	rpctypes "github.com/33cn/chain33/rpc/types"
 	ebTypes "github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/types"
 	"github.com/spf13/cobra"
 )
@@ -16,8 +15,6 @@ func StaticsCmd() *cobra.Command {
 
 	cmd.AddCommand(
 		ShowLockStaticsCmd(),
-		//ShowUnlockStaticsCmd(),
-		//ShowBurnStaticsCmd(),
 		ShowDepositStaticsCmd(),
 	)
 
@@ -46,66 +43,7 @@ func ShowLockStatics(cmd *cobra.Command, args []string) {
 		TokenAddr: tokenAddr,
 	}
 	var res ebTypes.StaticsLock
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowLockStatics", para, &res)
-	ctx.Run()
-}
-
-func ShowUnlockStaticsCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "unlock",
-		Short: "show the unlock statics of ETH or ERC20",
-		Run:   ShowUnlockStatics,
-	}
-	ShowUnlockStaticsFlags(cmd)
-	return cmd
-}
-
-func ShowUnlockStaticsFlags(cmd *cobra.Command) {
-	cmd.Flags().StringP("token", "t", "", "token address, optional, nil for ETH")
-	cmd.Flags().StringP("owner", "o", "", "owner address, optional, nil for all")
-}
-
-func ShowUnlockStatics(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	tokenAddr, _ := cmd.Flags().GetString("token")
-	owner, _ := cmd.Flags().GetString("owner")
-	para := ebTypes.StaticsRequest{
-		Owner:     owner,
-		TokenAddr: tokenAddr,
-	}
-
-	var res rpctypes.Reply
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowUnlockStatics", para, &res)
-	ctx.Run()
-}
-
-func ShowBurnStaticsCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "burn",
-		Short: "show the burn statics of chain33 asset",
-		Run:   ShowBurnStatics,
-	}
-	ShowBurnStaticsFlags(cmd)
-	return cmd
-}
-
-func ShowBurnStaticsFlags(cmd *cobra.Command) {
-	cmd.Flags().StringP("token", "t", "", "token address, optional, nil for ETH")
-	cmd.Flags().StringP("owner", "o", "", "owner address, optional, nil for all")
-}
-
-func ShowBurnStatics(cmd *cobra.Command, args []string) {
-	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
-	tokenAddr, _ := cmd.Flags().GetString("token")
-	owner, _ := cmd.Flags().GetString("owner")
-
-	para := ebTypes.StaticsRequest{
-		Owner:     owner,
-		TokenAddr: tokenAddr,
-	}
-
-	var res ebTypes.StaticsResponse
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowLockStaticsCmd", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowLockStatics", para, &res)
 	ctx.Run()
 }
 
@@ -132,6 +70,6 @@ func ShowDepositStatics(cmd *cobra.Command, args []string) {
 		TokenAddr: tokenAddr,
 	}
 	var res ebTypes.StaticsDeposit
-	ctx := jsonclient.NewRPCCtx(rpcLaddr, "RelayerManager.ShowDepositStatics", para, &res)
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ShowDepositStatics", para, &res)
 	ctx.Run()
 }

plugin/dapp/x2Ethereum/ebrelayer/ethcontract/test/bridgeBank_test.go

@@ -245,7 +245,7 @@ func TestBrigeTokenMint(t *testing.T) {
 
 	_, err = x2EthContracts.Oracle.NewOracleClaim(
 		authOracle,
-		events.CLAIM_TYPE_LOCK,
+		events.ClaimTypeLock,
 		chain33Sender,
 		ethReceiver,
 		logEvent.Token,
@@ -501,7 +501,7 @@ func TestBridgeBankUnlock(t *testing.T) {
 
 	_, err = x2EthContracts.Oracle.NewOracleClaim(
 		authOracle,
-		events.CLAIM_TYPE_BURN,
+		events.ClaimTypeBurn,
 		chain33Sender,
 		ethReceiver,
 		ethAddr,
@@ -535,7 +535,7 @@ func TestBridgeBankUnlock(t *testing.T) {
 
 	_, err = x2EthContracts.Oracle.NewOracleClaim(
 		authOracle,
-		events.CLAIM_TYPE_BURN,
+		events.ClaimTypeBurn,
 		chain33Sender,
 		ethReceiver,
 		bridgeTokenAddr,
@@ -666,7 +666,7 @@ func TestBridgeBankSecondUnlockEth(t *testing.T) {
 
 	_, err = x2EthContracts.Oracle.NewOracleClaim(
 		authOracle,
-		events.CLAIM_TYPE_BURN,
+		events.ClaimTypeBurn,
 		chain33Sender,
 		ethReceiver,
 		ethAddr,
@@ -696,7 +696,7 @@ func TestBridgeBankSecondUnlockEth(t *testing.T) {
 
 	_, err = x2EthContracts.Oracle.NewOracleClaim(
 		authOracle,
-		events.CLAIM_TYPE_BURN,
+		events.ClaimTypeBurn,
 		chain33Sender,
 		ethReceiver,
 		ethAddr,
@@ -828,7 +828,7 @@ func TestBridgeBankSedondUnlockErc20(t *testing.T) {
 	require.Nil(t, err)
 	_, err = x2EthContracts.Oracle.NewOracleClaim(
 		authOracle,
-		events.CLAIM_TYPE_BURN,
+		events.ClaimTypeBurn,
 		chain33Sender,
 		ethReceiver,
 		bridgeTokenAddr,
@@ -852,7 +852,7 @@ func TestBridgeBankSedondUnlockErc20(t *testing.T) {
 	require.Nil(t, err)
 	_, err = x2EthContracts.Oracle.NewOracleClaim(
 		authOracle,
-		events.CLAIM_TYPE_BURN,
+		events.ClaimTypeBurn,
 		chain33Sender,
 		ethReceiver,
 		bridgeTokenAddr,

plugin/dapp/x2Ethereum/ebrelayer/ethcontract/test/setup/simulatorDemo.go

-package setup
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"math/big"
-
-	"github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/ethcontract/generated"
-	"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"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-func main() {
-	// Generate a new random account and a funded simulator
-	key, _ := crypto.GenerateKey()
-
-	alloc := make(core.GenesisAlloc)
-	addr := crypto.PubkeyToAddress(key.PublicKey)
-	genesisAccount := core.GenesisAccount{
-		Balance:    big.NewInt(10000000000),
-		PrivateKey: crypto.FromECDSA(key),
-	}
-	alloc[addr] = genesisAccount
-
-	gasLimit := uint64(100000000)
-	sim := backends.NewSimulatedBackend(alloc, gasLimit)
-	ctx := context.Background()
-	gasPrice, err := sim.SuggestGasPrice(ctx)
-	if err != nil {
-		panic("Failed to SuggestGasPrice due to:" + err.Error())
-	}
-
-	auth := bind.NewKeyedTransactor(key)
-	//auth.Nonce = big.NewInt(int64(nonce))
-	auth.Value = big.NewInt(0) // in wei
-	auth.GasLimit = gasLimit
-	auth.GasPrice = gasPrice
-
-	// Deploy a token contract on the simulated blockchain
-	cosmosBridgeAddr := common.HexToAddress("0x8afdadfc88a1087c9a1d6c0f5dd04634b87f303a")
-	bridgeBankAddr := common.HexToAddress("0x0df9a824699bc5878232c9e612fe1a5346a5a368")
-	oracleAddr := common.HexToAddress("0x92c8b16afd6d423652559c6e266cbe1c29bfd84f")
-	valsetAddr := common.HexToAddress("0xcb074cb21cdddf3ce9c3c0a7ac4497d633c9d9f1")
-
-	_, _, bridgeRegistry, err := generated.DeployBridgeRegistry(auth, sim, cosmosBridgeAddr, bridgeBankAddr, oracleAddr, valsetAddr)
-	if err != nil {
-		log.Fatalf("Failed to deploy BridgeRegistry contract: %v", err)
-	}
-	balance, _ := sim.BalanceAt(ctx, addr, nil)
-	fmt.Println("balance before:", balance.String())
-
-	// Print the current (non existent) and pending name of the contract
-	cosmosBridgeAddrRetrive, _ := bridgeRegistry.Chain33Bridge(nil)
-	fmt.Println("Pre-mining cosmosBridgeAddr:", cosmosBridgeAddrRetrive.String())
-
-	cosmosBridgeAddrRetrive, _ = bridgeRegistry.Chain33Bridge(&bind.CallOpts{Pending: true})
-	fmt.Println("Pre-mining pending cosmosBridgeAddr:", cosmosBridgeAddrRetrive.String())
-
-	balance, _ = sim.BalanceAt(ctx, addr, nil)
-	fmt.Println("balance after:", balance.String())
-	// Commit all pending transactions in the simulator and print the names again
-	sim.Commit()
-
-	balance, _ = sim.BalanceAt(ctx, addr, nil)
-	fmt.Println("balance after:", balance.String())
-
-	cosmosBridgeAddrRetrive, _ = bridgeRegistry.Chain33Bridge(nil)
-	fmt.Println("Post-mining cosmosBridgeAddr:", cosmosBridgeAddrRetrive.String())
-
-	cosmosBridgeAddrRetrive, _ = bridgeRegistry.Chain33Bridge(&bind.CallOpts{Pending: true})
-	fmt.Println("Post-mining pending cosmosBridgeAddr:", cosmosBridgeAddrRetrive.String())
-
-	cosmosBridgeAddrRetrive, _ = bridgeRegistry.Chain33Bridge(nil)
-	fmt.Println("Post-mining cosmosBridgeAddr:", cosmosBridgeAddrRetrive.String())
-
-	balance, _ = sim.BalanceAt(ctx, addr, nil)
-	fmt.Println("balance after:", balance.String())
-}

plugin/dapp/x2Ethereum/ebrelayer/ethtxs/abi.go

@@ -15,22 +15,22 @@ const (
 )
 
 func LoadABI(contractName string) abi.ABI {
-	var abiJson string
+	var abiJSON string
 	switch contractName {
 	case BridgeBankABI:
-		abiJson = generated.BridgeBankABI
+		abiJSON = generated.BridgeBankABI
 	case Chain33BankABI:
-		abiJson = generated.Chain33BankABI
+		abiJSON = generated.Chain33BankABI
 	case Chain33BridgeABI:
-		abiJson = generated.Chain33BridgeABI
+		abiJSON = generated.Chain33BridgeABI
 	case EthereumBankABI:
-		abiJson = generated.EthereumBankABI
+		abiJSON = generated.EthereumBankABI
 	default:
 		panic("No abi matched")
 	}
 
 	// Convert the raw abi into a usable format
-	contractABI, err := abi.JSON(strings.NewReader(abiJson))
+	contractABI, err := abi.JSON(strings.NewReader(abiJSON))
 	if err != nil {
 		panic(err)
 	}

plugin/dapp/x2Ethereum/ebrelayer/ethtxs/auxiliary.go

@@ -6,6 +6,8 @@ import (
 	"errors"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+
 	"github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/ethcontract/generated"
 	"github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/events"
 	"github.com/ethereum/go-ethereum"
@@ -25,7 +27,7 @@ type NewProphecyClaimPara struct {
 	Txhash        []byte
 }
 
-func CreateBridgeToken(symbol string, client *ethclient.Client, para *OperatorInfo, x2EthDeployInfo *X2EthDeployInfo, x2EthContracts *X2EthContracts) (string, error) {
+func CreateBridgeToken(symbol string, backend bind.ContractBackend, para *OperatorInfo, x2EthDeployInfo *X2EthDeployInfo, x2EthContracts *X2EthContracts) (string, error) {
 	if nil == para {
 		return "", errors.New("No operator private key configured")
 	}
@@ -39,6 +41,7 @@ func CreateBridgeToken(symbol string, client *ethclient.Client, para *OperatorIn
 	// We will check logs for new events
 	logs := make(chan types.Log)
 	// Filter by contract and event, write results to logs
+	client := backend.(*ethclient.Client)
 	sub, err := client.SubscribeFilterLogs(context.Background(), query, logs)
 	if nil != err {
 		txslog.Error("CreateBrigeToken", "failed to SubscribeFilterLogs", err.Error())
@@ -54,7 +57,7 @@ func CreateBridgeToken(symbol string, client *ethclient.Client, para *OperatorIn
 	}()
 
 	//创建token
-	auth, err := PrepareAuth(client, para.PrivateKey, para.Address)
+	auth, err := PrepareAuth(backend, para.PrivateKey, para.Address)
 	if nil != err {
 		return "", err
 	}
@@ -95,7 +98,7 @@ func CreateBridgeToken(symbol string, client *ethclient.Client, para *OperatorIn
 	return logEvent.Token.String(), nil
 }
 
-func CreateERC20Token(symbol string, client *ethclient.Client, para *OperatorInfo, x2EthDeployInfo *X2EthDeployInfo, x2EthContracts *X2EthContracts) (string, error) {
+func CreateERC20Token(symbol string, backend bind.ContractBackend, para *OperatorInfo, x2EthDeployInfo *X2EthDeployInfo, x2EthContracts *X2EthContracts) (string, error) {
 	if nil == para {
 		return "", errors.New("No operator private key configured")
 	}
@@ -109,19 +112,19 @@ func CreateERC20Token(symbol string, client *ethclient.Client, para *OperatorInf
 		}
 	}()
 
-	auth, err := PrepareAuth(client, para.PrivateKey, para.Address)
+	auth, err := PrepareAuth(backend, para.PrivateKey, para.Address)
 	if nil != err {
 		return "", err
 	}
 
 	prepareDone = true
 
-	tokenAddr, tx, _, err := generated.DeployBridgeToken(auth, client, symbol)
+	tokenAddr, tx, _, err := generated.DeployBridgeToken(auth, backend, symbol)
 	if nil != err {
 		return "", err
 	}
 
-	err = waitEthTxFinished(client, tx.Hash(), "CreateERC20Token")
+	err = waitEthTxFinished(backend.(*ethclient.Client), tx.Hash(), "CreateERC20Token")
 	if nil != err {
 		return "", err
 	}
@@ -129,7 +132,7 @@ func CreateERC20Token(symbol string, client *ethclient.Client, para *OperatorInf
 	return tokenAddr.String(), nil
 }
 
-func MintERC20Token(tokenAddr, ownerAddr string, amount *big.Int, client *ethclient.Client, para *OperatorInfo) (string, error) {
+func MintERC20Token(tokenAddr, ownerAddr string, amount *big.Int, backend bind.ContractBackend, para *OperatorInfo) (string, error) {
 	if nil == para {
 		return "", errors.New("No operator private key configured")
 	}
@@ -143,14 +146,14 @@ func MintERC20Token(tokenAddr, ownerAddr string, amount *big.Int, client *ethcli
 		}
 	}()
 
-	operatorAuth, err := PrepareAuth(client, para.PrivateKey, para.Address)
+	operatorAuth, err := PrepareAuth(backend, para.PrivateKey, para.Address)
 	if nil != err {
 		return "", err
 	}
 
 	prepareDone = true
 
-	erc20TokenInstance, err := generated.NewBridgeToken(common.HexToAddress(tokenAddr), client)
+	erc20TokenInstance, err := generated.NewBridgeToken(common.HexToAddress(tokenAddr), backend)
 	if nil != err {
 		return "", err
 	}
@@ -159,7 +162,7 @@ func MintERC20Token(tokenAddr, ownerAddr string, amount *big.Int, client *ethcli
 		return "", err
 	}
 
-	err = waitEthTxFinished(client, tx.Hash(), "MintERC20Token")
+	err = waitEthTxFinished(backend.(*ethclient.Client), tx.Hash(), "MintERC20Token")
 	if nil != err {
 		return "", err
 	}
@@ -167,7 +170,7 @@ func MintERC20Token(tokenAddr, ownerAddr string, amount *big.Int, client *ethcli
 	return tx.Hash().String(), nil
 }
 
-func ApproveAllowance(ownerPrivateKeyStr, tokenAddr string, bridgeBank common.Address, amount *big.Int, client *ethclient.Client) (string, error) {
+func ApproveAllowance(ownerPrivateKeyStr, tokenAddr string, bridgeBank common.Address, amount *big.Int, backend bind.ContractBackend) (string, error) {
 	ownerPrivateKey, err := crypto.ToECDSA(common.FromHex(ownerPrivateKeyStr))
 	if nil != err {
 		return "", err
@@ -182,14 +185,14 @@ func ApproveAllowance(ownerPrivateKeyStr, tokenAddr string, bridgeBank common.Ad
 		}
 	}()
 
-	auth, err := PrepareAuth(client, ownerPrivateKey, ownerAddr)
+	auth, err := PrepareAuth(backend, ownerPrivateKey, ownerAddr)
 	if nil != err {
 		return "", err
 	}
 
 	prepareDone = true
 
-	erc20TokenInstance, err := generated.NewBridgeToken(common.HexToAddress(tokenAddr), client)
+	erc20TokenInstance, err := generated.NewBridgeToken(common.HexToAddress(tokenAddr), backend)
 	if nil != err {
 		return "", err
 	}
@@ -199,7 +202,7 @@ func ApproveAllowance(ownerPrivateKeyStr, tokenAddr string, bridgeBank common.Ad
 		return "", err
 	}
 
-	err = waitEthTxFinished(client, tx.Hash(), "ApproveAllowance")
+	err = waitEthTxFinished(backend.(*ethclient.Client), tx.Hash(), "ApproveAllowance")
 	if nil != err {
 		return "", err
 	}
@@ -207,7 +210,7 @@ func ApproveAllowance(ownerPrivateKeyStr, tokenAddr string, bridgeBank common.Ad
 	return tx.Hash().String(), nil
 }
 
-func Burn(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeBank common.Address, amount *big.Int, bridgeBankIns *generated.BridgeBank, client *ethclient.Client) (string, error) {
+func Burn(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeBank common.Address, amount *big.Int, bridgeBankIns *generated.BridgeBank, backend bind.ContractBackend) (string, error) {
 	ownerPrivateKey, err := crypto.ToECDSA(common.FromHex(ownerPrivateKeyStr))
 	if nil != err {
 		return "", err
@@ -220,7 +223,7 @@ func Burn(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeBank c
 			_, _ = revokeNonce(ownerAddr)
 		}
 	}()
-	auth, err := PrepareAuth(client, ownerPrivateKey, ownerAddr)
+	auth, err := PrepareAuth(backend, ownerPrivateKey, ownerAddr)
 	if nil != err {
 		return "", err
 	}
@@ -228,7 +231,7 @@ func Burn(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeBank c
 	prepareDone = true
 
 	tokenAddr := common.HexToAddress(tokenAddrstr)
-	tokenInstance, err := generated.NewBridgeToken(tokenAddr, client)
+	tokenInstance, err := generated.NewBridgeToken(tokenAddr, backend)
 	if nil != err {
 		return "", err
 	}
@@ -237,6 +240,7 @@ func Burn(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeBank c
 	if nil != err {
 		return "", err
 	}
+	client := backend.(*ethclient.Client)
 	err = waitEthTxFinished(client, tx.Hash(), "Approve")
 	if nil != err {
 		return "", err
@@ -245,7 +249,7 @@ func Burn(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeBank c
 
 	prepareDone = false
 
-	auth, err = PrepareAuth(client, ownerPrivateKey, ownerAddr)
+	auth, err = PrepareAuth(backend, ownerPrivateKey, ownerAddr)
 	if nil != err {
 		return "", err
 	}
@@ -264,7 +268,7 @@ func Burn(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeBank c
 	return tx.Hash().String(), nil
 }
 
-func BurnAsync(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeBank common.Address, amount *big.Int, bridgeBankIns *generated.BridgeBank, client *ethclient.Client) (string, error) {
+func BurnAsync(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeBank common.Address, amount *big.Int, bridgeBankIns *generated.BridgeBank, backend bind.ContractBackend) (string, error) {
 	ownerPrivateKey, err := crypto.ToECDSA(common.FromHex(ownerPrivateKeyStr))
 	if nil != err {
 		return "", err
@@ -278,7 +282,7 @@ func BurnAsync(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeB
 			_, _ = revokeNonce(ownerAddr)
 		}
 	}()
-	auth, err := PrepareAuth(client, ownerPrivateKey, ownerAddr)
+	auth, err := PrepareAuth(backend, ownerPrivateKey, ownerAddr)
 	if nil != err {
 		return "", err
 	}
@@ -294,8 +298,8 @@ func BurnAsync(ownerPrivateKeyStr, tokenAddrstr, chain33Receiver string, bridgeB
 	return tx.Hash().String(), nil
 }
 
-func TransferToken(tokenAddr, fromPrivateKeyStr, toAddr string, amount *big.Int, client *ethclient.Client) (string, error) {
-	tokenInstance, err := generated.NewBridgeToken(common.HexToAddress(tokenAddr), client)
+func TransferToken(tokenAddr, fromPrivateKeyStr, toAddr string, amount *big.Int, backend bind.ContractBackend) (string, error) {
+	tokenInstance, err := generated.NewBridgeToken(common.HexToAddress(tokenAddr), backend)
 	if nil != err {
 		return "", err
 	}
@@ -314,7 +318,7 @@ func TransferToken(tokenAddr, fromPrivateKeyStr, toAddr string, amount *big.Int,
 		}
 	}()
 
-	auth, err := PrepareAuth(client, fromPrivateKey, fromAddr)
+	auth, err := PrepareAuth(backend, fromPrivateKey, fromAddr)
 	if nil != err {
 		return "", err
 	}
@@ -326,14 +330,14 @@ func TransferToken(tokenAddr, fromPrivateKeyStr, toAddr string, amount *big.Int,
 		return "", err
 	}
 
-	err = waitEthTxFinished(client, tx.Hash(), "TransferFromToken")
+	err = waitEthTxFinished(backend.(*ethclient.Client), tx.Hash(), "TransferFromToken")
 	if nil != err {
 		return "", err
 	}
 	return tx.Hash().String(), nil
 }
 
-func LockEthErc20Asset(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver string, amount *big.Int, client *ethclient.Client, bridgeBank *generated.BridgeBank, bridgeBankAddr common.Address) (string, error) {
+func LockEthErc20Asset(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver string, amount *big.Int, backend bind.ContractBackend, bridgeBank *generated.BridgeBank, bridgeBankAddr common.Address) (string, error) {
 	var prepareDone bool
 	txslog.Info("LockEthErc20Asset", "ownerPrivateKeyStr", ownerPrivateKeyStr, "tokenAddrStr", tokenAddrStr, "chain33Receiver", chain33Receiver, "amount", amount.String())
 	ownerPrivateKey, err := crypto.ToECDSA(common.FromHex(ownerPrivateKeyStr))
@@ -353,11 +357,11 @@ func LockEthErc20Asset(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver string,
 	if "" != tokenAddrStr {
 		//如果是eth以外的erc20，则需要先进行approve操作
 		tokenAddr = common.HexToAddress(tokenAddrStr)
-		tokenInstance, err := generated.NewBridgeToken(tokenAddr, client)
+		tokenInstance, err := generated.NewBridgeToken(tokenAddr, backend)
 		if nil != err {
 			return "", err
 		}
-		auth, err := PrepareAuth(client, ownerPrivateKey, ownerAddr)
+		auth, err := PrepareAuth(backend, ownerPrivateKey, ownerAddr)
 		if nil != err {
 			txslog.Error("LockEthErc20Asset", "PrepareAuth err", err.Error())
 			return "", err
@@ -370,7 +374,7 @@ func LockEthErc20Asset(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver string,
 		if nil != err {
 			return "", err
 		}
-		err = waitEthTxFinished(client, tx.Hash(), "Approve")
+		err = waitEthTxFinished(backend.(*ethclient.Client), tx.Hash(), "Approve")
 		if nil != err {
 			return "", err
 		}
@@ -379,7 +383,7 @@ func LockEthErc20Asset(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver string,
 
 	prepareDone = false
 
-	auth, err := PrepareAuth(client, ownerPrivateKey, ownerAddr)
+	auth, err := PrepareAuth(backend, ownerPrivateKey, ownerAddr)
 	if nil != err {
 		txslog.Error("LockEthErc20Asset", "PrepareAuth err", err.Error())
 		return "", err
@@ -396,7 +400,7 @@ func LockEthErc20Asset(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver string,
 		txslog.Error("LockEthErc20Asset", "lock err", err.Error())
 		return "", err
 	}
-	err = waitEthTxFinished(client, tx.Hash(), "LockEthErc20Asset")
+	err = waitEthTxFinished(backend.(*ethclient.Client), tx.Hash(), "LockEthErc20Asset")
 	if nil != err {
 		txslog.Error("LockEthErc20Asset", "waitEthTxFinished err", err.Error())
 		return "", err
@@ -405,7 +409,7 @@ func LockEthErc20Asset(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver string,
 	return tx.Hash().String(), nil
 }
 
-func LockEthErc20AssetAsync(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver string, amount *big.Int, client *ethclient.Client, bridgeBank *generated.BridgeBank) (string, error) {
+func LockEthErc20AssetAsync(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver string, amount *big.Int, backend bind.ContractBackend, bridgeBank *generated.BridgeBank) (string, error) {
 	txslog.Info("LockEthErc20Asset", "ownerPrivateKeyStr", ownerPrivateKeyStr, "tokenAddrStr", tokenAddrStr, "chain33Receiver", chain33Receiver, "amount", amount.String())
 	ownerPrivateKey, err := crypto.ToECDSA(common.FromHex(ownerPrivateKeyStr))
 	if nil != err {
@@ -413,7 +417,7 @@ func LockEthErc20AssetAsync(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver st
 	}
 	ownerAddr := crypto.PubkeyToAddress(ownerPrivateKey.PublicKey)
 
-	auth, err := PrepareAuth(client, ownerPrivateKey, ownerAddr)
+	auth, err := PrepareAuth(backend, ownerPrivateKey, ownerAddr)
 	if nil != err {
 		txslog.Error("LockEthErc20Asset", "PrepareAuth err", err.Error())
 		return "", err
@@ -440,9 +444,9 @@ func LockEthErc20AssetAsync(ownerPrivateKeyStr, tokenAddrStr, chain33Receiver st
 }
 
 /////////////////NewProphecyClaim////////////////
-func MakeNewProphecyClaim(newProphecyClaimPara *NewProphecyClaimPara, client *ethclient.Client, privateKey *ecdsa.PrivateKey, transactor common.Address, x2EthContracts *X2EthContracts) (string, error) {
+func MakeNewProphecyClaim(newProphecyClaimPara *NewProphecyClaimPara, backend bind.ContractBackend, privateKey *ecdsa.PrivateKey, transactor common.Address, x2EthContracts *X2EthContracts) (string, error) {
 	var prepareDone bool
-	authVali, err := PrepareAuth(client, privateKey, transactor)
+	authVali, err := PrepareAuth(backend, privateKey, transactor)
 	if nil != err {
 		return "", err
 	}
@@ -471,7 +475,7 @@ func MakeNewProphecyClaim(newProphecyClaimPara *NewProphecyClaimPara, client *et
 	if nil != err {
 		return "", err
 	}
-	err = waitEthTxFinished(client, tx.Hash(), "MakeNewProphecyClaim")
+	err = waitEthTxFinished(backend.(*ethclient.Client), tx.Hash(), "MakeNewProphecyClaim")
 	if nil != err {
 		return "", err
 	}

plugin/dapp/x2Ethereum/ebrelayer/ethtxs/parser.go

@@ -12,7 +12,6 @@ package ethtxs
 import (
 	"crypto/ecdsa"
 	"math/big"
-	"regexp"
 	"strings"
 
 	chain33Types "github.com/33cn/chain33/types"
@@ -166,30 +165,3 @@ func Chain33MsgToProphecyClaim(event events.Chain33Msg) ProphecyClaim {
 
 	return prophecyClaim
 }
-
-// getSymbolAmountFromCoin : Parse (symbol, amount) from coin string
-func getSymbolAmountFromCoin(coin string) (string, *big.Int) {
-	coinRune := []rune(coin)
-	amount := new(big.Int)
-
-	var symbol string
-
-	// Set up regex
-	isLetter := regexp.MustCompile(`[a-z]`)
-
-	// Iterate over each rune in the coin string
-	for i, char := range coinRune {
-		// Regex will match first letter [a-z] (lowercase)
-		matched := isLetter.MatchString(string(char))
-
-		// On first match, split the coin into (amount, symbol)
-		if matched {
-			amount, _ = amount.SetString(string(coinRune[0:i]), 10)
-			symbol = string(coinRune[i:])
-
-			break
-		}
-	}
-
-	return symbol, amount
-}

plugin/dapp/x2Ethereum/ebrelayer/ethtxs/queryFromEth.go

@@ -113,13 +113,13 @@ func GetLockedFunds(bridgeBank *generated.BridgeBank, tokenAddrStr string) (stri
 	return balance.String(), nil
 }
 
-func GetDepositFunds(client *ethclient.Client, tokenAddrStr string) (string, error) {
+func GetDepositFunds(backend bind.ContractBackend, tokenAddrStr string) (string, error) {
 	if tokenAddrStr == "" {
 		return "", errors.New("nil token address")
 	}
 
 	tokenAddr := common.HexToAddress(tokenAddrStr)
-	bridgeToken, err := generated.NewBridgeToken(tokenAddr, client)
+	bridgeToken, err := generated.NewBridgeToken(tokenAddr, backend)
 	if nil != err {
 		return "", err
 	}

plugin/dapp/x2Ethereum/ebrelayer/ethtxs/recover.go

@@ -4,39 +4,39 @@ import (
 	"errors"
 
 	"github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/ethcontract/generated"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/ethclient"
 )
 
-func RecoverContractHandler(client *ethclient.Client, sender, registry common.Address) (*X2EthContracts, *X2EthDeployInfo, error) {
-	bridgeBankAddr, err := GetAddressFromBridgeRegistry(client, sender, registry, BridgeBank)
+func RecoverContractHandler(backend bind.ContractBackend, sender, registry common.Address) (*X2EthContracts, *X2EthDeployInfo, error) {
+	bridgeBankAddr, err := GetAddressFromBridgeRegistry(backend, sender, registry, BridgeBank)
 	if nil != err {
 		return nil, nil, errors.New("Failed to get addr for bridgeBank from registry")
 	}
-	bridgeBank, err := generated.NewBridgeBank(*bridgeBankAddr, client)
+	bridgeBank, err := generated.NewBridgeBank(*bridgeBankAddr, backend)
 	if nil != err {
 		return nil, nil, errors.New("Failed to NewBridgeBank")
 	}
 
-	chain33BridgeAddr, err := GetAddressFromBridgeRegistry(client, sender, registry, Chain33Bridge)
+	chain33BridgeAddr, err := GetAddressFromBridgeRegistry(backend, sender, registry, Chain33Bridge)
 	if nil != err {
 		return nil, nil, errors.New("Failed to get addr for chain33BridgeAddr from registry")
 	}
-	chain33Bridge, err := generated.NewChain33Bridge(*chain33BridgeAddr, client)
+	chain33Bridge, err := generated.NewChain33Bridge(*chain33BridgeAddr, backend)
 	if nil != err {
 		return nil, nil, errors.New("Failed to NewChain33Bridge")
 	}
 
-	oracleAddr, err := GetAddressFromBridgeRegistry(client, sender, registry, Oracle)
+	oracleAddr, err := GetAddressFromBridgeRegistry(backend, sender, registry, Oracle)
 	if nil != err {
 		return nil, nil, errors.New("Failed to get addr for oracleBridgeAddr from registry")
 	}
-	oracle, err := generated.NewOracle(*oracleAddr, client)
+	oracle, err := generated.NewOracle(*oracleAddr, backend)
 	if nil != err {
 		return nil, nil, errors.New("Failed to NewOracle")
 	}
 
-	registryInstance, _ := generated.NewBridgeRegistry(registry, client)
+	registryInstance, _ := generated.NewBridgeRegistry(registry, backend)
 	x2EthContracts := &X2EthContracts{
 		BridgeRegistry: registryInstance,
 		BridgeBank:     bridgeBank,
@@ -54,12 +54,12 @@ func RecoverContractHandler(client *ethclient.Client, sender, registry common.Ad
 	return x2EthContracts, x2EthDeployInfo, nil
 }
 
-func RecoverOracleInstance(client *ethclient.Client, sender, registry common.Address) (*generated.Oracle, error) {
-	oracleAddr, err := GetAddressFromBridgeRegistry(client, sender, registry, Oracle)
+func RecoverOracleInstance(backend bind.ContractBackend, sender, registry common.Address) (*generated.Oracle, error) {
+	oracleAddr, err := GetAddressFromBridgeRegistry(backend, sender, registry, Oracle)
 	if nil != err {
 		return nil, errors.New("Failed to get addr for oracleBridgeAddr from registry")
 	}
-	oracle, err := generated.NewOracle(*oracleAddr, client)
+	oracle, err := generated.NewOracle(*oracleAddr, backend)
 	if nil != err {
 		return nil, errors.New("Failed to NewOracle")
 	}

plugin/dapp/x2Ethereum/ebrelayer/ethtxs/registry.go

@@ -32,8 +32,8 @@ func (d ContractRegistry) String() string {
 }
 
 // GetAddressFromBridgeRegistry : utility method which queries the requested contract address from the BridgeRegistry
-func GetAddressFromBridgeRegistry(client *ethclient.Client, sender, registry common.Address, target ContractRegistry) (address *common.Address, err error) {
-	header, err := client.HeaderByNumber(context.Background(), nil)
+func GetAddressFromBridgeRegistry(backend bind.ContractBackend, sender, registry common.Address, target ContractRegistry) (address *common.Address, err error) {
+	header, err := backend.(*ethclient.Client).HeaderByNumber(context.Background(), nil)
 	if err != nil {
 		txslog.Error("GetAddressFromBridgeRegistry", "Failed to get HeaderByNumber due to:", err.Error())
 		return nil, err
@@ -48,7 +48,7 @@ func GetAddressFromBridgeRegistry(client *ethclient.Client, sender, registry com
 	}
 
 	// Initialize BridgeRegistry instance
-	registryInstance, err := bridgeRegistry.NewBridgeRegistry(registry, client)
+	registryInstance, err := bridgeRegistry.NewBridgeRegistry(registry, backend)
 	if err != nil {
 		txslog.Error("GetAddressFromBridgeRegistry", "Failed to NewBridgeRegistry to:", err.Error())
 		return nil, err

plugin/dapp/x2Ethereum/ebrelayer/ethtxs/relayToChain33.go

@@ -20,7 +20,7 @@ import (
 
 // RelayLockToChain33 : RelayLockToChain33 applies validator's signature to an EthBridgeClaim message
 //		containing information about an event on the Ethereum blockchain before relaying to the Bridge
-func RelayLockToChain33(privateKey chain33Crypto.PrivKey, claim *ebrelayerTypes.EthBridgeClaim, rpcUrl string) (string, error) {
+func RelayLockToChain33(privateKey chain33Crypto.PrivKey, claim *ebrelayerTypes.EthBridgeClaim, rpcURL string) (string, error) {
 	var res string
 
 	params := &types.Eth2Chain33{
@@ -41,7 +41,7 @@ func RelayLockToChain33(privateKey chain33Crypto.PrivKey, claim *ebrelayerTypes.
 		ActionName: types.NameEth2Chain33Action,
 		Payload:    chain33Types.MustPBToJSON(params),
 	}
-	ctx := jsonclient.NewRPCCtx(rpcUrl, "Chain33.CreateTransaction", pm, &res)
+	ctx := jsonclient.NewRPCCtx(rpcURL, "Chain33.CreateTransaction", pm, &res)
 	_, _ = ctx.RunResult()
 
 	data, err := common.FromHex(res)
@@ -71,12 +71,12 @@ func RelayLockToChain33(privateKey chain33Crypto.PrivKey, claim *ebrelayerTypes.
 	}
 	var txhash string
 
-	ctx = jsonclient.NewRPCCtx(rpcUrl, "Chain33.SendTransaction", pms, &txhash)
+	ctx = jsonclient.NewRPCCtx(rpcURL, "Chain33.SendTransaction", pms, &txhash)
 	_, err = ctx.RunResult()
 	return txhash, err
 }
 
-func RelayBurnToChain33(privateKey chain33Crypto.PrivKey, claim *ebrelayerTypes.EthBridgeClaim, rpcUrl string) (string, error) {
+func RelayBurnToChain33(privateKey chain33Crypto.PrivKey, claim *ebrelayerTypes.EthBridgeClaim, rpcURL string) (string, error) {
 	var res string
 
 	params := &types.Eth2Chain33{
@@ -97,7 +97,7 @@ func RelayBurnToChain33(privateKey chain33Crypto.PrivKey, claim *ebrelayerTypes.
 		ActionName: types.NameWithdrawEthAction,
 		Payload:    chain33Types.MustPBToJSON(params),
 	}
-	ctx := jsonclient.NewRPCCtx(rpcUrl, "Chain33.CreateTransaction", pm, &res)
+	ctx := jsonclient.NewRPCCtx(rpcURL, "Chain33.CreateTransaction", pm, &res)
 	_, _ = ctx.RunResult()
 
 	data, err := common.FromHex(res)
@@ -127,7 +127,7 @@ func RelayBurnToChain33(privateKey chain33Crypto.PrivKey, claim *ebrelayerTypes.
 	}
 	var txhash string
 
-	ctx = jsonclient.NewRPCCtx(rpcUrl, "Chain33.SendTransaction", pms, &txhash)
+	ctx = jsonclient.NewRPCCtx(rpcURL, "Chain33.SendTransaction", pms, &txhash)
 	_, err = ctx.RunResult()
 	return txhash, err
 }

plugin/dapp/x2Ethereum/ebrelayer/ethtxs/relayToEthereum.go

@@ -3,12 +3,13 @@ package ethtxs
 import (
 	"crypto/ecdsa"
 
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+
 	"github.com/33cn/chain33/common/log/log15"
 	"github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/ethcontract/generated"
 	"github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/events"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethclient"
 )
 
 var (
@@ -22,10 +23,10 @@ const (
 )
 
 // RelayOracleClaimToEthereum : relays the provided burn or lock to Chain33Bridge contract on the Ethereum network
-func RelayOracleClaimToEthereum(oracleInstance *generated.Oracle, client *ethclient.Client, sender common.Address, event events.Event, claim ProphecyClaim, privateKey *ecdsa.PrivateKey, chain33TxHash []byte) (txhash string, err error) {
+func RelayOracleClaimToEthereum(oracleInstance *generated.Oracle, backend bind.ContractBackend, sender common.Address, event events.Event, claim ProphecyClaim, privateKey *ecdsa.PrivateKey, chain33TxHash []byte) (txhash string, err error) {
 	txslog.Info("RelayProphecyClaimToEthereum", "sender", sender.String(), "event", event, "chain33Sender", common.ToHex(claim.Chain33Sender), "ethereumReceiver", claim.EthereumReceiver.String(), "TokenAddress", claim.TokenContractAddress.String(), "symbol", claim.Symbol, "Amount", claim.Amount.String(), "claimType", claim.ClaimType.String())
 
-	auth, err := PrepareAuth(client, privateKey, sender)
+	auth, err := PrepareAuth(backend, privateKey, sender)
 	if nil != err {
 		txslog.Error("RelayProphecyClaimToEthereum", "PrepareAuth err", err.Error())
 		return "", err

plugin/dapp/x2Ethereum/ebrelayer/ethtxs/utils.go

@@ -8,17 +8,16 @@ import (
 	"sync"
 	"time"
 
+	ebrelayerTypes "github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/types"
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/ethclient"
-	solsha3 "github.com/miguelmota/go-solidity-sha3"
-
-	ebrelayerTypes "github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/types"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/crypto/secp256k1"
+	"github.com/ethereum/go-ethereum/ethclient"
+	solsha3 "github.com/miguelmota/go-solidity-sha3"
 )
 
 type EthTxStatus int32
@@ -66,14 +65,6 @@ func prefixMessage(message common.Hash, key *ecdsa.PrivateKey) ([]byte, []byte)
 	return sig, prefixed
 }
 
-func loadPrivateKey(privateKey []byte) (key *ecdsa.PrivateKey, err error) {
-	key, err = crypto.ToECDSA(privateKey)
-	if nil != err {
-		return nil, err
-	}
-	return
-}
-
 // LoadSender : uses the validator's private key to load the validator's address
 func LoadSender(privateKey *ecdsa.PrivateKey) (address common.Address, err error) {
 	// Parse public key
@@ -91,7 +82,7 @@ func getNonce(sender common.Address, backend bind.ContractBackend) (*big.Int, er
 	if nonceMutex, exist := addr2Nonce[sender]; exist {
 		nonceMutex.rw.Lock()
 		defer nonceMutex.rw.Unlock()
-		nonceMutex.nonce += 1
+		nonceMutex.nonce++
 		addr2Nonce[sender] = nonceMutex
 		txslog.Debug("getNonce from cache", "address", sender.String(), "nonce", nonceMutex.nonce)
 		return big.NewInt(nonceMutex.nonce), nil
@@ -113,7 +104,7 @@ func revokeNonce(sender common.Address) (*big.Int, error) {
 	if nonceMutex, exist := addr2Nonce[sender]; exist {
 		nonceMutex.rw.Lock()
 		defer nonceMutex.rw.Unlock()
-		nonceMutex.nonce -= 1
+		nonceMutex.nonce--
 		addr2Nonce[sender] = nonceMutex
 		txslog.Debug("revokeNonce", "address", sender.String(), "nonce", nonceMutex.nonce)
 		return big.NewInt(nonceMutex.nonce), nil
@@ -122,6 +113,8 @@ func revokeNonce(sender common.Address) (*big.Int, error) {
 }
 
 func PrepareAuth(backend bind.ContractBackend, privateKey *ecdsa.PrivateKey, transactor common.Address) (*bind.TransactOpts, error) {
+	//var backend bind.ContractBackend = client
+	//client *ethclient.Client
 	if nil == privateKey || nil == backend {
 		txslog.Error("PrepareAuth", "nil input parameter", "backend", backend, "privateKey", privateKey)
 		return nil, errors.New("nil input parameter")

plugin/dapp/x2Ethereum/ebrelayer/events/events.go

@@ -25,8 +25,8 @@ const (
 )
 
 const (
-	CLAIM_TYPE_BURN = uint8(1)
-	CLAIM_TYPE_LOCK = uint8(2)
+	ClaimTypeBurn = uint8(1)
+	ClaimTypeLock = uint8(2)
 )
 
 // String : returns the event type as a string

plugin/dapp/x2Ethereum/ebrelayer/main.go

@@ -69,13 +69,13 @@ func main() {
 	mainlog.Info("db info:", " Dbdriver = ", cfg.SyncTxConfig.Dbdriver, ", DbPath = ", cfg.SyncTxConfig.DbPath, ", DbCache = ", cfg.SyncTxConfig.DbCache)
 	db := dbm.NewDB("relayer_db_service", cfg.SyncTxConfig.Dbdriver, cfg.SyncTxConfig.DbPath, cfg.SyncTxConfig.DbCache)
 
-	chain33RelayerService := chain33Relayer.StartChain33Relayer(cfg.SyncTxConfig, cfg.BridgeRegistry, cfg.EthProvider, db, ctx)
+	chain33RelayerService := chain33Relayer.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)
 
 	relayerManager := relayer.NewRelayerManager(chain33RelayerService, ethRelayerService, db)
 
 	log.Info("cfg.JrpcBindAddr = ", cfg.JrpcBindAddr)
-	startRpcServer(cfg.JrpcBindAddr, relayerManager)
+	startRPCServer(cfg.JrpcBindAddr, relayerManager)
 
 	ch := make(chan os.Signal, 1)
 	signal.Notify(ch, syscall.SIGTERM)
@@ -160,16 +160,16 @@ func (r *RPCServer) HandleHTTP(rpcPath, debugPath string) {
 	http.Handle(rpcPath, r)
 }
 
-type HttpConn struct {
+type HTTPConn struct {
 	in  io.Reader
 	out io.Writer
 }
 
-func (c *HttpConn) Read(p []byte) (n int, err error)  { return c.in.Read(p) }
-func (c *HttpConn) Write(d []byte) (n int, err error) { return c.out.Write(d) }
-func (c *HttpConn) Close() error                      { return nil }
+func (c *HTTPConn) Read(p []byte) (n int, err error)  { return c.in.Read(p) }
+func (c *HTTPConn) Write(d []byte) (n int, err error) { return c.out.Write(d) }
+func (c *HTTPConn) Close() error                      { return nil }
 
-func startRpcServer(address string, api interface{}) {
+func startRPCServer(address string, api interface{}) {
 	listener, err := net.Listen("tcp", address)
 	if err != nil {
 		fmt.Println("监听失败，端口可能已经被占用")
@@ -180,7 +180,7 @@ func startRpcServer(address string, api interface{}) {
 	srv.HandleHTTP(rpc.DefaultRPCPath, rpc.DefaultDebugPath)
 	var handler http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.URL.Path == "/" {
-			serverCodec := jsonrpc.NewServerCodec(&HttpConn{in: r.Body, out: w})
+			serverCodec := jsonrpc.NewServerCodec(&HTTPConn{in: r.Body, out: w})
 			w.Header().Set("Content-type", "application/json")
 			w.WriteHeader(200)
 			err := srv.ServeRequest(serverCodec)

plugin/dapp/x2Ethereum/ebrelayer/relayer/chain33/account.go

@@ -15,7 +15,7 @@ var (
 	start             = int(1)
 )
 
-func (chain33Relayer *Chain33Relayer) GetAccount(passphrase string) (privateKey, addr string, err error) {
+func (chain33Relayer *Relayer4Chain33) GetAccount(passphrase string) (privateKey, addr string, err error) {
 	accountInfo, err := chain33Relayer.db.Get(chain33AccountKey)
 	if nil != err {
 		return "", "", err
@@ -29,7 +29,7 @@ func (chain33Relayer *Chain33Relayer) GetAccount(passphrase string) (privateKey,
 	addr = ethAccount.Addr
 	return
 }
-func (chain33Relayer *Chain33Relayer) GetAccountAddr() (addr string, err error) {
+func (chain33Relayer *Relayer4Chain33) GetAccountAddr() (addr string, err error) {
 	accountInfo, err := chain33Relayer.db.Get(chain33AccountKey)
 	if nil != err {
 		relayerLog.Info("GetValidatorAddr", "Failed to get account from db due to:", err.Error())
@@ -44,7 +44,7 @@ func (chain33Relayer *Chain33Relayer) GetAccountAddr() (addr string, err error)
 	return
 }
 
-func (chain33Relayer *Chain33Relayer) ImportPrivateKey(passphrase, privateKeyStr string) (addr string, err error) {
+func (chain33Relayer *Relayer4Chain33) ImportPrivateKey(passphrase, privateKeyStr string) (addr string, err error) {
 	privateKeySlice, err := chain33Common.FromHex(privateKeyStr)
 	if nil != err {
 		return "", err
@@ -71,7 +71,7 @@ func (chain33Relayer *Chain33Relayer) ImportPrivateKey(passphrase, privateKeyStr
 	return
 }
 
-func (chain33Relayer *Chain33Relayer) StoreAccountWithNewPassphase(newPassphrase, oldPassphrase string) error {
+func (chain33Relayer *Relayer4Chain33) StoreAccountWithNewPassphase(newPassphrase, oldPassphrase string) error {
 	accountInfo, err := chain33Relayer.db.Get(chain33AccountKey)
 	if nil != err {
 		relayerLog.Info("StoreAccountWithNewPassphase", "pls check account is created already, err", err)
@@ -88,10 +88,10 @@ func (chain33Relayer *Chain33Relayer) StoreAccountWithNewPassphase(newPassphrase
 	return chain33Relayer.db.SetSync(chain33AccountKey, encodedInfo)
 }
 
-func (chain33Relayer *Chain33Relayer) RestorePrivateKeys(passphrase string) error {
+func (chain33Relayer *Relayer4Chain33) RestorePrivateKeys(passphrase string) error {
 	accountInfo, err := chain33Relayer.db.Get(chain33AccountKey)
 	if nil != err {
-		relayerLog.Info("No private key saved for Chain33Relayer")
+		relayerLog.Info("No private key saved for Relayer4Chain33")
 		return nil
 	}
 	ethAccount := &x2ethTypes.Account4Relayer{}
@@ -114,7 +114,7 @@ func (chain33Relayer *Chain33Relayer) RestorePrivateKeys(passphrase string) erro
 	return nil
 }
 
-func (chain33Relayer *Chain33Relayer) UpdatePrivateKey(Passphrase, privateKey string) error {
+func (chain33Relayer *Relayer4Chain33) UpdatePrivateKey(Passphrase, privateKey string) error {
 
 	return nil
 }

plugin/dapp/x2Ethereum/ebrelayer/relayer/chain33/chain33.go

@@ -11,6 +11,9 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/ethclient"
+
 	dbm "github.com/33cn/chain33/common/db"
 	log "github.com/33cn/chain33/common/log/log15"
 	"github.com/33cn/chain33/rpc/jsonclient"
@@ -24,20 +27,16 @@ import (
 	"github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/utils"
 	"github.com/33cn/plugin/plugin/dapp/x2Ethereum/types"
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/ethclient"
 )
 
 var relayerLog = log.New("module", "chain33_relayer")
 
-type Chain33Relayer struct {
-	syncTxReceipts      *syncTx.SyncTxReceipts
-	client              *ethclient.Client
+type Relayer4Chain33 struct {
+	syncTxReceipts       *syncTx.TxReceipts
+	ethBackend           bind.ContractBackend
 	rpcLaddr             string //用户向指定的blockchain节点进行rpc调用
 	fetchHeightPeriodMs  int64
 	db                   dbm.DB
-	syncTxChan          <-chan int64
-	//height              int64 //当前区块高度  +++++++++||++++++++++++||++++++++++||
-	//heightSync2App      int64 //已经同步高度           ^             ^           ^
 	lastHeight4Tx        int64 //等待被处理的具有相应的交易回执的高度
 	matDegree            int32 //成熟度         heightSync2App    matDegress   height
 	passphase            string
@@ -48,15 +47,14 @@ type Chain33Relayer struct {
 	totalTx4Chain33ToEth int64
 	statusCheckedIndex   int64
 	ctx                  context.Context
-	wg                   sync.WaitGroup
 	rwLock               sync.RWMutex
 	unlock               chan int
 	status               int32
 }
 
 // StartChain33Relayer : initializes a relayer which witnesses events on the chain33 network and relays them to Ethereum
-func StartChain33Relayer(syncTxConfig *ebTypes.SyncTxConfig, registryAddr, provider string, db dbm.DB, ctx context.Context) *Chain33Relayer {
-	relayer := &Chain33Relayer{
+func StartChain33Relayer(ctx context.Context, syncTxConfig *ebTypes.SyncTxConfig, registryAddr, provider string, db dbm.DB) *Relayer4Chain33 {
+	relayer := &Relayer4Chain33{
 		rpcLaddr:            syncTxConfig.Chain33Host,
 		fetchHeightPeriodMs: syncTxConfig.FetchHeightPeriodMs,
 		unlock:              make(chan int),
@@ -79,7 +77,7 @@ func StartChain33Relayer(syncTxConfig *ebTypes.SyncTxConfig, registryAddr, provi
 	if err != nil {
 		panic(err)
 	}
-	relayer.client = client
+	relayer.ethBackend = client
 	relayer.totalTx4Chain33ToEth = relayer.getTotalTxAmount2Eth()
 	relayer.statusCheckedIndex = relayer.getStatusCheckedIndex()
 
@@ -87,18 +85,18 @@ func StartChain33Relayer(syncTxConfig *ebTypes.SyncTxConfig, registryAddr, provi
 	return relayer
 }
 
-func (chain33Relayer *Chain33Relayer) SetPassphase(passphase string) {
+func (chain33Relayer *Relayer4Chain33) SetPassphase(passphase string) {
 	chain33Relayer.rwLock.Lock()
 	chain33Relayer.passphase = passphase
 	chain33Relayer.rwLock.Unlock()
 }
 
-func (chain33Relayer *Chain33Relayer) QueryTxhashRelay2Eth() ebTypes.Txhashes {
+func (chain33Relayer *Relayer4Chain33) QueryTxhashRelay2Eth() ebTypes.Txhashes {
 	txhashs := utils.QueryTxhashes([]byte(chain33ToEthBurnLockTxHashPrefix), chain33Relayer.db)
 	return ebTypes.Txhashes{Txhash: txhashs}
 }
 
-func (chain33Relayer *Chain33Relayer) GetRunningStatus() (relayerRunStatus *ebTypes.RelayerRunStatus) {
+func (chain33Relayer *Relayer4Chain33) GetRunningStatus() (relayerRunStatus *ebTypes.RelayerRunStatus) {
 	relayerRunStatus = &ebTypes.RelayerRunStatus{}
 	chain33Relayer.rwLock.RLock()
 	relayerRunStatus.Status = chain33Relayer.status
@@ -113,7 +111,7 @@ func (chain33Relayer *Chain33Relayer) GetRunningStatus() (relayerRunStatus *ebTy
 	return
 }
 
-func (chain33Relayer *Chain33Relayer) syncProc(syncCfg *ebTypes.SyncTxReceiptConfig) {
+func (chain33Relayer *Relayer4Chain33) syncProc(syncCfg *ebTypes.SyncTxReceiptConfig) {
 	_, _ = fmt.Fprintln(os.Stdout, "Pls unlock or import private key for Chain33 relayer")
 	<-chain33Relayer.unlock
 	_, _ = fmt.Fprintln(os.Stdout, "Chain33 relayer starts to run...")
@@ -121,7 +119,7 @@ func (chain33Relayer *Chain33Relayer) syncProc(syncCfg *ebTypes.SyncTxReceiptCon
 	chain33Relayer.syncTxReceipts = syncTx.StartSyncTxReceipt(syncCfg, chain33Relayer.db)
 	chain33Relayer.lastHeight4Tx = chain33Relayer.loadLastSyncHeight()
 
-	oracleInstance, err := relayerTx.RecoverOracleInstance(chain33Relayer.client, chain33Relayer.bridgeRegistryAddr, chain33Relayer.bridgeRegistryAddr)
+	oracleInstance, err := relayerTx.RecoverOracleInstance(chain33Relayer.ethBackend, chain33Relayer.bridgeRegistryAddr, chain33Relayer.bridgeRegistryAddr)
 	if err != nil {
 		panic(err.Error())
 	}
@@ -142,7 +140,7 @@ func (chain33Relayer *Chain33Relayer) syncProc(syncCfg *ebTypes.SyncTxReceiptCon
 	}
 }
 
-func (chain33Relayer *Chain33Relayer) getCurrentHeight() int64 {
+func (chain33Relayer *Relayer4Chain33) getCurrentHeight() int64 {
 	var res rpctypes.Header
 	ctx := jsonclient.NewRPCCtx(chain33Relayer.rpcLaddr, "Chain33.GetLastHeader", nil, &res)
 	_, err := ctx.RunResult()
@@ -152,7 +150,7 @@ func (chain33Relayer *Chain33Relayer) getCurrentHeight() int64 {
 	return res.Height
 }
 
-func (chain33Relayer *Chain33Relayer) onNewHeightProc(currentHeight int64) {
+func (chain33Relayer *Relayer4Chain33) onNewHeightProc(currentHeight int64) {
 	//检查已经提交的交易结果
 	for chain33Relayer.statusCheckedIndex < chain33Relayer.totalTx4Chain33ToEth {
 		index := chain33Relayer.statusCheckedIndex + 1
@@ -161,7 +159,7 @@ func (chain33Relayer *Chain33Relayer) onNewHeightProc(currentHeight int64) {
 			relayerLog.Error("onNewHeightProc", "getEthTxhash for index ", index, "error", err.Error())
 			break
 		}
-		status := relayerTx.GetEthTxStatus(chain33Relayer.client, txhash)
+		status := relayerTx.GetEthTxStatus(chain33Relayer.ethBackend.(*ethclient.Client), txhash)
 		//按照提交交易的先后顺序检查交易，只要出现当前交易还在pending状态，就不再检查后续交易，等到下个区块再从该交易进行检查
 		//TODO:可能会由于网络和打包挖矿的原因，使得交易执行顺序和提交顺序有差别，后续完善该检查逻辑
 		if status == relayerTx.EthTxPending.String() {
@@ -219,9 +217,9 @@ func getOracleClaimType(eventType string) events.Event {
 
 	switch eventType {
 	case events.MsgBurn.String():
-		claimType = events.Event(events.CLAIM_TYPE_BURN)
+		claimType = events.Event(events.ClaimTypeBurn)
 	case events.MsgLock.String():
-		claimType = events.Event(events.CLAIM_TYPE_LOCK)
+		claimType = events.Event(events.ClaimTypeLock)
 	default:
 		panic(errors.New("eventType invalid"))
 	}
@@ -230,7 +228,7 @@ func getOracleClaimType(eventType string) events.Event {
 }
 
 // handleBurnLockMsg : parse event data as a Chain33Msg, package it into a ProphecyClaim, then relay tx to the Ethereum Network
-func (chain33Relayer *Chain33Relayer) handleBurnLockMsg(claimEvent events.Event, receipt *chain33Types.ReceiptData, chain33TxHash []byte) error {
+func (chain33Relayer *Relayer4Chain33) handleBurnLockMsg(claimEvent events.Event, receipt *chain33Types.ReceiptData, chain33TxHash []byte) error {
 	relayerLog.Info("handleBurnLockMsg", "Received tx with hash", ethCommon.Bytes2Hex(chain33TxHash))
 
 	// Parse the witnessed event's data into a new Chain33Msg
@@ -245,7 +243,7 @@ func (chain33Relayer *Chain33Relayer) handleBurnLockMsg(claimEvent events.Event,
 	prophecyClaim := relayerTx.Chain33MsgToProphecyClaim(*chain33Msg)
 
 	// Relay the Chain33Msg to the Ethereum network
-	txhash, err := relayerTx.RelayOracleClaimToEthereum(chain33Relayer.oracleInstance, chain33Relayer.client, chain33Relayer.ethSender, claimEvent, prophecyClaim, chain33Relayer.privateKey4Ethereum, chain33TxHash)
+	txhash, err := relayerTx.RelayOracleClaimToEthereum(chain33Relayer.oracleInstance, chain33Relayer.ethBackend, chain33Relayer.ethSender, claimEvent, prophecyClaim, chain33Relayer.privateKey4Ethereum, chain33TxHash)
 	if nil != err {
 		return err
 	}

plugin/dapp/x2Ethereum/ebrelayer/relayer/chain33/store.go

@@ -21,7 +21,7 @@ func calcRelay2EthTxhash(txindex int64) []byte {
 	return []byte(fmt.Sprintf("%s-%012d", chain33ToEthBurnLockTxHashPrefix, txindex))
 }
 
-func (chain33Relayer *Chain33Relayer) updateTotalTxAmount2Eth(total int64) error {
+func (chain33Relayer *Relayer4Chain33) updateTotalTxAmount2Eth(total int64) error {
 	totalTx := &types.Int64{
 		Data: atomic.LoadInt64(&chain33Relayer.totalTx4Chain33ToEth),
 	}
@@ -29,12 +29,12 @@ func (chain33Relayer *Chain33Relayer) updateTotalTxAmount2Eth(total int64) error
 	return chain33Relayer.db.Set(chain33ToEthBurnLockTxTotalAmount, types.Encode(totalTx))
 }
 
-func (chain33Relayer *Chain33Relayer) getTotalTxAmount2Eth() int64 {
+func (chain33Relayer *Relayer4Chain33) getTotalTxAmount2Eth() int64 {
 	totalTx, _ := utils.LoadInt64FromDB(chain33ToEthBurnLockTxTotalAmount, chain33Relayer.db)
 	return totalTx
 }
 
-func (chain33Relayer *Chain33Relayer) setLastestRelay2EthTxhash(status, txhash string, txIndex int64) error {
+func (chain33Relayer *Relayer4Chain33) setLastestRelay2EthTxhash(status, txhash string, txIndex int64) error {
 	key := calcRelay2EthTxhash(txIndex)
 	ethTxStatus := &ebTypes.EthTxStatus{
 		Status: status,
@@ -44,7 +44,7 @@ func (chain33Relayer *Chain33Relayer) setLastestRelay2EthTxhash(status, txhash s
 	return chain33Relayer.db.Set(key, data)
 }
 
-func (chain33Relayer *Chain33Relayer) getEthTxhash(txIndex int64) (common.Hash, error) {
+func (chain33Relayer *Relayer4Chain33) getEthTxhash(txIndex int64) (common.Hash, error) {
 	key := calcRelay2EthTxhash(txIndex)
 	ethTxStatus := &ebTypes.EthTxStatus{}
 	data, err := chain33Relayer.db.Get(key)
@@ -58,7 +58,7 @@ func (chain33Relayer *Chain33Relayer) getEthTxhash(txIndex int64) (common.Hash,
 	return common.HexToHash(ethTxStatus.Txhash), nil
 }
 
-func (chain33Relayer *Chain33Relayer) setStatusCheckedIndex(txIndex int64) error {
+func (chain33Relayer *Relayer4Chain33) setStatusCheckedIndex(txIndex int64) error {
 	index := &types.Int64{
 		Data: txIndex,
 	}
@@ -66,13 +66,13 @@ func (chain33Relayer *Chain33Relayer) setStatusCheckedIndex(txIndex int64) error
 	return chain33Relayer.db.Set(EthTxStatusCheckedIndex, data)
 }
 
-func (chain33Relayer *Chain33Relayer) getStatusCheckedIndex() int64 {
+func (chain33Relayer *Relayer4Chain33) getStatusCheckedIndex() int64 {
 	index, _ := utils.LoadInt64FromDB(EthTxStatusCheckedIndex, chain33Relayer.db)
 	return index
 }
 
 //获取上次同步到app的高度
-func (chain33Relayer *Chain33Relayer) loadLastSyncHeight() int64 {
+func (chain33Relayer *Relayer4Chain33) loadLastSyncHeight() int64 {
 	height, err := utils.LoadInt64FromDB(lastSyncHeightPrefix, chain33Relayer.db)
 	if nil != err && err != types.ErrHeightNotExist {
 		relayerLog.Error("loadLastSyncHeight", "err:", err.Error())
@@ -81,7 +81,7 @@ func (chain33Relayer *Chain33Relayer) loadLastSyncHeight() int64 {
 	return height
 }
 
-func (chain33Relayer *Chain33Relayer) setLastSyncHeight(syncHeight int64) {
+func (chain33Relayer *Relayer4Chain33) setLastSyncHeight(syncHeight int64) {
 	bytes := types.Encode(&types.Int64{Data: syncHeight})
 	_ = chain33Relayer.db.Set(lastSyncHeightPrefix, bytes)
 }

plugin/dapp/x2Ethereum/ebrelayer/relayer/chain33/transceiver/sync/proc.go

@@ -21,7 +21,6 @@ var (
 	syncLastHeight   = []byte("syncLastHeight:")
 	txReceiptPrefix  = []byte("txReceiptPrefix:")
 	lastSequences    = []byte("lastSequences:")
-	lastSyncHeight   = []byte("lastSyncHeight:")
 	seqOperationType = []string{"SeqTypeAdd", "SeqTypeDel"}
 )
 
@@ -44,15 +43,15 @@ func pushTxReceipts(txReceipts *types.TxReceipts4Subscribe) error {
 	return err
 }
 
-type SyncTxReceipts struct {
+type TxReceipts struct {
 	db     dbm.DB
 	seqNum int64 //当前同步的序列号
 	height int64 //当前区块高度
 	quit   chan struct{}
 }
 
-func NewSyncTxReceipts(db dbm.DB) *SyncTxReceipts {
-	sync := &SyncTxReceipts{
+func NewSyncTxReceipts(db dbm.DB) *TxReceipts {
+	sync := &TxReceipts{
 		db: db,
 	}
 	sync.seqNum, _ = sync.loadBlockLastSequence()
@@ -64,7 +63,7 @@ func NewSyncTxReceipts(db dbm.DB) *SyncTxReceipts {
 }
 
 //此处添加一个高度为0的空块，只是为了查找下一个比较方便，并不需要使用其信息
-func (syncTx *SyncTxReceipts) initSyncReceiptDataBase() {
+func (syncTx *TxReceipts) initSyncReceiptDataBase() {
 	txblock0, _ := syncTx.GetTxReceipts(0)
 	if nil != txblock0 {
 		return
@@ -75,12 +74,12 @@ func (syncTx *SyncTxReceipts) initSyncReceiptDataBase() {
 	syncTx.setTxReceiptsPerBlock(txsPerBlock)
 }
 
-func (syncTx *SyncTxReceipts) Stop() {
+func (syncTx *TxReceipts) Stop() {
 	close(syncTx.quit)
 }
 
 // SaveAndSyncTxs2Relayer save block to db
-func (syncTx *SyncTxReceipts) SaveAndSyncTxs2Relayer() {
+func (syncTx *TxReceipts) SaveAndSyncTxs2Relayer() {
 	for {
 		select {
 		case txReceipts := <-txReceiptCh:
@@ -103,7 +102,7 @@ func (syncTx *SyncTxReceipts) SaveAndSyncTxs2Relayer() {
 // 所以不需要恢复过程， 读出高度即可
 
 // 处理输入流程
-func (syncTx *SyncTxReceipts) dealTxReceipts(txReceipts *types.TxReceipts4Subscribe) {
+func (syncTx *TxReceipts) dealTxReceipts(txReceipts *types.TxReceipts4Subscribe) {
 	count, start, txReceiptsParsed, err := parseTxReceipts(txReceipts)
 	if err != nil {
 		resultCh <- err
@@ -136,35 +135,34 @@ func (syncTx *SyncTxReceipts) dealTxReceipts(txReceipts *types.TxReceipts4Subscr
 	//发送回复，确认接收成功
 	resultCh <- nil
 	log.Debug("dealTxReceipts", "seqStart", start, "count", count, "maxBlockHeight", height)
-	return
 }
 
-func (syncTx *SyncTxReceipts) loadBlockLastSequence() (int64, error) {
+func (syncTx *TxReceipts) loadBlockLastSequence() (int64, error) {
 	return utils.LoadInt64FromDB(lastSequences, syncTx.db)
 }
 
-func (syncTx *SyncTxReceipts) LoadLastBlockHeight() (int64, error) {
+func (syncTx *TxReceipts) LoadLastBlockHeight() (int64, error) {
 	return utils.LoadInt64FromDB(syncLastHeight, syncTx.db)
 }
 
-func (syncTx *SyncTxReceipts) setBlockLastSequence(newSequence int64) {
+func (syncTx *TxReceipts) setBlockLastSequence(newSequence int64) {
 	Sequencebytes := types.Encode(&types.Int64{Data: newSequence})
 	syncTx.db.Set(lastSequences, Sequencebytes)
 	//同时更新内存中的seq
 	syncTx.updateSequence(newSequence)
 }
 
-func (syncTx *SyncTxReceipts) setBlockHeight(height int64) {
+func (syncTx *TxReceipts) setBlockHeight(height int64) {
 	bytes := types.Encode(&types.Int64{Data: height})
 	syncTx.db.Set(syncLastHeight, bytes)
 	atomic.StoreInt64(&syncTx.height, height)
 }
 
-func (syncTx *SyncTxReceipts) updateSequence(newSequence int64) {
+func (syncTx *TxReceipts) updateSequence(newSequence int64) {
 	atomic.StoreInt64(&syncTx.seqNum, newSequence)
 }
 
-func (syncTx *SyncTxReceipts) setTxReceiptsPerBlock(txReceipts *types.TxReceipts4SubscribePerBlk) {
+func (syncTx *TxReceipts) setTxReceiptsPerBlock(txReceipts *types.TxReceipts4SubscribePerBlk) {
 	key := txReceiptsKey4Height(txReceipts.Height)
 	value := types.Encode(txReceipts)
 	if err := syncTx.db.Set(key, value); nil != err {
@@ -172,7 +170,7 @@ func (syncTx *SyncTxReceipts) setTxReceiptsPerBlock(txReceipts *types.TxReceipts
 	}
 }
 
-func (syncTx *SyncTxReceipts) GetTxReceipts(height int64) (*types.TxReceipts4SubscribePerBlk, error) {
+func (syncTx *TxReceipts) GetTxReceipts(height int64) (*types.TxReceipts4SubscribePerBlk, error) {
 	key := txReceiptsKey4Height(height)
 	value, err := syncTx.db.Get(key)
 	if err != nil {
@@ -186,7 +184,7 @@ func (syncTx *SyncTxReceipts) GetTxReceipts(height int64) (*types.TxReceipts4Sub
 	return detail, nil
 }
 
-func (syncTx *SyncTxReceipts) GetNextValidTxReceipts(height int64) (*types.TxReceipts4SubscribePerBlk, error) {
+func (syncTx *TxReceipts) GetNextValidTxReceipts(height int64) (*types.TxReceipts4SubscribePerBlk, error) {
 	key := txReceiptsKey4Height(height)
 	helper := dbm.NewListHelper(syncTx.db)
 	TxReceipts := helper.List(txReceiptPrefix, key, 1, dbm.ListASC)
@@ -201,7 +199,7 @@ func (syncTx *SyncTxReceipts) GetNextValidTxReceipts(height int64) (*types.TxRec
 	return detail, nil
 }
 
-func (syncTx *SyncTxReceipts) delTxReceipts(height int64) {
+func (syncTx *TxReceipts) delTxReceipts(height int64) {
 	key := txReceiptsKey4Height(height)
 	_ = syncTx.db.Set(key, nil)
 }

plugin/dapp/x2Ethereum/ebrelayer/relayer/chain33/transceiver/sync/sync_tx_receipts.go

@@ -22,12 +22,12 @@ import (
 
 var (
 	log            = l.New("module", "sync.tx_receipts")
-	syncTxReceipts *SyncTxReceipts
+	syncTxReceipts *TxReceipts
 )
 
-func StartSyncTxReceipt(cfg *relayerTypes.SyncTxReceiptConfig, db dbm.DB) *SyncTxReceipts {
+func StartSyncTxReceipt(cfg *relayerTypes.SyncTxReceiptConfig, db dbm.DB) *TxReceipts {
 	log.Debug("StartSyncTxReceipt, load config", "para:", cfg)
-	log.Debug("SyncTxReceipts started ")
+	log.Debug("TxReceipts started ")
 
 	bindOrResumePush(cfg)
 	syncTxReceipts = NewSyncTxReceipts(db)

plugin/dapp/x2Ethereum/ebrelayer/relayer/ethereum/account.go

@@ -29,7 +29,7 @@ var (
 )
 
 type Key struct {
-	Id uuid.UUID // Version 4 "random" for unique id not derived from key data
+	ID uuid.UUID // Version 4 "random" for unique id not derived from key data
 	// to simplify lookups we also store the address
 	Address common.Address
 	// we only store privkey as pubkey/address can be derived from it
@@ -37,7 +37,7 @@ type Key struct {
 	PrivateKey *ecdsa.PrivateKey
 }
 
-func (ethRelayer *EthereumRelayer) NewAccount(passphrase string) (privateKeystr, addr string, err error) {
+func (ethRelayer *Relayer4Ethereum) NewAccount(passphrase string) (privateKeystr, addr string, err error) {
 	var privateKey *ecdsa.PrivateKey
 	privateKey, privateKeystr, addr, err = newKeyAndStore(ethRelayer.db, crand.Reader, passphrase)
 	if err != nil {
@@ -47,7 +47,7 @@ func (ethRelayer *EthereumRelayer) NewAccount(passphrase string) (privateKeystr,
 	return
 }
 
-func (ethRelayer *EthereumRelayer) GetAccount(passphrase string) (privateKey, addr string, err error) {
+func (ethRelayer *Relayer4Ethereum) GetAccount(passphrase string) (privateKey, addr string, err error) {
 	accountInfo, err := ethRelayer.db.Get(ethAccountKey)
 	if nil != err {
 		return "", "", err
@@ -62,7 +62,7 @@ func (ethRelayer *EthereumRelayer) GetAccount(passphrase string) (privateKey, ad
 	return
 }
 
-func (ethRelayer *EthereumRelayer) GetValidatorAddr() (validators x2ethTypes.ValidatorAddr4EthRelayer, err error) {
+func (ethRelayer *Relayer4Ethereum) GetValidatorAddr() (validators x2ethTypes.ValidatorAddr4EthRelayer, err error) {
 	var ethAccountAddr string
 	var chain33AccountAddr string
 	accountInfo, err := ethRelayer.db.Get(ethAccountKey)
@@ -92,7 +92,7 @@ func (ethRelayer *EthereumRelayer) GetValidatorAddr() (validators x2ethTypes.Val
 	return
 }
 
-func (ethRelayer *EthereumRelayer) RestorePrivateKeys(passPhase string) (err error) {
+func (ethRelayer *Relayer4Ethereum) RestorePrivateKeys(passPhase string) (err error) {
 	accountInfo, err := ethRelayer.db.Get(ethAccountKey)
 	if nil == err {
 		ethAccount := &x2ethTypes.Account4Relayer{}
@@ -135,7 +135,7 @@ func (ethRelayer *EthereumRelayer) RestorePrivateKeys(passPhase string) (err err
 	return nil
 }
 
-func (ethRelayer *EthereumRelayer) StoreAccountWithNewPassphase(newPassphrase, oldPassphrase string) error {
+func (ethRelayer *Relayer4Ethereum) StoreAccountWithNewPassphase(newPassphrase, oldPassphrase string) error {
 	accountInfo, err := ethRelayer.db.Get(ethAccountKey)
 	if nil != err {
 		relayerLog.Info("StoreAccountWithNewPassphase", "pls check account is created already, err", err)
@@ -152,7 +152,7 @@ func (ethRelayer *EthereumRelayer) StoreAccountWithNewPassphase(newPassphrase, o
 	return ethRelayer.db.SetSync(ethAccountKey, encodedInfo)
 }
 
-func (ethRelayer *EthereumRelayer) ImportChain33PrivateKey(passphrase, privateKeyStr string) error {
+func (ethRelayer *Relayer4Ethereum) ImportChain33PrivateKey(passphrase, privateKeyStr string) error {
 	var driver secp256k1.Driver
 	privateKeySli, err := chain33Common.FromHex(privateKeyStr)
 	if nil != err {
@@ -181,7 +181,7 @@ func (ethRelayer *EthereumRelayer) ImportChain33PrivateKey(passphrase, privateKe
 	return ethRelayer.db.SetSync(chain33AccountKey, encodedInfo)
 }
 
-func (ethRelayer *EthereumRelayer) ImportEthValidatorPrivateKey(passphrase, privateKeyStr string) error {
+func (ethRelayer *Relayer4Ethereum) ImportEthValidatorPrivateKey(passphrase, privateKeyStr string) error {
 	privateKeySli, err := chain33Common.FromHex(privateKeyStr)
 	if nil != err {
 		return err
@@ -285,7 +285,7 @@ func newKey(rand io.Reader) (*Key, error) {
 func newKeyFromECDSA(privateKeyECDSA *ecdsa.PrivateKey) *Key {
 	id := uuid.NewRandom()
 	key := &Key{
-		Id:         id,
+		ID:         id,
 		Address:    crypto.PubkeyToAddress(privateKeyECDSA.PublicKey),
 		PrivateKey: privateKeyECDSA,
 	}

plugin/dapp/x2Ethereum/ebrelayer/relayer/ethereum/ethereum.go

@@ -38,7 +38,7 @@ import (
 	ebTypes "github.com/33cn/plugin/plugin/dapp/x2Ethereum/ebrelayer/types"
 )
 
-type EthereumRelayer struct {
+type Relayer4Ethereum struct {
 	provider           string
 	clientChainID      *big.Int
 	bridgeRegistryAddr common.Address
@@ -57,16 +57,13 @@ type EthereumRelayer struct {
 	fetchHeightPeriodMs    int32
 	eventLogIndex          ebTypes.EventLogIndex
 	status                 int32
-	client               *ethclient.Client
+	backend                bind.ContractBackend
 	bridgeBankAddr         common.Address
-	//chain33BridgeAddr      common.Address
 	bridgeBankSub          ethereum.Subscription
 	bridgeBankLog          chan types.Log
 	bridgeBankEventLockSig string
 	bridgeBankEventBurnSig string
-	//chain33BridgeEventSig  string
 	bridgeBankAbi          abi.ABI
-	//chain33BridgeAbi       abi.ABI
 	deployInfo             *ebTypes.Deploy
 	x2EthDeployInfo        *ethtxs.X2EthDeployInfo
 	deployPara             *ethtxs.DeployPara
@@ -82,11 +79,11 @@ const (
 	DefaultBlockPeriod = 5000
 )
 
-func StartEthereumRelayer(rpcURL2Chain33 string, db dbm.DB, provider, registryAddress string, deploy *ebTypes.Deploy, degree, blockInterval int32) *EthereumRelayer {
+func StartEthereumRelayer(rpcURL2Chain33 string, db dbm.DB, provider, registryAddress string, deploy *ebTypes.Deploy, degree, blockInterval int32) *Relayer4Ethereum {
 	if 0 == blockInterval {
 		blockInterval = DefaultBlockPeriod
 	}
-	relayer := &EthereumRelayer{
+	relayer := &Relayer4Ethereum{
 		provider:            provider,
 		db:                  db,
 		unlockchan:          make(chan int, 2),
@@ -115,7 +112,7 @@ func StartEthereumRelayer(rpcURL2Chain33 string, db dbm.DB, provider, registryAd
 	return relayer
 }
 
-func (ethRelayer *EthereumRelayer) SetPrivateKey4Ethereum(privateKey4Ethereum *ecdsa.PrivateKey) {
+func (ethRelayer *Relayer4Ethereum) SetPrivateKey4Ethereum(privateKey4Ethereum *ecdsa.PrivateKey) {
 	ethRelayer.rwLock.Lock()
 	defer ethRelayer.rwLock.Unlock()
 	ethRelayer.privateKey4Ethereum = privateKey4Ethereum
@@ -124,7 +121,7 @@ func (ethRelayer *EthereumRelayer) SetPrivateKey4Ethereum(privateKey4Ethereum *e
 	}
 }
 
-func (ethRelayer *EthereumRelayer) GetRunningStatus() (relayerRunStatus *ebTypes.RelayerRunStatus) {
+func (ethRelayer *Relayer4Ethereum) GetRunningStatus() (relayerRunStatus *ebTypes.RelayerRunStatus) {
 	relayerRunStatus = &ebTypes.RelayerRunStatus{}
 	ethRelayer.rwLock.RLock()
 	relayerRunStatus.Status = ethRelayer.status
@@ -143,7 +140,7 @@ func (ethRelayer *EthereumRelayer) GetRunningStatus() (relayerRunStatus *ebTypes
 	return
 }
 
-func (ethRelayer *EthereumRelayer) recoverDeployPara() (err error) {
+func (ethRelayer *Relayer4Ethereum) recoverDeployPara() (err error) {
 	if nil == ethRelayer.deployInfo {
 		return nil
 	}
@@ -162,7 +159,7 @@ func (ethRelayer *EthereumRelayer) recoverDeployPara() (err error) {
 }
 
 //部署以太坊合约
-func (ethRelayer *EthereumRelayer) DeployContrcts() (bridgeRegistry string, err error) {
+func (ethRelayer *Relayer4Ethereum) DeployContrcts() (bridgeRegistry string, err error) {
 	bridgeRegistry = ""
 	if nil == ethRelayer.deployInfo {
 		return bridgeRegistry, errors.New("No deploy info configured yet")
@@ -207,7 +204,7 @@ func (ethRelayer *EthereumRelayer) DeployContrcts() (bridgeRegistry string, err
 			"power", power.String())
 	}
 
-	x2EthContracts, x2EthDeployInfo, err := ethtxs.DeployAndInit(ethRelayer.client, para)
+	x2EthContracts, x2EthDeployInfo, err := ethtxs.DeployAndInit(ethRelayer.backend, para)
 	if err != nil {
 		return bridgeRegistry, err
 	}
@@ -229,11 +226,11 @@ func (ethRelayer *EthereumRelayer) DeployContrcts() (bridgeRegistry string, err
 }
 
 //GetBalance：获取某一个币种的余额
-func (ethRelayer *EthereumRelayer) GetBalance(tokenAddr, owner string) (string, error) {
-	return ethtxs.GetBalance(ethRelayer.client, tokenAddr, owner)
+func (ethRelayer *Relayer4Ethereum) GetBalance(tokenAddr, owner string) (string, error) {
+	return ethtxs.GetBalance(ethRelayer.backend.(*ethclient.Client), tokenAddr, owner)
 }
 
-func (ethRelayer *EthereumRelayer) ShowBridgeBankAddr() (string, error) {
+func (ethRelayer *Relayer4Ethereum) ShowBridgeBankAddr() (string, error) {
 	if nil == ethRelayer.x2EthDeployInfo {
 		return "", errors.New("The relayer is not started yes")
 	}
@@ -241,7 +238,7 @@ func (ethRelayer *EthereumRelayer) ShowBridgeBankAddr() (string, error) {
 	return ethRelayer.x2EthDeployInfo.BridgeBank.Address.String(), nil
 }
 
-func (ethRelayer *EthereumRelayer) ShowBridgeRegistryAddr() (string, error) {
+func (ethRelayer *Relayer4Ethereum) ShowBridgeRegistryAddr() (string, error) {
 	if nil == ethRelayer.x2EthDeployInfo {
 		return "", errors.New("The relayer is not started yes")
 	}
@@ -249,100 +246,101 @@ func (ethRelayer *EthereumRelayer) ShowBridgeRegistryAddr() (string, error) {
 	return ethRelayer.x2EthDeployInfo.BridgeRegistry.Address.String(), nil
 }
 
-func (ethRelayer *EthereumRelayer) ShowLockStatics(tokenAddr string) (string, error) {
+func (ethRelayer *Relayer4Ethereum) ShowLockStatics(tokenAddr string) (string, error) {
 	return ethtxs.GetLockedFunds(ethRelayer.x2EthContracts.BridgeBank, tokenAddr)
 }
 
-func (ethRelayer *EthereumRelayer) ShowDepositStatics(tokenAddr string) (string, error) {
-	return ethtxs.GetDepositFunds(ethRelayer.client, tokenAddr)
+func (ethRelayer *Relayer4Ethereum) ShowDepositStatics(tokenAddr string) (string, error) {
+	return ethtxs.GetDepositFunds(ethRelayer.backend, tokenAddr)
 }
 
-func (ethRelayer *EthereumRelayer) ShowTokenAddrBySymbol(tokenSymbol string) (string, error) {
+func (ethRelayer *Relayer4Ethereum) ShowTokenAddrBySymbol(tokenSymbol string) (string, error) {
 	return ethtxs.GetToken2address(ethRelayer.x2EthContracts.BridgeBank, tokenSymbol)
 }
 
-func (ethRelayer *EthereumRelayer) IsProphecyPending(claimID [32]byte) (bool, error) {
+func (ethRelayer *Relayer4Ethereum) IsProphecyPending(claimID [32]byte) (bool, error) {
 	return ethtxs.IsProphecyPending(claimID, ethRelayer.ethValidator, ethRelayer.x2EthContracts.Chain33Bridge)
 }
 
-func (ethRelayer *EthereumRelayer) MakeNewProphecyClaim(newProphecyClaimPara *ethtxs.NewProphecyClaimPara) (string, error) {
-	return ethtxs.MakeNewProphecyClaim(newProphecyClaimPara, ethRelayer.client, ethRelayer.privateKey4Ethereum, ethRelayer.ethValidator, ethRelayer.x2EthContracts)
+func (ethRelayer *Relayer4Ethereum) MakeNewProphecyClaim(newProphecyClaimPara *ethtxs.NewProphecyClaimPara) (string, error) {
+	return ethtxs.MakeNewProphecyClaim(newProphecyClaimPara, ethRelayer.backend, ethRelayer.privateKey4Ethereum, ethRelayer.ethValidator, ethRelayer.x2EthContracts)
 }
 
-func (ethRelayer *EthereumRelayer) CreateBridgeToken(symbol string) (string, error) {
-	return ethtxs.CreateBridgeToken(symbol, ethRelayer.client, ethRelayer.operatorInfo, ethRelayer.x2EthDeployInfo, ethRelayer.x2EthContracts)
+func (ethRelayer *Relayer4Ethereum) CreateBridgeToken(symbol string) (string, error) {
+	return ethtxs.CreateBridgeToken(symbol, ethRelayer.backend, ethRelayer.operatorInfo, ethRelayer.x2EthDeployInfo, ethRelayer.x2EthContracts)
 }
 
-func (ethRelayer *EthereumRelayer) CreateERC20Token(symbol string) (string, error) {
-	return ethtxs.CreateERC20Token(symbol, ethRelayer.client, ethRelayer.operatorInfo, ethRelayer.x2EthDeployInfo, ethRelayer.x2EthContracts)
+func (ethRelayer *Relayer4Ethereum) CreateERC20Token(symbol string) (string, error) {
+	return ethtxs.CreateERC20Token(symbol, ethRelayer.backend, ethRelayer.operatorInfo, ethRelayer.x2EthDeployInfo, ethRelayer.x2EthContracts)
 }
 
-func (ethRelayer *EthereumRelayer) MintERC20Token(tokenAddr, ownerAddr, amount string) (string, error) {
+func (ethRelayer *Relayer4Ethereum) MintERC20Token(tokenAddr, ownerAddr, amount string) (string, error) {
 	bn := big.NewInt(1)
 	bn, _ = bn.SetString(x2ethTypes.TrimZeroAndDot(amount), 10)
-	return ethtxs.MintERC20Token(tokenAddr, ownerAddr, bn, ethRelayer.client, ethRelayer.operatorInfo)
+	return ethtxs.MintERC20Token(tokenAddr, ownerAddr, bn, ethRelayer.backend, ethRelayer.operatorInfo)
 }
 
-func (ethRelayer *EthereumRelayer) ApproveAllowance(ownerPrivateKey, tokenAddr, amount string) (string, error) {
+func (ethRelayer *Relayer4Ethereum) ApproveAllowance(ownerPrivateKey, tokenAddr, amount string) (string, error) {
 	bn := big.NewInt(1)
 	bn, _ = bn.SetString(x2ethTypes.TrimZeroAndDot(amount), 10)
-	return ethtxs.ApproveAllowance(ownerPrivateKey, tokenAddr, ethRelayer.x2EthDeployInfo.BridgeBank.Address, bn, ethRelayer.client)
+	return ethtxs.ApproveAllowance(ownerPrivateKey, tokenAddr, ethRelayer.x2EthDeployInfo.BridgeBank.Address, bn, ethRelayer.backend)
 }
 
-func (ethRelayer *EthereumRelayer) Burn(ownerPrivateKey, tokenAddr, chain33Receiver, amount string) (string, error) {
+func (ethRelayer *Relayer4Ethereum) Burn(ownerPrivateKey, tokenAddr, chain33Receiver, amount string) (string, error) {
 	bn := big.NewInt(1)
 	bn, _ = bn.SetString(x2ethTypes.TrimZeroAndDot(amount), 10)
-	return ethtxs.Burn(ownerPrivateKey, tokenAddr, chain33Receiver, ethRelayer.x2EthDeployInfo.BridgeBank.Address, bn, ethRelayer.x2EthContracts.BridgeBank, ethRelayer.client)
+	return ethtxs.Burn(ownerPrivateKey, tokenAddr, chain33Receiver, ethRelayer.x2EthDeployInfo.BridgeBank.Address, bn, ethRelayer.x2EthContracts.BridgeBank, ethRelayer.backend)
 }
 
-func (ethRelayer *EthereumRelayer) BurnAsync(ownerPrivateKey, tokenAddr, chain33Receiver, amount string) (string, error) {
+func (ethRelayer *Relayer4Ethereum) BurnAsync(ownerPrivateKey, tokenAddr, chain33Receiver, amount string) (string, error) {
 	bn := big.NewInt(1)
 	bn, _ = bn.SetString(x2ethTypes.TrimZeroAndDot(amount), 10)
-	return ethtxs.BurnAsync(ownerPrivateKey, tokenAddr, chain33Receiver, ethRelayer.x2EthDeployInfo.BridgeBank.Address, bn, ethRelayer.x2EthContracts.BridgeBank, ethRelayer.client)
+	return ethtxs.BurnAsync(ownerPrivateKey, tokenAddr, chain33Receiver, ethRelayer.x2EthDeployInfo.BridgeBank.Address, bn, ethRelayer.x2EthContracts.BridgeBank, ethRelayer.backend)
 }
 
-func (ethRelayer *EthereumRelayer) TransferToken(tokenAddr, fromKey, toAddr, amount string) (string, error) {
+func (ethRelayer *Relayer4Ethereum) TransferToken(tokenAddr, fromKey, toAddr, amount string) (string, error) {
 	bn := big.NewInt(1)
 	bn, _ = bn.SetString(x2ethTypes.TrimZeroAndDot(amount), 10)
-	return ethtxs.TransferToken(tokenAddr, fromKey, toAddr, bn, ethRelayer.client)
+	return ethtxs.TransferToken(tokenAddr, fromKey, toAddr, bn, ethRelayer.backend)
 }
 
-func (ethRelayer *EthereumRelayer) GetDecimals(tokenAddr string) (uint8, error) {
+func (ethRelayer *Relayer4Ethereum) GetDecimals(tokenAddr string) (uint8, error) {
 	opts := &bind.CallOpts{
 		Pending: true,
 		From:    common.HexToAddress(tokenAddr),
 		Context: context.Background(),
 	}
-	bridgeToken, _ := generated.NewBridgeToken(common.HexToAddress(tokenAddr), ethRelayer.client)
+	bridgeToken, _ := generated.NewBridgeToken(common.HexToAddress(tokenAddr), ethRelayer.backend)
 	return bridgeToken.Decimals(opts)
 }
 
-func (ethRelayer *EthereumRelayer) LockEthErc20Asset(ownerPrivateKey, tokenAddr, amount string, chain33Receiver string) (string, error) {
+func (ethRelayer *Relayer4Ethereum) LockEthErc20Asset(ownerPrivateKey, tokenAddr, amount string, chain33Receiver string) (string, error) {
 	bn := big.NewInt(1)
 	bn, _ = bn.SetString(x2ethTypes.TrimZeroAndDot(amount), 10)
-	return ethtxs.LockEthErc20Asset(ownerPrivateKey, tokenAddr, chain33Receiver, bn, ethRelayer.client, ethRelayer.x2EthContracts.BridgeBank, ethRelayer.x2EthDeployInfo.BridgeBank.Address)
+	return ethtxs.LockEthErc20Asset(ownerPrivateKey, tokenAddr, chain33Receiver, bn, ethRelayer.backend, ethRelayer.x2EthContracts.BridgeBank, ethRelayer.x2EthDeployInfo.BridgeBank.Address)
 }
 
-func (ethRelayer *EthereumRelayer) LockEthErc20AssetAsync(ownerPrivateKey, tokenAddr, amount string, chain33Receiver string) (string, error) {
+func (ethRelayer *Relayer4Ethereum) LockEthErc20AssetAsync(ownerPrivateKey, tokenAddr, amount string, chain33Receiver string) (string, error) {
 	bn := big.NewInt(1)
 	bn, _ = bn.SetString(x2ethTypes.TrimZeroAndDot(amount), 10)
-	return ethtxs.LockEthErc20AssetAsync(ownerPrivateKey, tokenAddr, chain33Receiver, bn, ethRelayer.client, ethRelayer.x2EthContracts.BridgeBank)
+	return ethtxs.LockEthErc20AssetAsync(ownerPrivateKey, tokenAddr, chain33Receiver, bn, ethRelayer.backend, ethRelayer.x2EthContracts.BridgeBank)
 }
 
-func (ethRelayer *EthereumRelayer) ShowTxReceipt(hash string) (*types.Receipt, error) {
+func (ethRelayer *Relayer4Ethereum) ShowTxReceipt(hash string) (*types.Receipt, error) {
 	txhash := common.HexToHash(hash)
-	return ethRelayer.client.TransactionReceipt(context.Background(), txhash)
+	client := ethRelayer.backend.(*ethclient.Client)
+	return client.TransactionReceipt(context.Background(), txhash)
 }
 
-func (ethRelayer *EthereumRelayer) proc() {
-	// Start client with infura ropsten provider
-	relayerLog.Info("EthereumRelayer proc", "Started Ethereum websocket with provider:", ethRelayer.provider,
+func (ethRelayer *Relayer4Ethereum) proc() {
+	// Start backend with infura ropsten provider
+	relayerLog.Info("Relayer4Ethereum proc", "Started Ethereum websocket with provider:", ethRelayer.provider,
 		"rpcURL2Chain33:", ethRelayer.rpcURL2Chain33)
 	client, err := ethtxs.SetupWebsocketEthClient(ethRelayer.provider)
 	if err != nil {
 		panic(err)
 	}
-	ethRelayer.client = client
+	ethRelayer.backend = client
 
 	ctx := context.Background()
 	clientChainID, err := client.NetworkID(ctx)
@@ -370,9 +368,7 @@ func (ethRelayer *EthereumRelayer) proc() {
 
 	var timer *time.Ticker
 	continueFailCount := int32(0)
-	for {
-		select {
-		case <-ethRelayer.unlockchan:
+	for range ethRelayer.unlockchan {
 		relayerLog.Info("Received ethRelayer.unlockchan")
 		if nil != ethRelayer.privateKey4Ethereum && nil != ethRelayer.privateKey4Chain33 && nilAddr != ethRelayer.bridgeRegistryAddr {
 			ethRelayer.ethValidator, err = ethtxs.LoadSender(ethRelayer.privateKey4Ethereum)
@@ -390,13 +386,12 @@ func (ethRelayer *EthereumRelayer) proc() {
 			goto latter
 		}
 	}
-	}
 
 latter:
 	for {
 		select {
 		case <-timer.C:
-			ethRelayer.procNewHeight(&continueFailCount, ctx)
+			ethRelayer.procNewHeight(ctx, &continueFailCount)
 		case err := <-ethRelayer.bridgeBankSub.Err():
 			panic("bridgeBankSub" + err.Error())
 		case vLog := <-ethRelayer.bridgeBankLog:
@@ -405,10 +400,10 @@ latter:
 	}
 }
 
-func (ethRelayer *EthereumRelayer) procNewHeight(continueFailCount *int32, ctx context.Context) {
-	head, err := ethRelayer.client.HeaderByNumber(ctx, nil)
+func (ethRelayer *Relayer4Ethereum) procNewHeight(ctx context.Context, continueFailCount *int32) {
+	head, err := ethRelayer.backend.(*ethclient.Client).HeaderByNumber(ctx, nil)
 	if nil != err {
-		*continueFailCount += 1
+		*continueFailCount++
 		if *continueFailCount >= (12 * 5) {
 			panic(err.Error())
 		}
@@ -455,18 +450,18 @@ func (ethRelayer *EthereumRelayer) procNewHeight(continueFailCount *int32, ctx c
 	}
 }
 
-func (ethRelayer *EthereumRelayer) storeBridgeBankLogs(vLog types.Log, setBlockNumber bool) {
+func (ethRelayer *Relayer4Ethereum) storeBridgeBankLogs(vLog types.Log, setBlockNumber bool) {
 	//lock,用于捕捉 (ETH/ERC20----->chain33) 跨链转移
 	//burn,用于捕捉 (chain33 token----->chain33) 实现chain33资产withdraw操作，之后在chain33上实现unlock操作
 	if vLog.Topics[0].Hex() == ethRelayer.bridgeBankEventLockSig {
 		//先进行数据的持久化，等到一定的高度成熟度之后再进行处理
-		relayerLog.Info("EthereumRelayer storeBridgeBankLogs", "^_^ ^_^ Received bridgeBankLog for event", "lock",
+		relayerLog.Info("Relayer4Ethereum storeBridgeBankLogs", "^_^ ^_^ Received bridgeBankLog for event", "lock",
 			"Block number:", vLog.BlockNumber, "tx Index", vLog.TxIndex, "log Index", vLog.Index, "Tx hash:", vLog.TxHash.Hex())
 		if err := ethRelayer.setEthTxEvent(vLog); nil != err {
 			panic(err.Error())
 		}
 	} else if vLog.Topics[0].Hex() == ethRelayer.bridgeBankEventBurnSig {
-		relayerLog.Info("EthereumRelayer storeBridgeBankLogs", "^_^ ^_^ Received bridgeBankLog for event", "burn",
+		relayerLog.Info("Relayer4Ethereum storeBridgeBankLogs", "^_^ ^_^ Received bridgeBankLog for event", "burn",
 			"Block number:", vLog.BlockNumber, "tx Index", vLog.TxIndex, "log Index", vLog.Index, "Tx hash:", vLog.TxHash.Hex())
 		if err := ethRelayer.setEthTxEvent(vLog); nil != err {
 			panic(err.Error())
@@ -479,11 +474,9 @@ func (ethRelayer *EthereumRelayer) storeBridgeBankLogs(vLog types.Log, setBlockN
 			panic(err.Error())
 		}
 	}
-
-	return
 }
 
-func (ethRelayer *EthereumRelayer) procBridgeBankLogs(vLog types.Log) {
+func (ethRelayer *Relayer4Ethereum) procBridgeBankLogs(vLog types.Log) {
 	if ethRelayer.checkTxProcessed(vLog.TxHash.Bytes()) {
 		relayerLog.Info("procBridgeBankLogs", "Tx has been already Processed with hash:", vLog.TxHash.Hex(),
 			"height", vLog.BlockNumber, "index", vLog.Index)
@@ -497,7 +490,7 @@ func (ethRelayer *EthereumRelayer) procBridgeBankLogs(vLog types.Log) {
 	}()
 
 	//检查当前交易是否因为区块回退而导致交易丢失
-	receipt, err := ethRelayer.client.TransactionReceipt(context.Background(), vLog.TxHash)
+	receipt, err := ethRelayer.backend.(*ethclient.Client).TransactionReceipt(context.Background(), vLog.TxHash)
 	if nil != err {
 		relayerLog.Error("procBridgeBankLogs", "Failed to get tx receipt with hash", vLog.TxHash.String())
 		return
@@ -512,38 +505,37 @@ func (ethRelayer *EthereumRelayer) procBridgeBankLogs(vLog types.Log) {
 	//lock,用于捕捉 (ETH/ERC20----->chain33) 跨链转移
 	if vLog.Topics[0].Hex() == ethRelayer.bridgeBankEventLockSig {
 		eventName := events.LogLock.String()
-		relayerLog.Info("EthereumRelayer proc", "Going to process", eventName,
+		relayerLog.Info("Relayer4Ethereum proc", "Going to process", eventName,
 			"Block number:", vLog.BlockNumber, "Tx hash:", vLog.TxHash.Hex())
 		err := ethRelayer.handleLogLockEvent(ethRelayer.clientChainID, ethRelayer.bridgeBankAbi, eventName, vLog)
 		if err != nil {
 			errinfo := fmt.Sprintf("Failed to handleLogLockEvent due to:%s", err.Error())
-			relayerLog.Info("EthereumRelayer procBridgeBankLogs", "errinfo", errinfo)
+			relayerLog.Info("Relayer4Ethereum procBridgeBankLogs", "errinfo", errinfo)
 			panic(errinfo)
 		}
 	} else if vLog.Topics[0].Hex() == ethRelayer.bridgeBankEventBurnSig {
 		//burn,用于捕捉 (chain33 token----->chain33) 实现chain33资产withdraw操作，之后在chain33上实现unlock操作
 		eventName := events.LogChain33TokenBurn.String()
-		relayerLog.Info("EthereumRelayer proc", "Going to process", eventName,
+		relayerLog.Info("Relayer4Ethereum proc", "Going to process", eventName,
 			"Block number:", vLog.BlockNumber, "Tx hash:", vLog.TxHash.Hex())
 		err := ethRelayer.handleLogBurnEvent(ethRelayer.clientChainID, ethRelayer.bridgeBankAbi, eventName, vLog)
 		if err != nil {
 			errinfo := fmt.Sprintf("Failed to handleLogBurnEvent due to:%s", err.Error())
-			relayerLog.Info("EthereumRelayer procBridgeBankLogs", "errinfo", errinfo)
+			relayerLog.Info("Relayer4Ethereum procBridgeBankLogs", "errinfo", errinfo)
 			panic(errinfo)
 		}
 	}
-	return
 }
 
-func (ethRelayer *EthereumRelayer) filterLogEvents() {
-	deployHeight, _ := ethtxs.GetDeployHeight(ethRelayer.client, ethRelayer.x2EthDeployInfo.BridgeRegistry.Address, ethRelayer.x2EthDeployInfo.BridgeRegistry.Address)
+func (ethRelayer *Relayer4Ethereum) filterLogEvents() {
+	deployHeight, _ := ethtxs.GetDeployHeight(ethRelayer.backend.(*ethclient.Client), ethRelayer.x2EthDeployInfo.BridgeRegistry.Address, ethRelayer.x2EthDeployInfo.BridgeRegistry.Address)
 	height4BridgeBankLogAt := int64(ethRelayer.getHeight4BridgeBankLogAt())
 
 	if height4BridgeBankLogAt < deployHeight {
 		height4BridgeBankLogAt = deployHeight
 	}
 
-	header, err := ethRelayer.client.HeaderByNumber(context.Background(), nil)
+	header, err := ethRelayer.backend.(*ethclient.Client).HeaderByNumber(context.Background(), nil)
 	if err != nil {
 		errinfo := fmt.Sprintf("Failed to get HeaderByNumbers due to:%s", err.Error())
 		panic(errinfo)
@@ -572,7 +564,7 @@ func (ethRelayer *EthereumRelayer) filterLogEvents() {
 	}
 }
 
-func (ethRelayer *EthereumRelayer) filterLogEventsProc(logchan chan<- types.Log, done chan<- int, title string, curHeight, heightLogProcAt int64, contractAddr common.Address, eventSig map[string]bool) {
+func (ethRelayer *Relayer4Ethereum) filterLogEventsProc(logchan chan<- types.Log, done chan<- int, title string, curHeight, heightLogProcAt int64, contractAddr common.Address, eventSig map[string]bool) {
 	relayerLog.Info(title, "eventSig", eventSig)
 
 	startHeight := heightLogProcAt
@@ -592,7 +584,7 @@ func (ethRelayer *EthereumRelayer) filterLogEventsProc(logchan chan<- types.Log,
 		}
 
 		// Filter by contract and event, write results to logs
-		logs, err := ethRelayer.client.FilterLogs(context.Background(), query)
+		logs, err := ethRelayer.backend.FilterLogs(context.Background(), query)
 		if err != nil {
 			errinfo := fmt.Sprintf("Failed to filterLogEvents due to:%s", err.Error())
 			panic(errinfo)
@@ -619,7 +611,7 @@ func (ethRelayer *EthereumRelayer) filterLogEventsProc(logchan chan<- types.Log,
 	}
 }
 
-func (ethRelayer *EthereumRelayer) prePareSubscribeEvent() {
+func (ethRelayer *Relayer4Ethereum) prePareSubscribeEvent() {
 	var eventName string
 	//bridgeBank处理
 	contactAbi := ethtxs.LoadABI(ethtxs.BridgeBankABI)
@@ -631,9 +623,8 @@ func (ethRelayer *EthereumRelayer) prePareSubscribeEvent() {
 	ethRelayer.bridgeBankAddr = ethRelayer.x2EthDeployInfo.BridgeBank.Address
 }
 
-func (ethRelayer *EthereumRelayer) subscribeEvent() {
-	var targetAddress common.Address
-	targetAddress = ethRelayer.bridgeBankAddr
+func (ethRelayer *Relayer4Ethereum) subscribeEvent() {
+	targetAddress := ethRelayer.bridgeBankAddr
 
 	// We need the target address in bytes[] for the query
 	query := ethereum.FilterQuery{
@@ -643,7 +634,7 @@ func (ethRelayer *EthereumRelayer) subscribeEvent() {
 	// We will check logs for new events
 	logs := make(chan types.Log, 10)
 	// Filter by contract and event, write results to logs
-	sub, err := ethRelayer.client.SubscribeFilterLogs(context.Background(), query, logs)
+	sub, err := ethRelayer.backend.SubscribeFilterLogs(context.Background(), query, logs)
 	if err != nil {
 		errinfo := fmt.Sprintf("Failed to SubscribeFilterLogs due to:%s", err.Error())
 		panic(errinfo)
@@ -651,33 +642,32 @@ func (ethRelayer *EthereumRelayer) subscribeEvent() {
 	relayerLog.Info("subscribeEvent", "Subscribed to contract at address:", targetAddress.Hex())
 	ethRelayer.bridgeBankLog = logs
 	ethRelayer.bridgeBankSub = sub
-	return
 }
 
-func (ethRelayer *EthereumRelayer) IsValidatorActive(addr string) (bool, error) {
+func (ethRelayer *Relayer4Ethereum) IsValidatorActive(addr string) (bool, error) {
 	return ethtxs.IsActiveValidator(common.HexToAddress(addr), ethRelayer.x2EthContracts.Valset)
 }
 
-func (ethRelayer *EthereumRelayer) ShowOperator() (string, error) {
-	operator, err := ethtxs.GetOperator(ethRelayer.client, ethRelayer.ethValidator, ethRelayer.bridgeBankAddr)
+func (ethRelayer *Relayer4Ethereum) ShowOperator() (string, error) {
+	operator, err := ethtxs.GetOperator(ethRelayer.backend.(*ethclient.Client), ethRelayer.ethValidator, ethRelayer.bridgeBankAddr)
 	if nil != err {
 		return "", err
 	}
 	return operator.String(), nil
 }
 
-func (ethRelayer *EthereumRelayer) QueryTxhashRelay2Eth() ebTypes.Txhashes {
+func (ethRelayer *Relayer4Ethereum) QueryTxhashRelay2Eth() ebTypes.Txhashes {
 	txhashs := ethRelayer.queryTxhashes([]byte(chain33ToEthTxHashPrefix))
 	return ebTypes.Txhashes{Txhash: txhashs}
 }
 
-func (ethRelayer *EthereumRelayer) QueryTxhashRelay2Chain33() *ebTypes.Txhashes {
+func (ethRelayer *Relayer4Ethereum) QueryTxhashRelay2Chain33() *ebTypes.Txhashes {
 	txhashs := ethRelayer.queryTxhashes([]byte(eth2chain33TxHashPrefix))
 	return &ebTypes.Txhashes{Txhash: txhashs}
 }
 
 // handleLogLockEvent : unpacks a LogLock event, converts it to a ProphecyClaim, and relays a tx to chain33
-func (ethRelayer *EthereumRelayer) handleLogLockEvent(clientChainID *big.Int, contractABI abi.ABI, eventName string, log types.Log) error {
+func (ethRelayer *Relayer4Ethereum) handleLogLockEvent(clientChainID *big.Int, contractABI abi.ABI, eventName string, log types.Log) error {
 	rpcURL := ethRelayer.rpcURL2Chain33
 
 	// Unpack the LogLock event using its unique event signature from the contract's ABI
@@ -697,7 +687,7 @@ func (ethRelayer *EthereumRelayer) handleLogLockEvent(clientChainID *big.Int, co
 			From:    common.HexToAddress(event.Token.String()),
 			Context: context.Background(),
 		}
-		bridgeToken, _ := generated.NewBridgeToken(common.HexToAddress(event.Token.String()), ethRelayer.client)
+		bridgeToken, _ := generated.NewBridgeToken(common.HexToAddress(event.Token.String()), ethRelayer.backend)
 
 		decimal, err = bridgeToken.Decimals(opts)
 		if err != nil {
@@ -735,7 +725,7 @@ func (ethRelayer *EthereumRelayer) handleLogLockEvent(clientChainID *big.Int, co
 }
 
 // handleLogBurnEvent : unpacks a burn event, converts it to a ProphecyClaim, and relays a tx to chain33
-func (ethRelayer *EthereumRelayer) handleLogBurnEvent(clientChainID *big.Int, contractABI abi.ABI, eventName string, log types.Log) error {
+func (ethRelayer *Relayer4Ethereum) handleLogBurnEvent(clientChainID *big.Int, contractABI abi.ABI, eventName string, log types.Log) error {
 	rpcURL := ethRelayer.rpcURL2Chain33
 
 	event, err := events.UnpackLogBurn(contractABI, eventName, log.Data)
@@ -752,7 +742,7 @@ func (ethRelayer *EthereumRelayer) handleLogBurnEvent(clientChainID *big.Int, co
 			From:    common.HexToAddress(event.Token.String()),
 			Context: context.Background(),
 		}
-		bridgeToken, _ := generated.NewBridgeToken(common.HexToAddress(event.Token.String()), ethRelayer.client)
+		bridgeToken, _ := generated.NewBridgeToken(common.HexToAddress(event.Token.String()), ethRelayer.backend)
 
 		decimal, err = bridgeToken.Decimals(opts)
 		if err != nil {

plugin/dapp/x2Ethereum/ebrelayer/relayer/ethereum/store.go

@@ -26,8 +26,6 @@ var (
 
 	ethTxEventPrefix               = []byte("ethTxEventPrefix")
 	lastBridgeBankHeightProcPrefix = []byte("lastBridgeBankHeight")
-
-	bridgeBankTxProCnt = []byte("bridgeBankTxProCnt")
 )
 
 func ethTxEventKey4Height(height uint64, index uint32) []byte {
@@ -42,11 +40,11 @@ func calcRelay2EthTxhash(txindex int64) []byte {
 	return []byte(fmt.Sprintf("%s-%012d", chain33ToEthTxHashPrefix, txindex))
 }
 
-func (ethRelayer *EthereumRelayer) setBridgeRegistryAddr(bridgeRegistryAddr string) error {
+func (ethRelayer *Relayer4Ethereum) setBridgeRegistryAddr(bridgeRegistryAddr string) error {
 	return ethRelayer.db.Set(bridgeRegistryAddrPrefix, []byte(bridgeRegistryAddr))
 }
 
-func (ethRelayer *EthereumRelayer) getBridgeRegistryAddr() (string, error) {
+func (ethRelayer *Relayer4Ethereum) getBridgeRegistryAddr() (string, error) {
 	addr, err := ethRelayer.db.Get(bridgeRegistryAddrPrefix)
 	if nil != err {
 		return "", err
@@ -54,7 +52,7 @@ func (ethRelayer *EthereumRelayer) getBridgeRegistryAddr() (string, error) {
 	return string(addr), nil
 }
 
-func (ethRelayer *EthereumRelayer) updateTotalTxAmount2chain33(total int64) error {
+func (ethRelayer *Relayer4Ethereum) updateTotalTxAmount2chain33(total int64) error {
 	totalTx := &chain33Types.Int64{
 		Data: atomic.LoadInt64(&ethRelayer.totalTx4Eth2Chain33),
 	}
@@ -62,12 +60,12 @@ func (ethRelayer *EthereumRelayer) updateTotalTxAmount2chain33(total int64) erro
 	return ethRelayer.db.Set(eth2chain33TxTotalAmount, chain33Types.Encode(totalTx))
 }
 
-func (ethRelayer *EthereumRelayer) setLastestRelay2Chain33Txhash(txhash string, txIndex int64) error {
+func (ethRelayer *Relayer4Ethereum) setLastestRelay2Chain33Txhash(txhash string, txIndex int64) error {
 	key := calcRelay2Chain33Txhash(txIndex)
 	return ethRelayer.db.Set(key, []byte(txhash))
 }
 
-func (ethRelayer *EthereumRelayer) updateTotalTxAmount2Eth(total int64) error {
+func (ethRelayer *Relayer4Ethereum) updateTotalTxAmount2Eth(total int64) error {
 	totalTx := &chain33Types.Int64{
 		Data: atomic.LoadInt64(&ethRelayer.totalTx4Chain33ToEth),
 	}
@@ -75,39 +73,39 @@ func (ethRelayer *EthereumRelayer) updateTotalTxAmount2Eth(total int64) error {
 	return ethRelayer.db.Set(chain33ToEthTxTotalAmount, chain33Types.Encode(totalTx))
 }
 
-func (ethRelayer *EthereumRelayer) setLastestRelay2EthTxhash(txhash string, txIndex int64) error {
+func (ethRelayer *Relayer4Ethereum) setLastestRelay2EthTxhash(txhash string, txIndex int64) error {
 	key := calcRelay2EthTxhash(txIndex)
 	return ethRelayer.db.Set(key, []byte(txhash))
 }
 
-func (ethRelayer *EthereumRelayer) queryTxhashes(prefix []byte) []string {
+func (ethRelayer *Relayer4Ethereum) queryTxhashes(prefix []byte) []string {
 	return utils.QueryTxhashes(prefix, ethRelayer.db)
 }
 
-func (ethRelayer *EthereumRelayer) setHeight4chain33BridgeLogAt(height uint64) error {
+func (ethRelayer *Relayer4Ethereum) setHeight4chain33BridgeLogAt(height uint64) error {
 	return ethRelayer.setLogProcHeight(chain33BridgeLogProcessedAt, height)
 }
 
-func (ethRelayer *EthereumRelayer) getHeight4chain33BridgeLogAt() uint64 {
+func (ethRelayer *Relayer4Ethereum) getHeight4chain33BridgeLogAt() uint64 {
 	return ethRelayer.getLogProcHeight(chain33BridgeLogProcessedAt)
 }
 
-func (ethRelayer *EthereumRelayer) setHeight4BridgeBankLogAt(height uint64) error {
+func (ethRelayer *Relayer4Ethereum) setHeight4BridgeBankLogAt(height uint64) error {
 	return ethRelayer.setLogProcHeight(bridgeBankLogProcessedAt, height)
 }
 
-func (ethRelayer *EthereumRelayer) getHeight4BridgeBankLogAt() uint64 {
+func (ethRelayer *Relayer4Ethereum) getHeight4BridgeBankLogAt() uint64 {
 	return ethRelayer.getLogProcHeight(bridgeBankLogProcessedAt)
 }
 
-func (ethRelayer *EthereumRelayer) setLogProcHeight(key []byte, height uint64) error {
+func (ethRelayer *Relayer4Ethereum) setLogProcHeight(key []byte, height uint64) error {
 	data := &ebTypes.Uint64{
 		Data: height,
 	}
 	return ethRelayer.db.Set(key, chain33Types.Encode(data))
 }
 
-func (ethRelayer *EthereumRelayer) getLogProcHeight(key []byte) uint64 {
+func (ethRelayer *Relayer4Ethereum) getLogProcHeight(key []byte) uint64 {
 	value, err := ethRelayer.db.Get(key)
 	if nil != err {
 		return 0
@@ -121,20 +119,17 @@ func (ethRelayer *EthereumRelayer) getLogProcHeight(key []byte) uint64 {
 }
 
 //保存处理过的交易
-func (ethRelayer *EthereumRelayer) setTxProcessed(txhash []byte) error {
+func (ethRelayer *Relayer4Ethereum) setTxProcessed(txhash []byte) error {
 	return ethRelayer.db.Set(txhash, []byte("1"))
 }
 
 //判断是否已经被处理，如果能够在数据库中找到该笔交易，则认为已经被处理
-func (ethRelayer *EthereumRelayer) checkTxProcessed(txhash []byte) bool {
+func (ethRelayer *Relayer4Ethereum) checkTxProcessed(txhash []byte) bool {
 	_, err := ethRelayer.db.Get(txhash)
-	if nil != err {
-		return false
-	}
-	return true
+	return nil == err
 }
 
-func (ethRelayer *EthereumRelayer) setEthTxEvent(vLog types.Log) error {
+func (ethRelayer *Relayer4Ethereum) setEthTxEvent(vLog types.Log) error {
 	key := ethTxEventKey4Height(vLog.BlockNumber, uint32(vLog.TxIndex))
 	value, err := json.Marshal(vLog)
 	if nil != err {
@@ -143,7 +138,7 @@ func (ethRelayer *EthereumRelayer) setEthTxEvent(vLog types.Log) error {
 	return ethRelayer.db.Set(key, value)
 }
 
-func (ethRelayer *EthereumRelayer) getEthTxEvent(blockNumber uint64, txIndex uint32) (*types.Log, error) {
+func (ethRelayer *Relayer4Ethereum) getEthTxEvent(blockNumber uint64, txIndex uint32) (*types.Log, error) {
 	key := ethTxEventKey4Height(blockNumber, txIndex)
 	data, err := ethRelayer.db.Get(key)
 	if nil != err {
@@ -157,7 +152,7 @@ func (ethRelayer *EthereumRelayer) getEthTxEvent(blockNumber uint64, txIndex uin
 	return &log, nil
 }
 
-func (ethRelayer *EthereumRelayer) getNextValidEthTxEventLogs(height uint64, index uint32, fetchCnt int32) ([]*types.Log, error) {
+func (ethRelayer *Relayer4Ethereum) getNextValidEthTxEventLogs(height uint64, index uint32, fetchCnt int32) ([]*types.Log, error) {
 	key := ethTxEventKey4Height(height, index)
 	helper := dbm.NewListHelper(ethRelayer.db)
 	datas := helper.List(ethTxEventPrefix, key, fetchCnt, dbm.ListASC)
@@ -177,14 +172,14 @@ func (ethRelayer *EthereumRelayer) getNextValidEthTxEventLogs(height uint64, ind
 	return logs, nil
 }
 
-func (ethRelayer *EthereumRelayer) setBridgeBankProcessedHeight(height uint64, index uint32) {
+func (ethRelayer *Relayer4Ethereum) setBridgeBankProcessedHeight(height uint64, index uint32) {
 	bytes := chain33Types.Encode(&ebTypes.EventLogIndex{
 		Height: height,
 		Index:  index})
 	_ = ethRelayer.db.Set(lastBridgeBankHeightProcPrefix, bytes)
 }
 
-func (ethRelayer *EthereumRelayer) getLastBridgeBankProcessedHeight() ebTypes.EventLogIndex {
+func (ethRelayer *Relayer4Ethereum) getLastBridgeBankProcessedHeight() ebTypes.EventLogIndex {
 	data, err := ethRelayer.db.Get(lastBridgeBankHeightProcPrefix)
 	if nil != err {
 		return ebTypes.EventLogIndex{}
@@ -195,7 +190,7 @@ func (ethRelayer *EthereumRelayer) getLastBridgeBankProcessedHeight() ebTypes.Ev
 }
 
 //构建一个引导查询使用的bridgeBankTx
-func (ethRelayer *EthereumRelayer) initBridgeBankTx() {
+func (ethRelayer *Relayer4Ethereum) initBridgeBankTx() {
 	log, _ := ethRelayer.getEthTxEvent(0, 0)
 	if nil != log {
 		return

plugin/dapp/x2Ethereum/ebrelayer/relayer/manager.go

@@ -32,9 +32,9 @@ const (
 	EncryptEnable = int64(1)
 )
 
-type RelayerManager struct {
-	chain33Relayer *chain33.Chain33Relayer
-	ethRelayer     *ethereum.EthereumRelayer
+type Manager struct {
+	chain33Relayer *chain33.Relayer4Chain33
+	ethRelayer     *ethereum.Relayer4Ethereum
 	store          *Store
 	isLocked       int32
 	mtx            sync.Mutex
@@ -47,9 +47,9 @@ type RelayerManager struct {
 //1.验证人的私钥需要通过cli命令行进行导入，且chain33和ethereum两种不同的验证人需要分别导入
 //2.显示或者重新替换原有的私钥首先需要通过passpin进行unlock的操作
 
-func NewRelayerManager(chain33Relayer *chain33.Chain33Relayer, ethRelayer *ethereum.EthereumRelayer, db dbm.DB) *RelayerManager {
+func NewRelayerManager(chain33Relayer *chain33.Relayer4Chain33, ethRelayer *ethereum.Relayer4Ethereum, db dbm.DB) *Manager {
 	l, _ := lru.New(4096)
-	manager := &RelayerManager{
+	manager := &Manager{
 		chain33Relayer: chain33Relayer,
 		ethRelayer:     ethRelayer,
 		store:          NewStore(db),
@@ -63,7 +63,7 @@ func NewRelayerManager(chain33Relayer *chain33.Chain33Relayer, ethRelayer *ether
 	return manager
 }
 
-func (manager *RelayerManager) SetPassphase(setPasswdReq relayerTypes.ReqSetPasswd, result *interface{}) error {
+func (manager *Manager) SetPassphase(setPasswdReq relayerTypes.ReqSetPasswd, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	// 新密码合法性校验
@@ -135,7 +135,7 @@ func (manager *RelayerManager) SetPassphase(setPasswdReq relayerTypes.ReqSetPass
 }
 
 //进行unlok操作
-func (manager *RelayerManager) Unlock(passphase string, result *interface{}) error {
+func (manager *Manager) Unlock(passphase string, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if EncryptEnable != manager.encryptFlag {
@@ -170,7 +170,7 @@ func (manager *RelayerManager) Unlock(passphase string, result *interface{}) err
 }
 
 //锁定操作，该操作一旦执行，就不能替换验证人的私钥，需要重新unlock之后才能修改
-func (manager *RelayerManager) Lock(param interface{}, result *interface{}) error {
+func (manager *Manager) Lock(param interface{}, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -185,7 +185,7 @@ func (manager *RelayerManager) Lock(param interface{}, result *interface{}) erro
 }
 
 //导入chain33relayer验证人的私钥,该私钥实际用于向ethereum提交验证交易时签名使用
-func (manager *RelayerManager) ImportChain33RelayerPrivateKey(importKeyReq relayerTypes.ImportKeyReq, result *interface{}) error {
+func (manager *Manager) ImportChain33RelayerPrivateKey(importKeyReq relayerTypes.ImportKeyReq, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	privateKey := importKeyReq.PrivateKey
@@ -194,7 +194,7 @@ func (manager *RelayerManager) ImportChain33RelayerPrivateKey(importKeyReq relay
 	}
 	_, err := manager.chain33Relayer.ImportPrivateKey(manager.passphase, privateKey)
 	if err != nil {
-		mlog.Error("ImportChain33ValidatorPrivateKey", "Failed due to casue:", err.Error())
+		mlog.Error("ImportChain33ValidatorPrivateKey", "Failed due to cause:", err.Error())
 		return err
 	}
 
@@ -206,7 +206,7 @@ func (manager *RelayerManager) ImportChain33RelayerPrivateKey(importKeyReq relay
 }
 
 //生成以太坊私钥
-func (manager *RelayerManager) GenerateEthereumPrivateKey(param interface{}, result *interface{}) error {
+func (manager *Manager) GenerateEthereumPrivateKey(param interface{}, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -223,7 +223,7 @@ func (manager *RelayerManager) GenerateEthereumPrivateKey(param interface{}, res
 }
 
 //为ethrelayer导入chain33私钥，为向chain33发送交易时进行签名使用
-func (manager *RelayerManager) ImportChain33PrivateKey4EthRelayer(privateKey string, result *interface{}) error {
+func (manager *Manager) ImportChain33PrivateKey4EthRelayer(privateKey string, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -240,7 +240,7 @@ func (manager *RelayerManager) ImportChain33PrivateKey4EthRelayer(privateKey str
 }
 
 //为ethrelayer导入chain33私钥，为向chain33发送交易时进行签名使用
-func (manager *RelayerManager) ImportEthValidatorPrivateKey(privateKey string, result *interface{}) error {
+func (manager *Manager) ImportEthValidatorPrivateKey(privateKey string, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -257,7 +257,7 @@ func (manager *RelayerManager) ImportEthValidatorPrivateKey(privateKey string, r
 }
 
 //显示在chain33中以验证人validator身份进行登录的地址
-func (manager *RelayerManager) ShowChain33RelayerValidator(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowChain33RelayerValidator(param interface{}, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	var err error
@@ -270,7 +270,7 @@ func (manager *RelayerManager) ShowChain33RelayerValidator(param interface{}, re
 }
 
 //显示在Ethereum中以验证人validator身份进行登录的地址
-func (manager *RelayerManager) ShowEthRelayerValidator(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowEthRelayerValidator(param interface{}, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	var err error
@@ -281,7 +281,7 @@ func (manager *RelayerManager) ShowEthRelayerValidator(param interface{}, result
 	return nil
 }
 
-func (manager *RelayerManager) IsValidatorActive(vallidatorAddr string, result *interface{}) error {
+func (manager *Manager) IsValidatorActive(vallidatorAddr string, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	active, err := manager.ethRelayer.IsValidatorActive(vallidatorAddr)
@@ -295,7 +295,7 @@ func (manager *RelayerManager) IsValidatorActive(vallidatorAddr string, result *
 	return nil
 }
 
-func (manager *RelayerManager) ShowOperator(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowOperator(param interface{}, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	operator, err := manager.ethRelayer.ShowOperator()
@@ -306,7 +306,7 @@ func (manager *RelayerManager) ShowOperator(param interface{}, result *interface
 	return nil
 }
 
-func (manager *RelayerManager) DeployContrcts(param interface{}, result *interface{}) error {
+func (manager *Manager) DeployContrcts(param interface{}, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -323,7 +323,7 @@ func (manager *RelayerManager) DeployContrcts(param interface{}, result *interfa
 	return nil
 }
 
-func (manager *RelayerManager) CreateBridgeToken(symbol string, result *interface{}) error {
+func (manager *Manager) CreateBridgeToken(symbol string, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -335,12 +335,12 @@ func (manager *RelayerManager) CreateBridgeToken(symbol string, result *interfac
 	}
 	*result = relayerTypes.ReplyAddr{
 		IsOK: true,
-		Addr: fmt.Sprintf("%s", tokenAddr),
+		Addr: tokenAddr,
 	}
 	return nil
 }
 
-func (manager *RelayerManager) CreateERC20Token(symbol string, result *interface{}) error {
+func (manager *Manager) CreateERC20Token(symbol string, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -352,12 +352,12 @@ func (manager *RelayerManager) CreateERC20Token(symbol string, result *interface
 	}
 	*result = relayerTypes.ReplyAddr{
 		IsOK: true,
-		Addr: fmt.Sprintf("%s", tokenAddr),
+		Addr: tokenAddr,
 	}
 	return nil
 }
 
-func (manager *RelayerManager) MintErc20(mintToken relayerTypes.MintToken, result *interface{}) error {
+func (manager *Manager) MintErc20(mintToken relayerTypes.MintToken, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -374,7 +374,7 @@ func (manager *RelayerManager) MintErc20(mintToken relayerTypes.MintToken, resul
 	return nil
 }
 
-func (manager *RelayerManager) ApproveAllowance(approveAllowance relayerTypes.ApproveAllowance, result *interface{}) error {
+func (manager *Manager) ApproveAllowance(approveAllowance relayerTypes.ApproveAllowance, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -391,7 +391,7 @@ func (manager *RelayerManager) ApproveAllowance(approveAllowance relayerTypes.Ap
 	return nil
 }
 
-func (manager *RelayerManager) Burn(burn relayerTypes.Burn, result *interface{}) error {
+func (manager *Manager) Burn(burn relayerTypes.Burn, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -408,7 +408,7 @@ func (manager *RelayerManager) Burn(burn relayerTypes.Burn, result *interface{})
 	return nil
 }
 
-func (manager *RelayerManager) BurnAsync(burn relayerTypes.Burn, result *interface{}) error {
+func (manager *Manager) BurnAsync(burn relayerTypes.Burn, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -425,7 +425,7 @@ func (manager *RelayerManager) BurnAsync(burn relayerTypes.Burn, result *interfa
 	return nil
 }
 
-func (manager *RelayerManager) LockEthErc20AssetAsync(lockEthErc20Asset relayerTypes.LockEthErc20, result *interface{}) error {
+func (manager *Manager) LockEthErc20AssetAsync(lockEthErc20Asset relayerTypes.LockEthErc20, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -442,7 +442,7 @@ func (manager *RelayerManager) LockEthErc20AssetAsync(lockEthErc20Asset relayerT
 	return nil
 }
 
-func (manager *RelayerManager) LockEthErc20Asset(lockEthErc20Asset relayerTypes.LockEthErc20, result *interface{}) error {
+func (manager *Manager) LockEthErc20Asset(lockEthErc20Asset relayerTypes.LockEthErc20, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -459,7 +459,7 @@ func (manager *RelayerManager) LockEthErc20Asset(lockEthErc20Asset relayerTypes.
 	return nil
 }
 
-func (manager *RelayerManager) MakeNewProphecyClaim(newProphecyClaim relayerTypes.NewProphecyClaim, result *interface{}) error {
+func (manager *Manager) MakeNewProphecyClaim(newProphecyClaim relayerTypes.NewProphecyClaim, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	if err := manager.checkPermission(); nil != err {
@@ -491,7 +491,7 @@ func (manager *RelayerManager) MakeNewProphecyClaim(newProphecyClaim relayerType
 	return nil
 }
 
-func (manager *RelayerManager) IsProphecyPending(claimID [32]byte, result *interface{}) error {
+func (manager *Manager) IsProphecyPending(claimID [32]byte, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	active, err := manager.ethRelayer.IsProphecyPending(claimID)
@@ -504,7 +504,7 @@ func (manager *RelayerManager) IsProphecyPending(claimID [32]byte, result *inter
 	return nil
 }
 
-func (manager *RelayerManager) GetBalance(balanceAddr relayerTypes.BalanceAddr, result *interface{}) error {
+func (manager *Manager) GetBalance(balanceAddr relayerTypes.BalanceAddr, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	balance, err := manager.ethRelayer.GetBalance(balanceAddr.TokenAddr, balanceAddr.Owner)
@@ -529,7 +529,7 @@ func (manager *RelayerManager) GetBalance(balanceAddr relayerTypes.BalanceAddr,
 	return nil
 }
 
-func (manager *RelayerManager) ShowBridgeBankAddr(para interface{}, result *interface{}) error {
+func (manager *Manager) ShowBridgeBankAddr(para interface{}, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	addr, err := manager.ethRelayer.ShowBridgeBankAddr()
@@ -543,7 +543,7 @@ func (manager *RelayerManager) ShowBridgeBankAddr(para interface{}, result *inte
 	return nil
 }
 
-func (manager *RelayerManager) ShowBridgeRegistryAddr(para interface{}, result *interface{}) error {
+func (manager *Manager) ShowBridgeRegistryAddr(para interface{}, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	addr, err := manager.ethRelayer.ShowBridgeRegistryAddr()
@@ -557,7 +557,7 @@ func (manager *RelayerManager) ShowBridgeRegistryAddr(para interface{}, result *
 	return nil
 }
 
-func (manager *RelayerManager) ShowLockStatics(token relayerTypes.TokenStatics, result *interface{}) error {
+func (manager *Manager) ShowLockStatics(token relayerTypes.TokenStatics, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	balance, err := manager.ethRelayer.ShowLockStatics(token.TokenAddr)
@@ -579,7 +579,7 @@ func (manager *RelayerManager) ShowLockStatics(token relayerTypes.TokenStatics,
 	return nil
 }
 
-func (manager *RelayerManager) ShowDepositStatics(token relayerTypes.TokenStatics, result *interface{}) error {
+func (manager *Manager) ShowDepositStatics(token relayerTypes.TokenStatics, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	supply, err := manager.ethRelayer.ShowDepositStatics(token.TokenAddr)
@@ -601,7 +601,7 @@ func (manager *RelayerManager) ShowDepositStatics(token relayerTypes.TokenStatic
 	return nil
 }
 
-func (manager *RelayerManager) ShowTokenAddrBySymbol(token relayerTypes.TokenStatics, result *interface{}) error {
+func (manager *Manager) ShowTokenAddrBySymbol(token relayerTypes.TokenStatics, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	addr, err := manager.ethRelayer.ShowTokenAddrBySymbol(token.TokenAddr)
@@ -616,7 +616,7 @@ func (manager *RelayerManager) ShowTokenAddrBySymbol(token relayerTypes.TokenSta
 	return nil
 }
 
-func (manager *RelayerManager) ShowTxReceipt(txhash string, result *interface{}) error {
+func (manager *Manager) ShowTxReceipt(txhash string, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	receipt, err := manager.ethRelayer.ShowTxReceipt(txhash)
@@ -627,7 +627,7 @@ func (manager *RelayerManager) ShowTxReceipt(txhash string, result *interface{})
 	return nil
 }
 
-func (manager *RelayerManager) checkPermission() error {
+func (manager *Manager) checkPermission() error {
 	if EncryptEnable != manager.encryptFlag {
 		return errors.New("pls set passphase first")
 	}
@@ -637,54 +637,54 @@ func (manager *RelayerManager) checkPermission() error {
 	return nil
 }
 
-func (manager *RelayerManager) ShowEthRelayerStatus(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowEthRelayerStatus(param interface{}, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	*result = manager.ethRelayer.GetRunningStatus()
 	return nil
 }
 
-func (manager *RelayerManager) ShowChain33RelayerStatus(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowChain33RelayerStatus(param interface{}, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	*result = manager.chain33Relayer.GetRunningStatus()
 	return nil
 }
 
-func (manager *RelayerManager) ShowEthRelayer2EthTxs(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowEthRelayer2EthTxs(param interface{}, result *interface{}) error {
 	*result = manager.ethRelayer.QueryTxhashRelay2Eth()
 	return nil
 }
 
-func (manager *RelayerManager) ShowEthRelayer2Chain33Txs(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowEthRelayer2Chain33Txs(param interface{}, result *interface{}) error {
 	*result = manager.ethRelayer.QueryTxhashRelay2Chain33()
 	return nil
 }
 
-func (manager *RelayerManager) ShowChain33Relayer2EthTxs(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowChain33Relayer2EthTxs(param interface{}, result *interface{}) error {
 	*result = manager.chain33Relayer.QueryTxhashRelay2Eth()
 	return nil
 }
 
-func (manager *RelayerManager) ShowTxsEth2chain33TxLock(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowTxsEth2chain33TxLock(param interface{}, result *interface{}) error {
 	return nil
 }
 
-func (manager *RelayerManager) ShowTxsEth2chain33TxBurn(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowTxsEth2chain33TxBurn(param interface{}, result *interface{}) error {
 	return nil
 }
 
-func (manager *RelayerManager) ShowTxsChain33ToEthTxLock(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowTxsChain33ToEthTxLock(param interface{}, result *interface{}) error {
 
 	return nil
 }
 
-func (manager *RelayerManager) ShowTxsChain33ToEthTxBurn(param interface{}, result *interface{}) error {
+func (manager *Manager) ShowTxsChain33ToEthTxBurn(param interface{}, result *interface{}) error {
 
 	return nil
 }
 
-func (manager *RelayerManager) TransferToken(transfer relayerTypes.TransferToken, result *interface{}) error {
+func (manager *Manager) TransferToken(transfer relayerTypes.TransferToken, result *interface{}) error {
 	manager.mtx.Lock()
 	defer manager.mtx.Unlock()
 	txhash, err := manager.ethRelayer.TransferToken(transfer.TokenAddr, transfer.FromKey, transfer.ToAddr, transfer.Amount)
@@ -698,36 +698,31 @@ func (manager *RelayerManager) TransferToken(transfer relayerTypes.TransferToken
 	return nil
 }
 
-func (manager *RelayerManager) GetDecimals(tokenAddr string) (int64, error) {
+func (manager *Manager) GetDecimals(tokenAddr string) (int64, error) {
 	if d, ok := manager.decimalLru.Get(tokenAddr); ok {
 		mlog.Info("GetDecimals", "from cache", d)
 		return d.(int64), nil
-	} else {
+	}
+
 	if d, err := manager.store.Get(utils.CalAddr2DecimalsPrefix(tokenAddr)); err == nil {
 		decimal, err := strconv.ParseInt(string(d), 10, 64)
 		if err != nil {
 			return 0, err
 		}
-
 		manager.decimalLru.Add(tokenAddr, decimal)
-
 		mlog.Info("GetDecimals", "from DB", d)
 
 		return decimal, nil
+	}
 
-		} else {
 	d, err := manager.ethRelayer.GetDecimals(tokenAddr)
 	if err != nil {
 		return 0, err
 	}
-
 	_ = manager.store.Set(utils.CalAddr2DecimalsPrefix(tokenAddr), []byte(strconv.FormatInt(int64(d), 10)))
-
 	manager.decimalLru.Add(tokenAddr, int64(d))
 
 	mlog.Info("GetDecimals", "from Node", d)
 
 	return int64(d), nil
-		}
-	}
 }

plugin/dapp/x2Ethereum/ebrelayer/relayer/store.go

@@ -17,15 +17,9 @@ var (
 )
 
 const (
-	keyAccount            = "Account"
-	keyAddr               = "Addr"
-	keyLabel              = "Label"
-	keyTx                 = "Tx"
 	keyEncryptionFlag     = "Encryption"
 	keyEncryptionCompFlag = "EncryptionFlag" // 中间有一段时间运行了一个错误的密码版本，导致有部分用户信息发生错误，需要兼容下
 	keyPasswordHash       = "PasswordHash"
-	keyWalletSeed         = "walletseed"
-	keyAirDropIndex       = "AirDropIndex" //存储通过seed生成的空投地址信息
 )
 
 // CalcEncryptionFlag 加密标志Key

plugin/dapp/x2Ethereum/ebrelayer/utils/utils.go

@@ -84,7 +84,7 @@ func LoadInt64FromDB(key []byte, db dbm.DB) (int64, error) {
 
 func QueryTxhashes(prefix []byte, db dbm.DB) []string {
 	kvdb := dbm.NewKVDB(db)
-	hashes, err := kvdb.List([]byte(prefix), nil, 10, 1)
+	hashes, err := kvdb.List(prefix, nil, 10, 1)
 	if nil != err {
 		return nil
 	}

plugin/dapp/x2Ethereum/test.sh

-#!/usr/bin/env bash
-set -x
-CLI="/opt/src/github.com/33cn/plugin/build/chain33-cli"
-EBCLI="/opt/src/github.com/33cn/plugin/plugin/dapp/x2Ethereum/build/ebcli_A"
-
-ETHContractAddr="0x0000000000000000000000000000000000000000"
-BTYContractAddr="0x40BFE5eD039A9a2Eb42ece2E2CA431bFa7Cf4c42"
-Ethsender="0xcbfddc6ae318970ba3feeb0541624f95822e413a"
-BtyReceiever="1BqP2vHkYNjSgdnTqm7pGbnphLhtEhuJFi"
-BtyTokenContractAddr="0xbAf2646b8DaD8776fc74Bf4C8d59E6fB3720eddf"
-
-Validator1="14KEKbYtKKQm4wMthSK9J4La4nAiidGozt"
-Validator2="12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv"
-Validator3="1BqP2vHkYNjSgdnTqm7pGbnphLhtEhuJFi"
-
-# 测试流程
-#
-# bankAddr = 1BqP2vHkYNjSgdnTqm7pGbnphLhtEhuJFi
-#
-#
-# 1.Exec_EthBridgeClaim, 测试chain33这端
-#
-#
-#
-
-block_wait() {
-    if [[ $# -lt 1 ]]; then
-        echo "wrong #block_wait parameter"
-        exit 1
-    fi
-    cur_height=$(${CLI} block last_header | jq ".height")
-    expect=$((cur_height + ${1}))
-    local count=0
-    while true; do
-        new_height=$(${CLI} block last_header | jq ".height")
-        if [[ ${new_height} -ge ${expect} ]]; then
-            break
-        fi
-        count=$((count + 1))
-        sleep 1
-    done
-    sleep 1
-    count=$((count + 1))
-    echo "wait new block $count s, cur height=$expect,old=$cur_height"
-}
-
-# check_tx(ty, hash)
-# ty：交易执行结果
-#   1：交易打包
-#   2：交易执行成功
-# hash：交易hash
-check_tx() {
-    if [[ $# -lt 2 ]]; then
-        echo "wrong check_tx parameters"
-        exit 1
-    fi
-    ty=$(${CLI} tx query -s ${2} | jq .receipt.ty)
-    if [[ ${ty} != ${1} ]]; then
-        echo "check tx error, hash is ${2}"
-        exit 1
-    fi
-}
-
-check_Number() {
-    if [[ $# -lt 2 ]]; then
-        echo "wrong check_Number parameters"
-        exit 1
-    fi
-    if [[ ${1} != ${2} ]]; then
-        echo "error Number, expect ${1}, get ${2}"
-        exit 1
-    fi
-}
-
-# SetConsensusThreshold
-hash=$(${CLI} send x2ethereum setconsensus -p 80 -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
-#block_wait 2
-check_tx 2 ${hash}
-
-# query ConsensusThreshold
-nowConsensus=$(${CLI} send x2ethereum query consensus -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .nowConsensusThreshold | sed 's/\"//g')
-check_Number 80 ${nowConsensus}
-
-# add a validator
-hash=$(${CLI} send x2ethereum add -a ${Validator3} -p 7 -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
-#block_wait 2
-check_tx 2 ${hash}
-
-# query Validators
-validators=$(${CLI} send x2ethereum query validators -v ${Validator3} -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .validators | sed 's/\"//g')
-totalPower=$(${CLI} send x2ethereum query validators -v ${Validator3} -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .totalPower | sed 's/\"//g')
-check_Number 7 ${totalPower}
-
-# add a validator again
-hash=$(${CLI} send x2ethereum add -a ${Validator2} -p 6 -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
-#block_wait 2
-check_tx 2 ${hash}
-
-# query Validators
-validators=$(${CLI} send x2ethereum query validators -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .validators | sed 's/\"//g')
-totalPower=$(${CLI} send x2ethereum query validators -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .totalPower | sed 's/\"//g')
-check_Number 13 ${totalPower}
-
-# remove a validator
-hash=$(${CLI} send x2ethereum remove -a ${Validator2} -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
-#block_wait 2
-check_tx 2 ${hash}
-
-# query Validators
-validators=$(${CLI} send x2ethereum query validators -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .validators | sed 's/\"//g')
-totalPower=$(${CLI} send x2ethereum query validators -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .totalPower | sed 's/\"//g')
-check_Number 7 ${totalPower}
-
-# add a validator again
-hash=$(${CLI} send x2ethereum add -a ${Validator2} -p 6 -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
-#block_wait 2
-check_tx 2 ${hash}
-
-# query Validators
-validators=$(${CLI} send x2ethereum query validators -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .validators | sed 's/\"//g')
-totalPower=$(${CLI} send x2ethereum query validators -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .totalPower | sed 's/\"//g')
-check_Number 13 ${totalPower}
-
-# add a validator
-hash=$(${CLI} send x2ethereum add -a ${Validator1} -p 87 -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
-#block_wait 2
-check_tx 2 ${hash}
-
-# query Validators
-validators=$(${CLI} send x2ethereum query validators -v 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .validators | sed 's/\"//g')
-totalPower=$(${CLI} send x2ethereum query validators -v 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .totalPower | sed 's/\"//g')
-check_Number 6 ${totalPower}
-
-totalPower=$(${CLI} send x2ethereum query totalpower -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv | jq .totalPower | sed 's/\"//g')
-check_Number 100 ${totalPower}
-
-##############################################################
-######################## 测试交易 #############################
-##############################################################
-
-# chain33 -> ethereum
-
-# send bty to mavl-x2ethereum-bty-12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv
-${CLI} send coins send_exec -e x2ethereum -a 200 -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv
-
-# send a chain33eth tx，在chain33侧lock 5个bty
-hash=$(${CLI} send x2ethereum lock --amount 5 -e x2ethereum -t bty -r ${Ethsender} -s 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv -q ${BtyTokenContractAddr} -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
-#block_wait 4
-check_tx 2 ${hash}
-
-#在以太坊侧burn掉1个bty
-hash=$(${EBCLI} relayer ethereum burn -m 1 -t ${BtyTokenContractAddr} -r ${BtyReceiever} -k 772db14fc5ae829b155e1eda09431a0b566833f2de3b50b2d35625542b3ae52f | jq .msg | sed 's/\"//g')
-
-# ethereum -> chain33，在以太坊侧lock 0.1 eth
-hash=$(${EBCLI} relayer ethereum lock -m 0.1 -r ${BtyReceiever} -k 772db14fc5ae829b155e1eda09431a0b566833f2de3b50b2d35625542b3ae52f)
-
-#在chain33 burn 0.1eth
-hash=$(${CLI} send x2ethereum burn --amount 0.1 -e x2ethereum -t eth -r ${Ethsender} -s ${BtyReceiever} -q ${ETHContractAddr} -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
-#block_wait 4
-check_tx 2 ${hash}
-
-# ethereum -> chain33
-hash=$(${EBCLI} relayer ethereum lock -m 0.1 -t ${BtyTokenContractAddr} -r ${BtyReceiever} -k 772db14fc5ae829b155e1eda09431a0b566833f2de3b50b2d35625542b3ae52f)
-
-hash=$(${CLI} send x2ethereum burn --amount 0.1 -t ${BtyTokenContractAddr} -e x2ethereum -t eth -r ${Ethsender} -s ${BtyReceiever} -q ${ETHContractAddr} -k 12qyocayNF7Lv6C9qW4avxs2E7U41fKSfv)
-#block_wait 4
-check_tx 2 ${hash}