Inner Transaction Search

api/converter_utils.go

@@ -246,13 +246,23 @@ type rowData struct {
 	AssetCloseAmount uint64
 }
 
+// txnRowToTransaction parses the idb.TxnRow and generates the appropriate generated.Transaction object.
+// If the idb.TxnRow represents an inner transaction, the root transaction is returned.
 func txnRowToTransaction(row idb.TxnRow) (generated.Transaction, error) {
 	if row.Error != nil {
 		return generated.Transaction{}, row.Error
 	}
 
+	var bytes []byte
+	if row.TxnBytes != nil {
+		bytes = row.TxnBytes
+	} else if row.RootTxnBytes != nil {
+		bytes = row.RootTxnBytes
+	} else {
+		return generated.Transaction{}, fmt.Errorf("%d:%d transaction bytes missing", row.Round, row.Intra)
+	}
 	var stxn transactions.SignedTxnWithAD
-	err := protocol.Decode(row.TxnBytes, &stxn)
+	err := protocol.Decode(bytes, &stxn)
 	if err != nil {
 		return generated.Transaction{}, fmt.Errorf("%s: %s", errUnableToDecodeTransaction, err.Error())
 	}
@@ -265,9 +275,16 @@ func txnRowToTransaction(row idb.TxnRow) (generated.Transaction, error) {
 		AssetCloseAmount: row.Extra.AssetCloseAmount,
 	}
 
+	if row.Extra.RootIntra != "" {
+		extra.Intra, err = strconv.Atoi(row.Extra.RootIntra)
+		if err != nil {
+			return generated.Transaction{}, fmt.Errorf("txnRowToTransaction(): failed to parse root-intra (%s): %w", row.Extra.RootIntra, err)
+		}
+	}
+
 	txn, err := signedTxnWithAdToTransaction(&stxn, extra)
 	if err != nil {
-		return generated.Transaction{}, err
+		return generated.Transaction{}, fmt.Errorf("txnRowToTransaction(): failure converting signed transaction to response: %w", err)
 	}
 
 	sig := generated.TransactionSignature{

api/handlers.go

@@ -676,7 +676,6 @@ func (si *ServerImplementation) fetchBlock(ctx context.Context, round uint64) (g
 			return generated.Block{}, err
 		}
 		results = append(results, tx)
-		txrow.Next()
 	}
 
 	ret.Transactions = &results
@@ -727,19 +726,42 @@ func (si *ServerImplementation) fetchAccounts(ctx context.Context, options idb.A
 
 // fetchTransactions is used to query the backend for transactions, and compute the next token
 func (si *ServerImplementation) fetchTransactions(ctx context.Context, filter idb.TransactionFilter) ([]generated.Transaction, string, uint64 /*round*/, error) {
+	// Used for filtering duplicates after getting results.
+	rootTxnDedupeMap := make(map[string]struct{})
+
 	results := make([]generated.Transaction, 0)
 	txchan, round := si.db.Transactions(ctx, filter)
 	nextToken := ""
-	for txrow := range txchan {
+	var txrow idb.TxnRow
+	for txrow = range txchan {
 		tx, err := txnRowToTransaction(txrow)
 		if err != nil {
 			return nil, "", round, err
 		}
+
+		// Do not return inner transactions.
+		if tx.Id == nil {
+			continue
+		}
+
+		// The root txn has already been added.
+		if _, ok := rootTxnDedupeMap[*tx.Id]; ok {
+			continue
+		}
+
+		rootTxnDedupeMap[*tx.Id] = struct{}{}
 		results = append(results, tx)
-		nextToken = txrow.Next()
 	}
 
-	return results, nextToken, round, nil
+	// No next token if there were no results.
+	if len(results) == 0 {
+		return results, "", round, nil
+	}
+
+	// The sort order depends on whether the address filter is used.
+	nextToken, err := txrow.Next(filter.Address == nil)
+
+	return results, nextToken, round, err
 }
 
 //////////////////////

api/handlers_e2e_test.go

@@ -10,8 +10,10 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/algorand/go-algorand-sdk/encoding/json"
+	"github.com/algorand/go-algorand/data/basics"
 	"github.com/algorand/go-algorand/data/bookkeeping"
 	"github.com/algorand/go-algorand/data/transactions"
+
 	"github.com/algorand/indexer/api/generated/v2"
 	"github.com/algorand/indexer/idb"
 	"github.com/algorand/indexer/idb/postgres"
@@ -130,3 +132,170 @@ func TestBlockNotFound(t *testing.T) {
 	require.Equal(t, http.StatusNotFound, rec.Code)
 	require.Equal(t, "{\"message\":\"error while looking up block for round '100': block not found\"}\n", rec.Body.String())
 }
+
+// TestInnerTxn runs queries that return one or more root/inner transactions,
+// and verifies that only a single root transaction is returned.
+func TestInnerTxn(t *testing.T) {
+	var appAddr basics.Address
+	appAddr[1] = 99
+	appAddrStr := appAddr.String()
+
+	pay := "pay"
+	axfer := "axfer"
+	testcases := []struct {
+		name   string
+		filter generated.SearchForTransactionsParams
+	}{
+		{
+			name:   "match on root",
+			filter: generated.SearchForTransactionsParams{Address: &appAddrStr, TxType: &pay},
+		},
+		{
+			name:   "match on inner",
+			filter: generated.SearchForTransactionsParams{Address: &appAddrStr, TxType: &pay},
+		},
+		{
+			name:   "match on inner-inner",
+			filter: generated.SearchForTransactionsParams{Address: &appAddrStr, TxType: &axfer},
+		},
+		{
+			name:   "match all",
+			filter: generated.SearchForTransactionsParams{Address: &appAddrStr},
+		},
+	}
+
+	db, shutdownFunc := setupIdb(t, test.MakeGenesis(), test.MakeGenesisBlock())
+	defer shutdownFunc()
+
+	///////////
+	// Given // a DB with some inner txns in it.
+	///////////
+	appCall := test.MakeAppCallWithInnerTxn(test.AccountA, appAddr, test.AccountB, appAddr, test.AccountC)
+	expectedID := appCall.Txn.ID().String()
+
+	block, err := test.MakeBlockForTxns(test.MakeGenesisBlock().BlockHeader, &appCall)
+	require.NoError(t, err)
+
+	err = db.AddBlock(&block)
+	require.NoError(t, err, "failed to commit")
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			//////////
+			// When // we run a query that matches the Root Txn and/or Inner Txns
+			//////////
+			e := echo.New()
+			req := httptest.NewRequest(http.MethodGet, "/", nil)
+			rec := httptest.NewRecorder()
+			c := e.NewContext(req, rec)
+			c.SetPath("/v2/transactions/")
+
+			api := &ServerImplementation{db: db}
+			err = api.SearchForTransactions(c, tc.filter)
+			require.NoError(t, err)
+
+			//////////
+			// Then // The only result is the root transaction.
+			//////////
+			require.Equal(t, http.StatusOK, rec.Code)
+			var response generated.TransactionsResponse
+			json.Decode(rec.Body.Bytes(), &response)
+
+			require.Len(t, response.Transactions, 1)
+			require.Equal(t, expectedID, *(response.Transactions[0].Id))
+		})
+	}
+}
+
+// TestPagingRootTxnDeduplication checks that paging in the middle of an inner
+// transaction group does not allow the root transaction to be returned on both
+// pages.
+func TestPagingRootTxnDeduplication(t *testing.T) {
+	db, shutdownFunc := setupIdb(t, test.MakeGenesis(), test.MakeGenesisBlock())
+	defer shutdownFunc()
+
+	///////////
+	// Given // a DB with some inner txns in it.
+	///////////
+	var appAddr basics.Address
+	appAddr[1] = 99
+	appAddrStr := appAddr.String()
+
+	appCall := test.MakeAppCallWithInnerTxn(test.AccountA, appAddr, test.AccountB, appAddr, test.AccountC)
+	expectedID := appCall.Txn.ID().String()
+
+	block, err := test.MakeBlockForTxns(test.MakeGenesisBlock().BlockHeader, &appCall)
+	require.NoError(t, err)
+
+	err = db.AddBlock(&block)
+	require.NoError(t, err, "failed to commit")
+
+	testcases := []struct {
+		name   string
+		params generated.SearchForTransactionsParams
+	}{
+		{
+			name:   "descending transaction search, middle of inner txns",
+			params: generated.SearchForTransactionsParams{Address: &appAddrStr, Limit: uint64Ptr(1)},
+		},
+		{
+			name:   "ascending transaction search, middle of inner txns",
+			params: generated.SearchForTransactionsParams{Limit: uint64Ptr(2)},
+		},
+		{
+			name:   "ascending transaction search, match root skip over inner txns",
+			params: generated.SearchForTransactionsParams{Limit: uint64Ptr(1)},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			//////////
+			// When // we match the first inner transaction and page to the next.
+			//////////
+			e := echo.New()
+			req := httptest.NewRequest(http.MethodGet, "/", nil)
+			rec1 := httptest.NewRecorder()
+			c := e.NewContext(req, rec1)
+			c.SetPath("/v2/transactions/")
+
+			// Get first page with limit 1.
+			// Address filter causes results to return newest to oldest.
+			api := &ServerImplementation{db: db}
+			err = api.SearchForTransactions(c, tc.params)
+			require.NoError(t, err)
+
+			require.Equal(t, http.StatusOK, rec1.Code)
+			var response generated.TransactionsResponse
+			json.Decode(rec1.Body.Bytes(), &response)
+			require.Len(t, response.Transactions, 1)
+			require.Equal(t, expectedID, *(response.Transactions[0].Id))
+			pageOneNextToken := *response.NextToken
+
+			// Second page, using "NextToken" from first page.
+			req = httptest.NewRequest(http.MethodGet, "/", nil)
+			rec2 := httptest.NewRecorder()
+			c = e.NewContext(req, rec2)
+			c.SetPath("/v2/transactions/")
+
+			// Set the next token
+			tc.params.Next = &pageOneNextToken
+			// In the debugger I see the internal call returning the inner tx + root tx
+			err = api.SearchForTransactions(c, tc.params)
+			require.NoError(t, err)
+
+			//////////
+			// Then // There are no new results on the next page.
+			//////////
+			var response2 generated.TransactionsResponse
+			require.Equal(t, http.StatusOK, rec2.Code)
+			json.Decode(rec2.Body.Bytes(), &response2)
+
+			require.Len(t, response2.Transactions, 0)
+			// The fact that NextToken changes indicates that the search results were different.
+			if response2.NextToken != nil {
+				require.NotEqual(t, pageOneNextToken, *response2.NextToken)
+			}
+		})
+	}
+}

api/indexer.oas2.json

@@ -2094,7 +2094,7 @@
     },
     "limit": {
       "type": "integer",
-      "description": "Maximum number of results to return.",
+      "description": "Maximum number of results to return. There could be additional pages even if the limit is not reached.",
       "name": "limit",
       "in": "query"
     },