relayed v3 get transaction response improved + support for inner tx

README.md

@@ -35,6 +35,7 @@ For more details, go [here](https://docs.multiversx.com/sdk-and-tools/proxy/).
 - `/v1.0/transaction/cost`         (POST) --> receives a single transaction in JSON format and returns it's cost
 - `/v1.0/transaction/:txHash` (GET) --> returns the transaction which corresponds to the hash
 - `/v1.0/transaction/:txHash?withResults=true` (GET) --> returns the transaction and results which correspond to the hash
+- `/v1.0/transaction/:txHash?withResults=true&withRelayedTxHash=:relayedTxHash` (GET) --> returns the inner transaction which corresponds to the hash and was part of the relayedTxHash
 - `/v1.0/transaction/:txHash?sender=senderAddress` (GET) --> returns the transaction which corresponds to the hash (faster because will ask for transaction from the observer which is in the shard in which the address is part).
 - `/v1.0/transaction/:txHash?sender=senderAddress&withResults=true` (GET) --> returns the transaction and results which correspond to the hash (faster because will ask for transaction from observer which is in the shard in which the address is part)
 - `/v1.0/transaction/:txHash/status` (GET) --> returns the status of the transaction which corresponds to the hash

api/groups/baseTransactionGroup.go

@@ -239,7 +239,7 @@ func (group *transactionGroup) getTransaction(c *gin.Context) {
 		return
 	}
 
-	tx, err := group.facade.GetTransaction(txHash, options.WithResults)
+	tx, err := group.facade.GetTransaction(txHash, options.WithResults, options.WithRelayedTxHash)
 	if err != nil {
 		shared.RespondWith(c, http.StatusInternalServerError, nil, err.Error(), data.ReturnCodeInternalError)
 		return

api/groups/interface.go

@@ -95,7 +95,7 @@ type TransactionFacadeHandler interface {
 	TransactionCostRequest(tx *data.Transaction) (*data.TxCostResponseData, error)
 	GetTransactionStatus(txHash string, sender string) (string, error)
 	GetProcessedTransactionStatus(txHash string) (*data.ProcessStatusResponse, error)
-	GetTransaction(txHash string, withResults bool) (*transaction.ApiTransactionResult, error)
+	GetTransaction(txHash string, withResults bool, withRelayedTxHash string) (*transaction.ApiTransactionResult, error)
 	GetTransactionByHashAndSenderAddress(txHash string, sndAddr string, withEvents bool) (*transaction.ApiTransactionResult, int, error)
 	GetTransactionsPool(fields string) (*data.TransactionsPool, error)
 	GetTransactionsPoolForShard(shardID uint32, fields string) (*data.TransactionsPool, error)

api/groups/urlParams.go

@@ -124,7 +124,12 @@ func parseTransactionQueryOptions(c *gin.Context) (common.TransactionQueryOption
 		return common.TransactionQueryOptions{}, err
 	}
 
-	options := common.TransactionQueryOptions{WithResults: withResults}
+	withRelayedTxHash := parseStringUrlParam(c, common.UrlParameterWithRelayedTxHash)
+
+	options := common.TransactionQueryOptions{
+		WithResults:       withResults,
+		WithRelayedTxHash: withRelayedTxHash,
+	}
 	return options, nil
 }
 

api/mock/facadeStub.go

@@ -24,7 +24,7 @@ type FacadeStub struct {
 	GetNFTTokenIDsRegisteredByAddressCalled      func(address string, options common.AccountQueryOptions) (*data.GenericAPIResponse, error)
 	GetAllESDTTokensCalled                       func(address string, options common.AccountQueryOptions) (*data.GenericAPIResponse, error)
 	GetTransactionsHandler                       func(address string) ([]data.DatabaseTransaction, error)
-	GetTransactionHandler                        func(txHash string, withResults bool) (*transaction.ApiTransactionResult, error)
+	GetTransactionHandler                        func(txHash string, withResults bool, withRelayedTxHash string) (*transaction.ApiTransactionResult, error)
 	GetTransactionsPoolHandler                   func(fields string) (*data.TransactionsPool, error)
 	GetTransactionsPoolForShardHandler           func(shardID uint32, fields string) (*data.TransactionsPool, error)
 	GetTransactionsPoolForSenderHandler          func(sender, fields string) (*data.TransactionsPoolForSender, error)
@@ -343,8 +343,8 @@ func (f *FacadeStub) GetTransactionByHashAndSenderAddress(txHash string, sndAddr
 }
 
 // GetTransaction -
-func (f *FacadeStub) GetTransaction(txHash string, withResults bool) (*transaction.ApiTransactionResult, error) {
-	return f.GetTransactionHandler(txHash, withResults)
+func (f *FacadeStub) GetTransaction(txHash string, withResults bool, withRelayedTxHash string) (*transaction.ApiTransactionResult, error) {
+	return f.GetTransactionHandler(txHash, withResults, withRelayedTxHash)
 }
 
 // GetTransactionsPool -

cmd/proxy/config/swagger/openapi.json

@@ -2042,7 +2042,7 @@
         }
       }
     },
-    "/transaction/{txHash}?withResults=true": {
+    "/transaction/{txHash}?withResults=true&withRelayedTxHash={relayedTxHash}": {
       "get": {
         "tags": [
           "transaction"

common/options.go

@@ -49,6 +49,8 @@ const (
 	UrlParameterWithAlteredAccounts = "withAlteredAccounts"
 	// UrlParameterWithKeys represents the name of an URL parameter
 	UrlParameterWithKeys = "withKeys"
+	// UrlParameterWithRelayedTxHash represents the name of an URL parameter
+	UrlParameterWithRelayedTxHash = "withRelayedTxHash"
 )
 
 // BlockQueryOptions holds options for block queries
@@ -67,7 +69,8 @@ type HyperblockQueryOptions struct {
 
 // TransactionQueryOptions holds options for transaction queries
 type TransactionQueryOptions struct {
-	WithResults bool
+	WithResults       bool
+	WithRelayedTxHash string
 }
 
 // TransactionSimulationOptions holds options for transaction simulation requests

facade/baseFacade.go

@@ -221,8 +221,8 @@ func (pf *ProxyFacade) GetProcessedTransactionStatus(txHash string) (*data.Proce
 }
 
 // GetTransaction should return a transaction by hash
-func (pf *ProxyFacade) GetTransaction(txHash string, withResults bool) (*transaction.ApiTransactionResult, error) {
-	return pf.txProc.GetTransaction(txHash, withResults)
+func (pf *ProxyFacade) GetTransaction(txHash string, withResults bool, withRelayedTxHash string) (*transaction.ApiTransactionResult, error) {
+	return pf.txProc.GetTransaction(txHash, withResults, withRelayedTxHash)
 }
 
 // ReloadObservers will try to reload the observers

facade/interface.go

@@ -41,7 +41,7 @@ type TransactionProcessor interface {
 	SimulateTransaction(tx *data.Transaction, checkSignature bool) (*data.GenericAPIResponse, error)
 	TransactionCostRequest(tx *data.Transaction) (*data.TxCostResponseData, error)
 	GetTransactionStatus(txHash string, sender string) (string, error)
-	GetTransaction(txHash string, withEvents bool) (*transaction.ApiTransactionResult, error)
+	GetTransaction(txHash string, withEvents bool, withRelayedTxHash string) (*transaction.ApiTransactionResult, error)
 	GetProcessedTransactionStatus(txHash string) (*data.ProcessStatusResponse, error)
 	GetTransactionByHashAndSenderAddress(txHash string, sndAddr string, withEvents bool) (*transaction.ApiTransactionResult, int, error)
 	ComputeTransactionHash(tx *data.Transaction) (string, error)

facade/mock/transactionProcessorStub.go

@@ -19,7 +19,7 @@ type TransactionProcessorStub struct {
 	TransactionCostRequestCalled                func(tx *data.Transaction) (*data.TxCostResponseData, error)
 	GetTransactionStatusCalled                  func(txHash string, sender string) (string, error)
 	GetProcessedTransactionStatusCalled         func(txHash string) (*data.ProcessStatusResponse, error)
-	GetTransactionCalled                        func(txHash string, withEvents bool) (*transaction.ApiTransactionResult, error)
+	GetTransactionCalled                        func(txHash string, withEvents bool, withRelayedTxHash string) (*transaction.ApiTransactionResult, error)
 	GetTransactionByHashAndSenderAddressCalled  func(txHash string, sndAddr string, withEvents bool) (*transaction.ApiTransactionResult, int, error)
 	ComputeTransactionHashCalled                func(tx *data.Transaction) (string, error)
 	GetTransactionsPoolCalled                   func(fields string) (*data.TransactionsPool, error)
@@ -93,9 +93,9 @@ func (tps *TransactionProcessorStub) GetProcessedTransactionStatus(txHash string
 }
 
 // GetTransaction -
-func (tps *TransactionProcessorStub) GetTransaction(txHash string, withEvents bool) (*transaction.ApiTransactionResult, error) {
+func (tps *TransactionProcessorStub) GetTransaction(txHash string, withEvents bool, withRelayedTxHash string) (*transaction.ApiTransactionResult, error) {
 	if tps.GetTransactionCalled != nil {
-		return tps.GetTransactionCalled(txHash, withEvents)
+		return tps.GetTransactionCalled(txHash, withEvents, withRelayedTxHash)
 	}
 
 	return nil, errNotImplemented

process/errors.go

@@ -112,3 +112,6 @@ var ErrEmptyPubKey = errors.New("public key is empty")
 
 // ErrNilHttpClient signals that a nil http client has been provided
 var ErrNilHttpClient = errors.New("nil http client")
+
+// ErrInvalidHash signals that an invalid hash has been provided
+var ErrInvalidHash = errors.New("invalid hash")

process/transactionProcessor.go

@@ -359,16 +359,99 @@ func (tp *TransactionProcessor) TransactionCostRequest(tx *data.Transaction) (*d
 }
 
 // GetTransaction should return a transaction from observer
-func (tp *TransactionProcessor) GetTransaction(txHash string, withResults bool) (*transaction.ApiTransactionResult, error) {
-	tx, err := tp.getTxFromObservers(txHash, requestTypeFullHistoryNodes, withResults)
+func (tp *TransactionProcessor) GetTransaction(txHash string, withResults bool, withRelayedTxHash string) (*transaction.ApiTransactionResult, error) {
+	txHashToGetFromObservers := txHash
+
+	// if the relayed tx hash was provided, this one should be requested from observers
+	innerTxRequested := len(withRelayedTxHash) == len(txHash)
+	if innerTxRequested {
+		txHashToGetFromObservers = withRelayedTxHash
+	}
+
+	tx, err := tp.getTxFromObservers(txHashToGetFromObservers, requestTypeFullHistoryNodes, withResults)
 	if err != nil {
 		return nil, err
 	}
 
 	tx.HyperblockNonce = tx.NotarizedAtDestinationInMetaNonce
 	tx.HyperblockHash = tx.NotarizedAtDestinationInMetaHash
 
-	return tx, nil
+	if len(tx.InnerTransactions) == 0 {
+		if innerTxRequested {
+			return nil, fmt.Errorf("%w, requested hash %s with relayedTxHash %s, but the relayedTxHash has no inner transaction",
+				ErrInvalidHash, txHash, withRelayedTxHash)
+		}
+
+		return tx, nil
+	}
+
+	convertRelayedTxV3ToNetworkTx(tx)
+
+	// requested a relayed transaction, returning it after scrs were moved
+	if !innerTxRequested {
+		return tx, nil
+	}
+
+	for _, innerTx := range tx.InnerTransactions {
+		if innerTx.Hash == txHash {
+			return innerTx, nil
+		}
+	}
+
+	return nil, fmt.Errorf("%w, but the relayedTx %s has no inner transaction with hash %s",
+		ErrInvalidHash, withRelayedTxHash, txHash)
+}
+
+func convertRelayedTxV3ToNetworkTx(tx *transaction.ApiTransactionResult) {
+	movedSCRs := make(map[string]struct{}, 0)
+	for _, innerTx := range tx.InnerTransactions {
+		for _, scr := range tx.SmartContractResults {
+			if isResultOfInnerTx(tx.SmartContractResults, scr, innerTx.Hash) {
+				innerTx.SmartContractResults = append(innerTx.SmartContractResults, scr)
+				movedSCRs[scr.Hash] = struct{}{}
+			}
+		}
+	}
+
+	if len(movedSCRs) == len(tx.SmartContractResults) {
+		// all scrs were generated by inner txs
+		tx.SmartContractResults = make([]*transaction.ApiSmartContractResult, 0)
+		return
+	}
+
+	numSCRsLeftForRelayer := len(tx.SmartContractResults) - len(movedSCRs)
+	scrsForRelayer := make([]*transaction.ApiSmartContractResult, 0, numSCRsLeftForRelayer)
+	for _, scr := range tx.SmartContractResults {
+		_, wasMoved := movedSCRs[scr.Hash]
+		if !wasMoved {
+			scrsForRelayer = append(scrsForRelayer, scr)
+		}
+	}
+
+	tx.SmartContractResults = scrsForRelayer
+}
+
+func isResultOfInnerTx(allScrs []*transaction.ApiSmartContractResult, currentScr *transaction.ApiSmartContractResult, innerTxHash string) bool {
+	if currentScr.PrevTxHash == innerTxHash {
+		return true
+	}
+
+	parentScr := getParentSCR(allScrs, currentScr.PrevTxHash)
+	if check.IfNilReflect(parentScr) {
+		return false
+	}
+
+	return isResultOfInnerTx(allScrs, parentScr, innerTxHash)
+}
+
+func getParentSCR(allScrs []*transaction.ApiSmartContractResult, hash string) *transaction.ApiSmartContractResult {
+	for _, scr := range allScrs {
+		if scr.Hash == hash {
+			return scr
+		}
+	}
+
+	return nil
 }
 
 // GetTransactionByHashAndSenderAddress returns a transaction
@@ -712,7 +795,7 @@ func (tp *TransactionProcessor) gatherAllLogsAndScrs(tx *transaction.ApiTransact
 	}
 
 	for _, scrFromTx := range tx.SmartContractResults {
-		scr, err := tp.GetTransaction(scrFromTx.Hash, withResults)
+		scr, err := tp.GetTransaction(scrFromTx.Hash, withResults, "")
 		if err != nil {
 			return nil, nil, fmt.Errorf("%w for scr hash %s", err, scrFromTx.Hash)
 		}