Merge pull request #290 from multiversx/mvx_to_eth

MVX-> ETH integration test swap with chain simulator

clients/multiversx/interface.go

@@ -21,6 +21,7 @@ type Proxy interface {
 	GetShardOfAddress(ctx context.Context, bech32Address string) (uint32, error)
 	GetESDTTokenData(ctx context.Context, address core.AddressHandler, tokenIdentifier string, queryOptions api.AccountQueryOptions) (*data.ESDTFungibleTokenData, error)
 	GetTransactionInfoWithResults(ctx context.Context, hash string) (*data.TransactionInfo, error)
+	ProcessTransactionStatus(ctx context.Context, hexTxHash string) (transaction.TxStatus, error)
 	IsInterfaceNil() bool
 }
 

integrationTests/mock/multiversXChainMock.go

@@ -136,6 +136,11 @@ func (mock *MultiversXChainMock) GetTransactionInfoWithResults(_ context.Context
 	return &data.TransactionInfo{}, nil
 }
 
+// ProcessTransactionStatus -
+func (mock *MultiversXChainMock) ProcessTransactionStatus(_ context.Context, _ string) (transaction.TxStatus, error) {
+	return "", nil
+}
+
 // AddRelayer -
 func (mock *MultiversXChainMock) AddRelayer(address sdkCore.AddressHandler) {
 	mock.mutState.Lock()

integrationTests/proxyWithChainSimulator.go

@@ -226,26 +226,52 @@ func (instance *proxyWithChainSimulator) DeploySC(ctx context.Context, wasmFileP
 
 // GetTransactionResult tries to get a transaction result. It may wait a few blocks
 func (instance *proxyWithChainSimulator) GetTransactionResult(ctx context.Context, hash string) (data.TransactionOnNetwork, error) {
-	txResult, errGet := instance.proxyInstance.GetTransactionInfoWithResults(ctx, hash)
-	if errGet == nil && txResult.Data.Transaction.Status == transaction.TxStatusSuccess.String() {
-		return txResult.Data.Transaction, nil
+	txResult, err := instance.getTxInfoWithResultsIfTxProcessingFinished(ctx, hash)
+	if err == nil && txResult != nil {
+		return *txResult, nil
 	}
 
 	// wait for tx to be done, in order to get the contract address
-	timeoutTimer := time.NewTimer(instance.roundDuration * 5)
+	timeoutTimer := time.NewTimer(instance.roundDuration * 20)
 	for {
 		select {
 		case <-time.After(instance.roundDuration):
-			txResult, errGet = instance.proxyInstance.GetTransactionInfoWithResults(ctx, hash)
-			if errGet == nil && txResult.Data.Transaction.Status == transaction.TxStatusSuccess.String() {
-				return txResult.Data.Transaction, nil
+			txResult, err = instance.getTxInfoWithResultsIfTxProcessingFinished(ctx, hash)
+			if err == nil && txResult != nil {
+				return *txResult, nil
+			}
+			if err != nil {
+				return data.TransactionOnNetwork{}, err
 			}
 		case <-timeoutTimer.C:
 			return data.TransactionOnNetwork{}, errors.New("timeout")
 		}
 	}
 }
 
+func (instance *proxyWithChainSimulator) getTxInfoWithResultsIfTxProcessingFinished(ctx context.Context, hash string) (*data.TransactionOnNetwork, error) {
+	txStatus, err := instance.proxyInstance.ProcessTransactionStatus(ctx, hash)
+	if err != nil {
+		return nil, err
+	}
+
+	if txStatus == transaction.TxStatusPending {
+		return nil, nil
+	}
+
+	if txStatus != transaction.TxStatusSuccess {
+		log.Warn("something went wrong with the transaction", "hash", hash, "status", txStatus)
+	}
+
+	txResult, errGet := instance.proxyInstance.GetTransactionInfoWithResults(ctx, hash)
+	if errGet != nil {
+		return nil, err
+	}
+
+	return &txResult.Data.Transaction, nil
+
+}
+
 // ScCall will make the provided sc call
 func (instance *proxyWithChainSimulator) ScCall(ctx context.Context, senderPK string, senderSK []byte, contract string, value string, function string, parameters []string) (string, error) {
 	params := []string{function}