release v1.1.1

bridge/setu/listener/tron.go

@@ -221,6 +221,18 @@ func (tl *TronListener) queryAndBroadcastEvents(chainManagerParams *chainmanager
 			logBytes, _ := json.Marshal(vLog)
 			if selectedEvent != nil {
 				tl.Logger.Debug("ReceivedTronEvent", "eventname", selectedEvent.Name)
+
+				receipt, err := tl.contractConnector.GetTronTransactionReceipt(vLog.TxHash.Hex())
+				if receipt != nil && !helper.IsTronTransactionReceiptSuccessful(receipt) {
+					tl.Logger.Error(
+						"Skip failed tron transaction event",
+						"eventname", selectedEvent.Name,
+						"txHash", vLog.TxHash.Hex(),
+						"error", err,
+					)
+					continue
+				}
+
 				switch selectedEvent.Name {
 				case "NewHeaderBlock":
 					if isCurrentValidator, delay := util.CalculateTaskDelay(tl.cliCtx); isCurrentValidator {

bridge/setu/processor/clerk.go

@@ -84,7 +84,27 @@ func (cp *ClerkProcessor) sendStateSyncedToHeimdall(eventName string, logBytes s
 			return nil
 		}
 
-		cp.Logger.Debug(
+		if helper.GetConfig().CloseOriginTokenDeposit {
+			shouldBroadcast, err := cp.shouldBroadcastStateSyncedEvent(event.Data, rootChainType)
+			if err != nil {
+				cp.Logger.Error("Error while checking state sync token type", "error", err)
+				return err
+			}
+			if !shouldBroadcast {
+				cp.Logger.Info("Ignoring deposit event for non-mintable ERC20 token",
+					"event", eventName,
+					"id", event.Id,
+					"contract", event.ContractAddress,
+					"data", hex.EncodeToString(event.Data),
+					"txHash", hmTypes.BytesToHeimdallHash(vLog.TxHash.Bytes()),
+					"logIndex", uint64(vLog.Index),
+					"rootChainType", rootChainType,
+				)
+				return nil
+			}
+		}
+
+		cp.Logger.Info(
 			"⬜ New event found",
 			"event", eventName,
 			"id", event.Id,
@@ -118,6 +138,28 @@ func (cp *ClerkProcessor) sendStateSyncedToHeimdall(eventName string, logBytes s
 	return nil
 }
 
+func (cp *ClerkProcessor) shouldBroadcastStateSyncedEvent(data []byte, rootChainType string) (bool, error) {
+	stateData, err := helper.ParseStateSyncData(data)
+	if err != nil {
+		return false, err
+	}
+	if stateData.EventType != helper.StateSyncEventDeposit {
+		return true, nil
+	}
+
+	return false, nil
+	// rootChainManagerProxy, err := helper.GetRootChainManagerProxy(rootChainType)
+	// if err != nil {
+	// 	return false, err
+	// }
+	// tokenType, err := cp.contractConnector.GetRootTokenType(rootChainType, rootChainManagerProxy, stateData.RootToken)
+	// if err != nil {
+	// 	return false, err
+	// }
+
+	// return tokenType == helper.MintableERC20TokenHash, nil
+}
+
 // isOldTx  checks if tx is already processed or not
 func (cp *ClerkProcessor) isOldTx(cliCtx cliContext.CLIContext, txHash string, logIndex uint64, rootChainType string) (bool, error) {
 	queryParam := map[string]interface{}{

chainmanager/side_handler.go

@@ -49,10 +49,14 @@ func SideHandleMsgNewChain(ctx sdk.Context, msg types.MsgNewChain, k Keeper, con
 		err             error
 	)
 	// get event log on tron
-	receipt, err = contractCaller.GetTronTransactionReceipt(msg.TxHash.Hex())
+	receipt, err = contractCaller.GetTronConfirmedTxReceipt(msg.TxHash.Hex(), params.TronchainTxConfirmations)
 	if err != nil || receipt == nil {
 		return common.ErrorSideTx(k.Codespace(), common.CodeWaitFrConfirmation)
 	}
+	if !helper.IsTronTransactionReceiptSuccessful(receipt) {
+		k.Logger(ctx).Error("Tron transaction failed", "txHash", msg.TxHash.Hex(), "status", receipt.Status)
+		return common.ErrorSideTx(k.Codespace(), common.CodeInvalidMsg)
+	}
 	contractAddress = hmTypes.HexToTronAddress(chainParams.TronChainAddress)
 	// decode validator join event
 	eventLog, err := contractCaller.DecodeNewChainEvent(contractAddress, receipt, msg.LogIndex)

checkpoint/client/cli/tx.go

@@ -240,10 +240,16 @@ func SendCheckpointACKTx(cdc *codec.Codec) *cobra.Command {
 				}
 				rootChainAddress = chainmanagerParams.ChainParams.RootChainAddress.EthAddress()
 			case hmTypes.RootChainTypeTron:
-				receipt, err = contractCallerObj.GetTronTransactionReceipt(txHash.Hex())
+				receipt, err = contractCallerObj.GetTronConfirmedTxReceipt(
+					txHash.Hex(),
+					chainmanagerParams.TronchainTxConfirmations,
+				)
 				if err != nil || receipt == nil {
 					return errors.New("transaction is not confirmed yet. Please wait for sometime and try again")
 				}
+				if !helper.IsTronTransactionReceiptSuccessful(receipt) {
+					return errors.New("tron transaction failed")
+				}
 				rootChainAddress = hmTypes.HexToTronAddress(chainmanagerParams.ChainParams.TronChainAddress)
 			default:
 				return fmt.Errorf("wrong root chain %v", rootChain)

clerk/querier.go

@@ -119,7 +119,10 @@ func handleQueryRecordSequence(ctx sdk.Context, req abci.RequestQuery, keeper Ke
 		receipt, err = contractCallerObj.GetConfirmedTxReceipt(hmTypes.HexToHeimdallHash(params.TxHash).EthHash(),
 			bscChain.TxConfirmations, hmTypes.RootChainTypeBsc, false)
 	case hmTypes.RootChainTypeTron:
-		receipt, err = contractCallerObj.GetTronTransactionReceipt(hmTypes.HexToHeimdallHash(params.TxHash).TronHash().Hex())
+		receipt, err = contractCallerObj.GetTronConfirmedTxReceipt(
+			hmTypes.HexToHeimdallHash(params.TxHash).TronHash().Hex(),
+			chainParams.TronchainTxConfirmations,
+		)
 	default:
 		return nil, sdk.ErrInternal(fmt.Sprintf("wrong chain type = " + params.RootChainType + "please pass correct chainType like eth or tron"))
 	}

clerk/querier_test.go

@@ -246,7 +246,7 @@ func (suite *QuerierTestSuite) TestHandleQueryRecordSequence() {
 	// tron
 	testSeq = helper.CalculateSequence(big.NewInt(1), 1, hmTypes.RootChainTypeTron).String()
 	ck.SetRecordSequence(ctx, testSeq)
-	suite.contractCaller.On("GetTronTransactionReceipt", txHash.TronHash().String()).Return(txreceipt, nil)
+	suite.contractCaller.On("GetTronConfirmedTxReceipt", txHash.TronHash().String(), chainParams.TronchainTxConfirmations).Return(txreceipt, nil)
 	req = abci.RequestQuery{
 		Path: route,
 		Data: app.Codec().MustMarshalJSON(types.NewQueryRecordSequenceParams("12345", logIndex, hmTypes.RootChainTypeTron)),

clerk/side_handler.go

@@ -93,10 +93,14 @@ func SideHandleMsgEventRecord(ctx sdk.Context, k Keeper, msg types.MsgEventRecor
 		}
 		contractAddress = bscChain.StateSenderAddress.EthAddress()
 	case hmTypes.RootChainTypeTron:
-		receipt, err = contractCaller.GetTronTransactionReceipt(msg.TxHash.Hex())
+		receipt, err = contractCaller.GetTronConfirmedTxReceipt(msg.TxHash.Hex(), params.TronchainTxConfirmations)
 		if err != nil || receipt == nil {
 			return hmCommon.ErrorSideTx(k.Codespace(), common.CodeWaitFrConfirmation)
 		}
+		if !helper.IsTronTransactionReceiptSuccessful(receipt) {
+			k.Logger(ctx).Error("Tron transaction failed", "txHash", msg.TxHash.Hex(), "status", receipt.Status)
+			return hmCommon.ErrorSideTx(k.Codespace(), common.CodeInvalidMsg)
+		}
 		contractAddress = hmTypes.HexToTronAddress(chainParams.TronStateSenderAddress)
 	default:
 		k.Logger(ctx).Error("RootChain type: ", msg.RootChainType, " does not  match eth or tron")
@@ -138,6 +142,18 @@ func SideHandleMsgEventRecord(ctx sdk.Context, k Keeper, msg types.MsgEventRecor
 		return hmCommon.ErrorSideTx(k.Codespace(), common.CodeInvalidMsg)
 	}
 
+	if helper.GetConfig().CloseOriginTokenDeposit {
+		shouldVote, err := shouldVoteStateSyncedEvent(contractCaller, msg.RootChainType, msg.Data)
+		if err != nil {
+			k.Logger(ctx).Error("Error parsing state sync data", "error", err)
+			return hmCommon.ErrorSideTx(k.Codespace(), common.CodeErrDecodeEvent)
+		}
+		if !shouldVote {
+			k.Logger(ctx).Error("Deposit token type is not mintable ERC20", "rootChainType", msg.RootChainType, "txHash", msg.TxHash.Hex())
+			return hmCommon.ErrorSideTx(k.Codespace(), common.CodeInvalidMsg)
+		}
+	}
+
 	result.Result = abci.SideTxResultType_Yes
 	return
 }
@@ -211,3 +227,25 @@ func PostHandleMsgEventRecord(ctx sdk.Context, k Keeper, msg types.MsgEventRecor
 		Events: ctx.EventManager().Events(),
 	}
 }
+
+func shouldVoteStateSyncedEvent(contractCaller helper.IContractCaller, rootChainType string, data []byte) (bool, error) {
+	stateData, err := helper.ParseStateSyncData(data)
+	if err != nil {
+		return false, err
+	}
+	if stateData.EventType != helper.StateSyncEventDeposit {
+		return true, nil
+	}
+	return false, nil
+
+	// rootChainManagerProxy, err := helper.GetRootChainManagerProxy(rootChainType)
+	// if err != nil {
+	// 	return false, err
+	// }
+	// tokenType, err := contractCaller.GetRootTokenType(rootChainType, rootChainManagerProxy, stateData.RootToken)
+	// if err != nil {
+	// 	return false, err
+	// }
+
+	// return tokenType == helper.MintableERC20TokenHash, nil
+}

clerk/side_handler_test.go

@@ -1,8 +1,10 @@
 package clerk_test
 
 import (
+	"encoding/hex"
 	"math/big"
 	"math/rand"
+	"strings"
 	"testing"
 	"time"
 
@@ -14,6 +16,7 @@ import (
 	"github.com/stretchr/testify/suite"
 	abci "github.com/tendermint/tendermint/abci/types"
 
+	ethCommon "github.com/ethereum/go-ethereum/common"
 	ethTypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/maticnetwork/heimdall/app"
 	"github.com/maticnetwork/heimdall/clerk"
@@ -62,9 +65,7 @@ func TestSideHandlerTestSuite(t *testing.T) {
 	suite.Run(t, new(SideHandlerTestSuite))
 }
 
-//
 // Test cases
-//
 func (suite *SideHandlerTestSuite) TestSideHandler() {
 	t, ctx := suite.T(), suite.ctx
 
@@ -88,6 +89,7 @@ func (suite *SideHandlerTestSuite) TestSideHandleMsgEventRecord() {
 		logIndex := uint64(10)
 		blockNumber := uint64(599)
 		txReceipt := &ethTypes.Receipt{
+			Status:      ethTypes.ReceiptStatusSuccessful,
 			BlockNumber: new(big.Int).SetUint64(blockNumber),
 		}
 		txHash := hmTypes.HexToHeimdallHash("success hash")
@@ -131,6 +133,7 @@ func (suite *SideHandlerTestSuite) TestSideHandleMsgEventRecord() {
 		logIndex := uint64(10)
 		blockNumber := uint64(599)
 		txReceipt := &ethTypes.Receipt{
+			Status:      ethTypes.ReceiptStatusSuccessful,
 			BlockNumber: new(big.Int).SetUint64(blockNumber),
 		}
 		txHash := hmTypes.HexToHeimdallHash("hello tron")
@@ -147,7 +150,7 @@ func (suite *SideHandlerTestSuite) TestSideHandleMsgEventRecord() {
 			suite.chainID,
 			hmTypes.RootChainTypeTron,
 		)
-		suite.contractCaller.On("GetTronTransactionReceipt", txHash.Hex()).Return(txReceipt, nil)
+		suite.contractCaller.On("GetTronConfirmedTxReceipt", txHash.Hex(), chainParams.TronchainTxConfirmations).Return(txReceipt, nil)
 		event := &statesender.StatesenderStateSynced{
 			Id:              new(big.Int).SetUint64(msg.ID),
 			ContractAddress: msg.ContractAddress.TronAddress(),
@@ -166,6 +169,95 @@ func (suite *SideHandlerTestSuite) TestSideHandleMsgEventRecord() {
 		require.Error(t, err)
 
 	})
+
+	t.Run("CloseOriginTokenDeposit", func(t *testing.T) {
+		suite.contractCaller = mocks.IContractCaller{}
+		suite.sideHandler = clerk.NewSideTxHandler(suite.app.ClerkKeeper, &suite.contractCaller)
+		conf := helper.GetDefaultHeimdallConfig()
+		conf.CloseOriginTokenDeposit = true
+		conf.EthRootChainManagerProxy = "0x0000000000000000000000000000000000000001"
+		helper.SetTestConfig(conf)
+		defer helper.SetTestConfig(helper.GetDefaultHeimdallConfig())
+
+		logIndex := uint64(11)
+		blockNumber := uint64(600)
+		txReceipt := &ethTypes.Receipt{
+			BlockNumber: new(big.Int).SetUint64(blockNumber),
+		}
+		txHash := hmTypes.HexToHeimdallHash("mintable deposit")
+		data, err := hex.DecodeString(strings.TrimPrefix(depositStateSyncData, "0x"))
+		require.NoError(t, err)
+		rootToken := ethCommon.HexToAddress("0x032017411f4663b317fe77c257d28d5cd1b26e3d")
+
+		msg := types.NewMsgEventRecord(
+			hmTypes.BytesToHeimdallAddress(addr1.Bytes()),
+			txHash,
+			logIndex,
+			blockNumber,
+			id,
+			hmTypes.BytesToHeimdallAddress(addr1.Bytes()),
+			data,
+			suite.chainID,
+			hmTypes.RootChainTypeEth,
+		)
+
+		suite.contractCaller.On("GetConfirmedTxReceipt", txHash.EthHash(), chainParams.MainchainTxConfirmations, hmTypes.RootChainTypeEth).Return(txReceipt, nil)
+		event := &statesender.StatesenderStateSynced{
+			Id:              new(big.Int).SetUint64(msg.ID),
+			ContractAddress: msg.ContractAddress.EthAddress(),
+			Data:            msg.Data,
+		}
+		suite.contractCaller.On("DecodeStateSyncedEvent", chainParams.ChainParams.StateSenderAddress.EthAddress(), txReceipt, logIndex).Return(event, nil)
+		suite.contractCaller.On("GetRootTokenType", hmTypes.RootChainTypeEth, conf.EthRootChainManagerProxy, rootToken).Return(helper.MintableERC20TokenHash, nil)
+
+		result := suite.sideHandler(ctx, msg)
+		require.Equal(t, uint32(common.CodeInvalidMsg), result.Code)
+		require.Equal(t, abci.SideTxResultType_Skip, result.Result)
+	})
+	t.Run("CloseOriginTokenDeposit", func(t *testing.T) {
+		suite.contractCaller = mocks.IContractCaller{}
+		suite.sideHandler = clerk.NewSideTxHandler(suite.app.ClerkKeeper, &suite.contractCaller)
+		conf := helper.GetDefaultHeimdallConfig()
+		conf.CloseOriginTokenDeposit = true
+		conf.EthRootChainManagerProxy = "0x0000000000000000000000000000000000000001"
+		helper.SetTestConfig(conf)
+		defer helper.SetTestConfig(helper.GetDefaultHeimdallConfig())
+
+		logIndex := uint64(12)
+		blockNumber := uint64(601)
+		txReceipt := &ethTypes.Receipt{
+			BlockNumber: new(big.Int).SetUint64(blockNumber),
+		}
+		txHash := hmTypes.HexToHeimdallHash("non mintable deposit")
+		data, err := hex.DecodeString(strings.TrimPrefix(depositStateSyncData, "0x"))
+		require.NoError(t, err)
+		rootToken := ethCommon.HexToAddress("0x032017411f4663b317fe77c257d28d5cd1b26e3d")
+
+		msg := types.NewMsgEventRecord(
+			hmTypes.BytesToHeimdallAddress(addr1.Bytes()),
+			txHash,
+			logIndex,
+			blockNumber,
+			id,
+			hmTypes.BytesToHeimdallAddress(addr1.Bytes()),
+			data,
+			suite.chainID,
+			hmTypes.RootChainTypeEth,
+		)
+
+		suite.contractCaller.On("GetConfirmedTxReceipt", txHash.EthHash(), chainParams.MainchainTxConfirmations, hmTypes.RootChainTypeEth).Return(txReceipt, nil)
+		event := &statesender.StatesenderStateSynced{
+			Id:              new(big.Int).SetUint64(msg.ID),
+			ContractAddress: msg.ContractAddress.EthAddress(),
+			Data:            msg.Data,
+		}
+		suite.contractCaller.On("DecodeStateSyncedEvent", chainParams.ChainParams.StateSenderAddress.EthAddress(), txReceipt, logIndex).Return(event, nil)
+		suite.contractCaller.On("GetRootTokenType", hmTypes.RootChainTypeEth, conf.EthRootChainManagerProxy, rootToken).Return(ethCommon.HexToHash("0x01"), nil)
+
+		result := suite.sideHandler(ctx, msg)
+		require.NotEqual(t, uint32(sdk.CodeOK), result.Code)
+		require.Equal(t, abci.SideTxResultType_Skip, result.Result)
+	})
 	t.Run("NoReceipt", func(t *testing.T) {
 		suite.contractCaller = mocks.IContractCaller{}
 
@@ -201,6 +293,7 @@ func (suite *SideHandlerTestSuite) TestSideHandleMsgEventRecord() {
 		logIndex := uint64(100)
 		blockNumber := uint64(510)
 		txReceipt := &ethTypes.Receipt{
+			Status:      ethTypes.ReceiptStatusSuccessful,
 			BlockNumber: new(big.Int).SetUint64(blockNumber),
 		}
 		txHash := hmTypes.HexToHeimdallHash("no log hash")
@@ -228,6 +321,8 @@ func (suite *SideHandlerTestSuite) TestSideHandleMsgEventRecord() {
 	})
 }
 
+const depositStateSyncData = "0x87a7811f4bfedea3d341ad165680ae306b01aaeacc205d227629cf157dd9f821000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000a9635197462ba512b47d19399017f6857888bc27000000000000000000000000032017411f4663b317fe77c257d28d5cd1b26e3d0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000056bc75e2d63100000"
+
 func (suite *SideHandlerTestSuite) TestPostHandler() {
 	t, ctx := suite.T(), suite.ctx