add WithdrawFromChain33Cmd

plugin/dapp/cross2eth/ebcli/chain33RelayerCmd.go

@@ -31,6 +31,7 @@ func Chain33RelayerCmd() *cobra.Command {
 		TokenAddressCmd(),
 		MultiSignCmd(),
 		ResendChain33EventCmd(),
+		WithdrawFromChain33Cmd(),
 	)
 
 	return cmd
@@ -415,3 +416,48 @@ func resendChain33Event(cmd *cobra.Command, args []string) {
 	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.ResendChain33Event", resendChain33EventReq, &res)
 	ctx.Run()
 }
+
+func WithdrawFromChain33Cmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "withdraw",
+		Short: "async withdraw the asset from chain33 to make it unlocked on ethereum",
+		Run:   WithdrawFromChain33,
+	}
+	addWithdrawFromChain33Flags(cmd)
+	return cmd
+}
+
+//addWithdrawFromChain33CmdFlags ...
+func addWithdrawFromChain33Flags(cmd *cobra.Command) {
+	cmd.Flags().StringP("key", "k", "", "owner private key for chain33")
+	_ = cmd.MarkFlagRequired("key")
+	cmd.Flags().StringP("token", "t", "", "token address")
+	_ = cmd.MarkFlagRequired("token")
+	cmd.Flags().StringP("receiver", "r", "", "receiver address on Ethereum")
+	_ = cmd.MarkFlagRequired("receiver")
+	cmd.Flags().Float64P("amount", "m", float64(0), "amount")
+	_ = cmd.MarkFlagRequired("amount")
+}
+
+func WithdrawFromChain33(cmd *cobra.Command, args []string) {
+	rpcLaddr, _ := cmd.Flags().GetString("rpc_laddr")
+	key, _ := cmd.Flags().GetString("key")
+	tokenAddr, _ := cmd.Flags().GetString("token")
+	amount, _ := cmd.Flags().GetFloat64("amount")
+	receiver, _ := cmd.Flags().GetString("receiver")
+
+	d, err := utils.SimpleGetDecimals(tokenAddr)
+	if err != nil {
+		fmt.Println("get decimals err")
+		return
+	}
+	para := ebTypes.WithdrawFromChain33{
+		OwnerKey:         key,
+		TokenAddr:        tokenAddr,
+		Amount:           utils.ToWei(amount, d).String(),
+		EthereumReceiver: receiver,
+	}
+	var res rpctypes.Reply
+	ctx := jsonclient.NewRPCCtx(rpcLaddr, "Manager.WithdrawFromChain33", para, &res)
+	ctx.Run()
+}

plugin/dapp/cross2eth/ebrelayer/proto/relayer.proto

@@ -255,5 +255,11 @@ message WithdrawSymbol2Fee  {
     map<string, int64> symbol2Fee = 1;
 }
 
+message WithdrawFromChain33 {
+    string ownerKey   = 1;
+    string tokenAddr  = 2;
+    string amount      = 3;
+    string ethereumReceiver = 4;
+}
 
 

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

@@ -639,3 +639,9 @@ func (chain33Relayer *Relayer4Chain33) SetMultiSignAddr(address string) {
 
 	chain33Relayer.setMultiSignAddress(address)
 }
+
+func (chain33Relayer *Relayer4Chain33) WithdrawFromChain33(ownerPrivateKey, tokenAddr, ethereumReceiver, amount string) (string, error) {
+	bn := big.NewInt(1)
+	bn, _ = bn.SetString(utils.TrimZeroAndDot(amount), 10)
+	return withdrawAsync(ownerPrivateKey, tokenAddr, ethereumReceiver, bn.Int64(), chain33Relayer.bridgeBankAddr, chain33Relayer.chainName, chain33Relayer.rpcLaddr)
+}

plugin/dapp/cross2eth/ebrelayer/relayer/chain33/tx.go

@@ -646,3 +646,48 @@ func sendQuery(rpcAddr, funcName string, request types.Message, result proto.Mes
 	}
 	return true
 }
+
+func withdrawAsync(ownerPrivateKeyStr, tokenAddrstr, ethereumReceiver string, amount int64, bridgeBankAddr string, chainName, rpcURL string) (string, error) {
+	var driver secp256k1.Driver
+	privateKeySli, err := chain33Common.FromHex(ownerPrivateKeyStr)
+	if nil != err {
+		return "", err
+	}
+	ownerPrivateKey, err := driver.PrivKeyFromBytes(privateKeySli)
+	if nil != err {
+		return "", err
+	}
+
+	approveTxHash, err := approve(ownerPrivateKey, tokenAddrstr, bridgeBankAddr, chainName, rpcURL, amount)
+	if err != nil {
+		chain33txLog.Error("withdrawAsync", "failed to send approve tx due to:", err.Error())
+		return "", err
+	}
+	chain33txLog.Debug("withdrawAsync", "approve with tx hash", approveTxHash)
+
+	withdrawTxHash, err := withdrawViaProxy(ownerPrivateKey, bridgeBankAddr, ethereumReceiver, tokenAddrstr, chainName, rpcURL, amount)
+	if err != nil {
+		chain33txLog.Error("withdrawAsync", "failed to send withdraw tx due to:", err.Error())
+		return "", err
+	}
+	chain33txLog.Debug("withdrawAsync", "withdraw with tx hash", withdrawTxHash)
+
+	return withdrawTxHash, err
+}
+
+func withdrawViaProxy(privateKey chain33Crypto.PrivKey, contractAddr, ethereumReceiver, ethereumTokenAddress, chainName, rpcURL string, amount int64) (string, error) {
+	//function withdrawViaProxy(
+	//	bytes memory _ethereumReceiver,
+	//	address _bridgeTokenAddress,
+	//	uint256 _amount
+	//)
+	parameter := fmt.Sprintf("withdrawViaProxy(%s, %s, %d)", ethereumReceiver, ethereumTokenAddress, amount)
+	note := parameter
+	_, packData, err := evmAbi.Pack(parameter, generated.BridgeBankABI, false)
+	if nil != err {
+		chain33txLog.Info("withdraw", "Failed to do abi.Pack due to:", err.Error())
+		return "", err
+	}
+
+	return sendEvmTx(privateKey, contractAddr, chainName, rpcURL, note, packData, 0)
+}

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

@@ -1092,3 +1092,20 @@ func (manager *Manager) CfgWithdraw(cfgWithdrawReq *relayerTypes.CfgWithdrawReq,
 	}
 	return nil
 }
+
+func (manager *Manager) WithdrawFromChain33(burn relayerTypes.BurnFromChain33, result *interface{}) error {
+	manager.mtx.Lock()
+	defer manager.mtx.Unlock()
+	if err := manager.checkPermission(); nil != err {
+		return err
+	}
+	txhash, err := manager.chain33Relayer.WithdrawFromChain33(burn.OwnerKey, burn.TokenAddr, burn.EthereumReceiver, burn.Amount)
+	if nil != err {
+		return err
+	}
+	*result = rpctypes.Reply{
+		IsOk: true,
+		Msg:  txhash,
+	}
+	return nil
+}