API: Experimental full assets for account endpoint.

daemon/algod/api/server/v2/handlers.go

@@ -105,7 +105,7 @@
 	ConsensusParams(r basics.Round) (config.ConsensusParams, error)
 	Latest() basics.Round
 	LookupAsset(rnd basics.Round, addr basics.Address, aidx basics.AssetIndex) (ledgercore.AssetResource, error)
-	LookupAssets(rnd basics.Round, addr basics.Address, assetIDGT basics.AssetIndex, limit uint64) ([]ledgercore.AssetResourceWithIDs, basics.Round, error)
+	LookupAssets(addr basics.Address, assetIDGT basics.AssetIndex, limit uint64) ([]ledgercore.AssetResourceWithIDs, basics.Round, error)
 	LookupApplication(rnd basics.Round, addr basics.Address, aidx basics.AppIndex) (ledgercore.AppResource, error)
 	BlockCert(rnd basics.Round) (blk bookkeeping.Block, cert agreement.Certificate, err error)
 	LatestTotals() (basics.Round, ledgercore.AccountTotals, error)
@@ -1113,93 +1113,92 @@
 
 // AccountAssetsInformation looks up an account's asset holdings.
 // (GET /v2/accounts/{address}/assets)
 func (v2 *Handlers) AccountAssetsInformation(ctx echo.Context, address string, params model.AccountAssetsInformationParams) error {
 	if !v2.Node.Config().EnableExperimentalAPI {
 		return ctx.String(http.StatusNotFound, "/v2/accounts/{address}/assets was not enabled in the configuration file by setting the EnableExperimentalAPI to true")
 	}
 
 	addr, err := basics.UnmarshalChecksumAddress(address)
 	if err != nil {
 		return badRequest(ctx, err, errFailedToParseAddress, v2.Log)
 	}
 
 	var assetGreaterThan uint64 = 0
 	if params.Next != nil {
 		agt, err0 := strconv.ParseUint(*params.Next, 10, 64)
 		if err0 != nil {
 			return badRequest(ctx, err0, fmt.Sprintf("%s: %v", errUnableToParseNext, err0), v2.Log)
 		}
 		assetGreaterThan = agt
 	}
 
 	if params.Limit != nil {
 		if *params.Limit <= 0 {
 			return badRequest(ctx, errors.New(errInvalidLimit), errInvalidLimit, v2.Log)
 		}
 
 		if *params.Limit > MaxAssetResults {
 			limitErrMsg := fmt.Sprintf("limit %d exceeds max assets single batch limit %d", *params.Limit, MaxAssetResults)
 			return badRequest(ctx, errors.New(limitErrMsg), limitErrMsg, v2.Log)
 		}
 	} else {
 		// default limit
 		l := DefaultAssetResults
 		params.Limit = &l
 	}
 
 	ledger := v2.Node.LedgerForAPI()
 
 	// Logic
 	// 1. Get the account's asset holdings subject to limits
 	// 2. Handle empty response
 	// 3. Prepare JSON response
-	lastRound := ledger.Latest()
 
 	// We intentionally request one more than the limit to determine if there are more assets.
-	records, lookupRound, err := ledger.LookupAssets(lastRound, addr, basics.AssetIndex(assetGreaterThan), *params.Limit+1)
+	records, lookupRound, err := ledger.LookupAssets(addr, basics.AssetIndex(assetGreaterThan), *params.Limit+1)
 
 	if err != nil {
 		return internalError(ctx, err, errFailedLookingUpLedger, v2.Log)
 	}
 
 	// prepare JSON response
 	response := model.AccountAssetsInformationResponse{Round: uint64(lookupRound)}
 
 	// If the total count is greater than the limit, we set the next token to the last asset ID being returned
 	if uint64(len(records)) > *params.Limit {
 		// we do not include the last record in the response
 		records = records[:*params.Limit]
 		nextTk := strconv.FormatUint(uint64(records[len(records)-1].AssetID), 10)
 		response.NextToken = &nextTk
 	}
 
 	assetHoldings := make([]model.AccountAssetHolding, 0, len(records))
 
 	for _, record := range records {
 		if record.AssetHolding == nil {
 			v2.Log.Warnf("AccountAssetsInformation: asset %d has no holding - should not be possible", record.AssetID)
 			continue
 		}
 
 		aah := model.AccountAssetHolding{
 			AssetHolding: model.AssetHolding{
 				Amount:   record.AssetHolding.Amount,
 				AssetID:  uint64(record.AssetID),
 				IsFrozen: record.AssetHolding.Frozen,
 			},
 		}
 
 		if !record.Creator.IsZero() {
 			asset := AssetParamsToAsset(record.Creator.String(), record.AssetID, record.AssetParams)
 			aah.AssetParams = &asset.Params
 		}
 
 		assetHoldings = append(assetHoldings, aah)
 	}
 
 	response.AssetHoldings = &assetHoldings
 
 	return ctx.JSON(http.StatusOK, response)
 }
 
 // PreEncodedSimulateTxnResult mirrors model.SimulateTransactionResult

daemon/algod/api/server/v2/test/handlers_resources_test.go

@@ -109,10 +109,10 @@ func (l *mockLedger) LookupAsset(rnd basics.Round, addr basics.Address, aidx bas
 	return ar, nil
 }
 
-func (l *mockLedger) LookupAssets(rnd basics.Round, addr basics.Address, assetIDGT basics.AssetIndex, limit uint64) ([]ledgercore.AssetResourceWithIDs, basics.Round, error) {
+func (l *mockLedger) LookupAssets(addr basics.Address, assetIDGT basics.AssetIndex, limit uint64) ([]ledgercore.AssetResourceWithIDs, basics.Round, error) {
 	ad, ok := l.accounts[addr]
 	if !ok {
-		return nil, rnd, nil
+		return nil, basics.Round(0), nil
 	}
 
 	var res []ledgercore.AssetResourceWithIDs
@@ -132,7 +132,7 @@ func (l *mockLedger) LookupAssets(rnd basics.Round, addr basics.Address, assetID
 			res = append(res, apr)
 		}
 	}
-	return res, rnd, nil
+	return res, basics.Round(0), nil
 }
 
 func (l *mockLedger) LookupApplication(rnd basics.Round, addr basics.Address, aidx basics.AppIndex) (ar ledgercore.AppResource, err error) {
@@ -428,7 +428,6 @@ func accountInformationResourceLimitsTest(t *testing.T, accountMaker func(int) b
 
 func accountAssetInformationResourceLimitsTest(t *testing.T, handlers v2.Handlers, addr basics.Address,
 	acctData basics.AccountData, params model.AccountAssetsInformationParams, inputNextToken int, maxResults int, expectToken bool) {
-	fakeLatestRound := basics.Round(10)
 
 	ctx, rec := newReq(t)
 	err := handlers.AccountAssetsInformation(ctx, addr.String(), params)
@@ -437,7 +436,6 @@ func accountAssetInformationResourceLimitsTest(t *testing.T, handlers v2.Handler
 	var ret model.AccountAssetsInformationResponse
 	err = json.Unmarshal(rec.Body.Bytes(), &ret)
 	require.NoError(t, err)
-	assert.Equal(t, fakeLatestRound, basics.Round(ret.Round))
 
 	if expectToken {
 		nextRaw, err0 := strconv.ParseUint(*ret.NextToken, 10, 64)
@@ -477,43 +475,46 @@ func TestAccountAssetsInformation(t *testing.T) {
 	accountAssetInformationResourceLimitsTest(t, handlers, addr, acctData, model.AccountAssetsInformationParams{},
 		0, int(v2.DefaultAssetResults), false)
 
-	// 2. Query with limit<total resources, no next - should get the first (lowest asset id to highest) limit results back
 	rawLimit := 100
 	limit := uint64(rawLimit)
+	// 2. Query with limit<total resources, no next - should get the first (lowest asset id to highest) limit results back
 	accountAssetInformationResourceLimitsTest(t, handlers, addr, acctData,
 		model.AccountAssetsInformationParams{Limit: &limit}, 0, rawLimit, true)
 
-	// 3. Query with limit, next
-	rawNext := 100
-	nextTk := strconv.FormatUint(uint64(rawNext), 10)
-	accountAssetInformationResourceLimitsTest(t, handlers, addr, acctData,
-		model.AccountAssetsInformationParams{Limit: &limit, Next: &nextTk}, rawNext, rawLimit, true)
-
-	//4. Query with limit, next to retrieve final batch
-	rawNext = 1019
-	nextTk = strconv.FormatUint(uint64(rawNext), 10)
-	accountAssetInformationResourceLimitsTest(t, handlers, addr, acctData,
-		model.AccountAssetsInformationParams{Limit: &limit, Next: &nextTk}, rawNext, totalAssetHoldings-rawNext, false)
+	// 3. Loop through all assets in the account in batches of 100, ensure we get all assets back.
+	// Exercises limit and next combined.
+	for rawNext := 0; rawNext < totalAssetHoldings; rawNext += rawLimit {
+		nextTk := strconv.FormatUint(uint64(rawNext), 10)
+		// We expect a next token for all but the last batch
+		expectToken := true
+		expectedResultsCount := rawLimit
+		if rawNext+rawLimit >= totalAssetHoldings {
+			expectToken = false
+			expectedResultsCount = totalAssetHoldings - rawNext
+		}
+		accountAssetInformationResourceLimitsTest(t, handlers, addr, acctData,
+			model.AccountAssetsInformationParams{Limit: &limit, Next: &nextTk}, rawNext, expectedResultsCount, expectToken)
+	}
 
-	// 5. Query with limit, next to provide batch, but no data in that range
-	rawNext = 1025
-	nextTk = strconv.FormatUint(uint64(rawNext), 10)
+	// 4. Query with limit, next to provide batch, but no data in that range
+	rawNext := 1025
+	nextTk := strconv.FormatUint(uint64(rawNext), 10)
 	accountAssetInformationResourceLimitsTest(t, handlers, addr, acctData,
 		model.AccountAssetsInformationParams{Limit: &limit, Next: &nextTk}, rawNext, totalAssetHoldings-rawNext, false)
 
-	// 6. Malformed address
+	// 5. Malformed address
 	ctx, rec := newReq(t)
 	err := handlers.AccountAssetsInformation(ctx, "", model.AccountAssetsInformationParams{})
 	require.NoError(t, err)
 	require.Equal(t, 400, rec.Code)
 	require.Equal(t, "{\"message\":\"failed to parse the address\"}\n", rec.Body.String())
 
-	// 7. Unknown address (200 returned, just no asset data)
+	// 6. Unknown address (200 returned, just no asset data)
 	unknownAddress := basics.Address{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
 	accountAssetInformationResourceLimitsTest(t, handlers, unknownAddress, basics.AccountData{}, model.AccountAssetsInformationParams{},
 		0, 0, false)
 
-	// 8a. Invalid limits - larger than configured max
+	// 7a. Invalid limits - larger than configured max
 	ctx, rec = newReq(t)
 	err = handlers.AccountAssetsInformation(ctx, addr.String(), model.AccountAssetsInformationParams{
 		Limit: func() *uint64 {
@@ -525,7 +526,7 @@ func TestAccountAssetsInformation(t *testing.T) {
 	require.Equal(t, 400, rec.Code)
 	require.Equal(t, "{\"message\":\"limit 1001 exceeds max assets single batch limit 1000\"}\n", rec.Body.String())
 
-	// 8b. Invalid limits - zero
+	// 7b. Invalid limits - zero
 	ctx, rec = newReq(t)
 	err = handlers.AccountAssetsInformation(ctx, addr.String(), model.AccountAssetsInformationParams{
 		Limit: func() *uint64 {

ledger/acctupdates.go

@@ -341,8 +341,8 @@
 	return au.lookupResource(rnd, addr, aidx, ctype, true /* take lock */)
 }
 
-func (au *accountUpdates) LookupAssetResources(rnd basics.Round, addr basics.Address, assetIDGT basics.AssetIndex, limit uint64) ([]ledgercore.AssetResourceWithIDs, basics.Round, error) {
-	return au.lookupAssetResources(rnd, addr, assetIDGT, limit, true /* take lock */)
+func (au *accountUpdates) LookupAssetResources(addr basics.Address, assetIDGT basics.AssetIndex, limit uint64) ([]ledgercore.AssetResourceWithIDs, basics.Round, error) {
+	return au.lookupAssetResources(addr, assetIDGT, limit)
 }
 
 func (au *accountUpdates) LookupKv(rnd basics.Round, key string) ([]byte, error) {
@@ -1212,88 +1212,53 @@
 	}
 }
 
-func (au *accountUpdates) lookupAssetResources(rnd basics.Round, addr basics.Address, assetIDGT basics.AssetIndex, limit uint64, synchronized bool) (data []ledgercore.AssetResourceWithIDs, validThrough basics.Round, err error) {
-	needUnlock := false
-	if synchronized {
-		au.accountsMu.RLock()
-		needUnlock = true
+// lookupAllResources returns all the resources for a given address, solely based on what is persisted to disk. It does not
+// take into account any in-memory deltas; the round number returned is the latest round number that is known to the database.
+func (au *accountUpdates) lookupAssetResources(addr basics.Address, assetIDGT basics.AssetIndex, limit uint64) (data []ledgercore.AssetResourceWithIDs, validThrough basics.Round, err error) {
+	// Look for resources on disk
+	persistedResources, resourceDbRound, err0 := au.accountsq.LookupLimitedResources(addr, basics.CreatableIndex(assetIDGT), limit, basics.AssetCreatable)
+	if err0 != nil {
+		return nil, basics.Round(0), err0
 	}
-	defer func() {
-		if needUnlock {
-			au.accountsMu.RUnlock()
-		}
-	}()
-
-	for {
-		currentDbRound := au.cachedDBRound
-
-		// This checks that the specified round is >= au.cachedDBRound - if not, it will return an error.
-		_, err = au.roundOffset(rnd)
-		if err != nil {
-			return
-		}
-
-		if synchronized {
-			au.accountsMu.RUnlock()
-			needUnlock = false
-		}
-
-		// Look for resources on disk
-		persistedResources, resourceDbRound, err0 := au.accountsq.LookupLimitedResources(addr, basics.CreatableIndex(assetIDGT), limit, basics.AssetCreatable)
-		if err0 != nil {
-			return nil, basics.Round(0), err0
-		}
-
-		if resourceDbRound == currentDbRound || len(persistedResources) == 0 { // db round will return 0 in this case
-			data = make([]ledgercore.AssetResourceWithIDs, 0, len(persistedResources))
-			for _, pd := range persistedResources {
-				ah := pd.Data.GetAssetHolding()
-
-				var arwi ledgercore.AssetResourceWithIDs
-				if !pd.Creator.IsZero() {
-					ap := pd.Data.GetAssetParams()
 
-					arwi = ledgercore.AssetResourceWithIDs{
-						AssetID: basics.AssetIndex(pd.Aidx),
-						Creator: pd.Creator,
+	data = make([]ledgercore.AssetResourceWithIDs, 0, len(persistedResources))
+	for _, pd := range persistedResources {
+		ah := pd.Data.GetAssetHolding()
 
-						AssetResource: ledgercore.AssetResource{
-							AssetHolding: &ah,
-							AssetParams:  &ap,
-						},
-					}
-				} else {
-					arwi = ledgercore.AssetResourceWithIDs{
-						AssetID: basics.AssetIndex(pd.Aidx),
+		var arwi ledgercore.AssetResourceWithIDs
+		if !pd.Creator.IsZero() {
+			ap := pd.Data.GetAssetParams()
 
-						AssetResource: ledgercore.AssetResource{
-							AssetHolding: &ah,
-						},
-					}
-				}
+			arwi = ledgercore.AssetResourceWithIDs{
+				AssetID: basics.AssetIndex(pd.Aidx),
+				Creator: pd.Creator,
 
-				data = append(data, arwi)
+				AssetResource: ledgercore.AssetResource{
+					AssetHolding: &ah,
+					AssetParams:  &ap,
+				},
 			}
-			// We've found all the resources we could find for this address.
-			return data, currentDbRound, nil
-		}
+		} else {
+			arwi = ledgercore.AssetResourceWithIDs{
+				AssetID: basics.AssetIndex(pd.Aidx),
 
-		if synchronized {
-			if resourceDbRound < currentDbRound {
-				au.log.Errorf("accountUpdates.lookupAssetResources: resource database round %d is behind in-memory round %d", resourceDbRound, currentDbRound)
-				return nil, basics.Round(0), &StaleDatabaseRoundError{databaseRound: resourceDbRound, memoryRound: currentDbRound}
-			}
-			au.accountsMu.RLock()
-			needUnlock = true
-			for currentDbRound >= au.cachedDBRound {
-				au.accountsReadCond.Wait()
+				AssetResource: ledgercore.AssetResource{
+					AssetHolding: &ah,
+				},
 			}
-		} else {
-			// in non-sync mode, we don't wait since we already assume that we're synchronized.
-			au.log.Errorf("accountUpdates.lookupAssetResources: database round %d mismatching in-memory round %d", resourceDbRound, currentDbRound)
-			return nil, basics.Round(0), &MismatchingDatabaseRoundError{databaseRound: resourceDbRound, memoryRound: currentDbRound}
 		}
+
+		data = append(data, arwi)
+	}
+	// We've found all the resources we could find for this address.
+	currentDbRound := resourceDbRound
+	// The resourceDbRound will not be set if there are no persisted resources
+	if len(data) == 0 {
+		au.accountsMu.RLock()
+		currentDbRound = au.cachedDBRound
+		au.accountsMu.RUnlock()
 	}
+	return data, currentDbRound, nil
 }
 
 func (au *accountUpdates) lookupStateDelta(rnd basics.Round) (ledgercore.StateDelta, error) {

ledger/ledger.go

@@ -584,9 +584,9 @@
 }
 
 // LookupAssets loads asset resources that match the request parameters from the ledger.
-func (l *Ledger) LookupAssets(rnd basics.Round, addr basics.Address, assetIDGT basics.AssetIndex, limit uint64) ([]ledgercore.AssetResourceWithIDs, basics.Round, error) {
-	resources, lookupRound, err := l.accts.LookupAssetResources(rnd, addr, assetIDGT, limit)
+func (l *Ledger) LookupAssets(addr basics.Address, assetIDGT basics.AssetIndex, limit uint64) ([]ledgercore.AssetResourceWithIDs, basics.Round, error) {
+	resources, lookupRound, err := l.accts.LookupAssetResources(addr, assetIDGT, limit)
 	return resources, lookupRound, err
 }
 
 // lookupResource loads a resource that matches the request parameters from the accounts update

ledger/store/trackerdb/sqlitedriver/schema.go

@@ -948,77 +948,91 @@
 	var creatableTypeOnResourcesRun bool
 	err := e.QueryRow("SELECT 1 FROM pragma_table_info('resources') WHERE name='ctype'").Scan(&creatableTypeOnResourcesRun)
 	if err == nil {
-		// Already exists.
+		// Check if any ctypes are invalid
+		var count uint64
+		err0 := e.QueryRow("SELECT COUNT(*) FROM resources WHERE ctype NOT IN (0, 1)").Scan(&count)
+		if err0 != nil {
+			return err0
+		}
+		if count > 0 {
+			// Invalid ctypes found, return an error
+			return fmt.Errorf("invalid ctypes found in resources table; database is corrupted and needs to be rebuilt")
+		}
+		// Column exists, no ctypes are invalid, no migration needed so return clean
 		return nil
 	} else if !errors.Is(err, sql.ErrNoRows) {
 		return err
-	} // A sql.ErrNoRows error means the column does not exist, so we need to create it
+	} // A sql.ErrNoRows error means the column does not exist, so we need to create it/run the migration
+
+	// If we reached here, a sql.ErrNoRows error was returned, so we need to create the column
 
 	// Add ctype column
 	createStmt := `ALTER TABLE resources ADD COLUMN ctype INTEGER NOT NULL DEFAULT -1`
 
 	_, err = e.ExecContext(ctx, createStmt)
 	if err != nil {
 		return err
 	}
 
 	if populateColumn {
 		// Populate the new ctype column with the corresponding creatable type from assetcreators where available
 		updateStmt := `UPDATE resources SET ctype = (
     SELECT COALESCE((SELECT ac.ctype FROM assetcreators ac WHERE ac.asset = resources.aidx),-1)
 	) WHERE ctype = -1`
 
 		_, err0 := e.ExecContext(ctx, updateStmt)
 		if err0 != nil {
 			return err0
 		}
 
 		updatePrepStmt, err0 := e.PrepareContext(ctx, "UPDATE resources SET ctype = ? WHERE addrid = ? AND aidx = ?")
 		if err0 != nil {
 			return err0
 		}
 		defer updatePrepStmt.Close()
 
 		// Pull resource entries into memory where ctype is not set
 		rows, err0 := e.QueryContext(ctx, "SELECT addrid, aidx, data FROM resources r WHERE ctype = -1")
 		if err0 != nil {
 			return err0
 		}
 		defer rows.Close()
 
 		// Update the ctype column for subset of resources where ctype was not resolved from assetcreators
 		for rows.Next() {
 			var addrid int64
 			var aidx int64
 			var encodedData []byte
 			err0 = rows.Scan(&addrid, &aidx, &encodedData)
 			if err0 != nil {
 				return err0
 			}
 
 			var rd trackerdb.ResourcesData
 			err0 = protocol.Decode(encodedData, &rd)
 			if err0 != nil {
 				return err0
 			}
 
 			var ct basics.CreatableType
 			if rd.IsAsset() && rd.IsApp() {
 				// This should never happen!
 				return fmt.Errorf("unable to discern creatable type for addrid %d, resource %d", addrid, aidx)
 			} else if rd.IsAsset() {
 				ct = basics.AssetCreatable
 			} else if rd.IsApp() {
 				ct = basics.AppCreatable
 			} else { // This should never happen!
 				return fmt.Errorf("unable to discern creatable type for addrid %d, resource %d", addrid, aidx)
 			}
 
 			_, err0 = updatePrepStmt.ExecContext(ctx, ct, addrid, aidx)
 			if err0 != nil {
 				return err0
 			}
 		}
+
+		return rows.Err()
 	}
 
 	return nil

ledger/store/trackerdb/sqlitedriver/sql.go

@@ -87,10 +87,27 @@
 		return nil, err
 	}
 
-	qs.lookupLimitedResourcesStmt, err = q.Prepare("SELECT ab.rowid, ar.rnd, r.aidx, ac.creator, r.data, cr.data FROM acctrounds ar JOIN accountbase ab ON ab.address = ? JOIN resources r ON r.addrid = ab.addrid LEFT JOIN assetcreators ac ON r.aidx = ac.asset LEFT JOIN " +
-		"accountbase cab ON ac.creator = cab.address LEFT JOIN resources cr ON cr.addrid = cab.addrid AND cr.aidx = r.aidx WHERE ar.id = 'acctbase' AND r.ctype = ? AND r.aidx > ? ORDER BY r.aidx ASC LIMIT ?")
+	qs.lookupLimitedResourcesStmt, err = q.Prepare(
+		`SELECT ab.rowid,
+						ar.rnd,
+       					r.aidx,
+      	 				ac.creator,
+       					r.data,
+       					cr.data
+				FROM acctrounds ar
+				JOIN accountbase ab ON ab.address = ?
+				JOIN resources r ON r.addrid = ab.addrid
+				LEFT JOIN assetcreators ac ON r.aidx = ac.asset
+				LEFT JOIN accountbase cab ON ac.creator = cab.address
+				LEFT JOIN resources cr ON cr.addrid = cab.addrid
+				AND cr.aidx = r.aidx
+				WHERE ar.id = 'acctbase'
+  					AND r.ctype = ?
+  					AND r.aidx > ?
+				ORDER BY r.aidx ASC
+				LIMIT ?`)
 	if err != nil {
 		return nil, err
 	}
 
 	qs.lookupKvPairStmt, err = q.Prepare("SELECT acctrounds.rnd, kvstore.key, kvstore.value FROM acctrounds LEFT JOIN kvstore ON key = ? WHERE id='acctbase';")
@@ -174,7 +191,7 @@
 			return
 		}
 
 		w.insertResourceStmt, err = e.Prepare("INSERT INTO resources(addrid, aidx, data, ctype) VALUES(?, ?, ?, ?)")
 		if err != nil {
 			return
 		}
@@ -385,9 +402,9 @@
 func (qs *accountsDbQueries) LookupAllResources(addr basics.Address) (data []trackerdb.PersistedResourcesData, rnd basics.Round, err error) {
 	err = db.Retry(func() error {
 		// Query for all resources
 		rows, err0 := qs.lookupAllResourcesStmt.Query(addr[:])
 		if err0 != nil {
 			return err0
 		}
 		defer rows.Close()
 
@@ -396,7 +413,7 @@
 		data = nil
 		var buf []byte
 		for rows.Next() {
 			err = rows.Scan(&addrid, &dbRound, &aidx, &buf)
 			if err != nil {
 				return err
 			}
@@ -427,83 +444,87 @@
 	return
 }
 
 func (qs *accountsDbQueries) LookupLimitedResources(addr basics.Address, minIdx basics.CreatableIndex, maxCreatables uint64, ctype basics.CreatableType) (data []trackerdb.PersistedResourcesDataWithCreator, rnd basics.Round, err error) {
 	err = db.Retry(func() error {
 		rows, err0 := qs.lookupLimitedResourcesStmt.Query(addr[:], ctype, minIdx, maxCreatables)
 		if err0 != nil {
 			return err0
 		}
 		defer rows.Close()
 
 		var addrid, aidx sql.NullInt64
 		var dbRound basics.Round
 		data = nil
 		var actAssetBuf []byte
 		var crtAssetBuf []byte
 		var creatorAddrBuf []byte
 		for rows.Next() {
 			err = rows.Scan(&addrid, &dbRound, &aidx, &creatorAddrBuf, &actAssetBuf, &crtAssetBuf)
 			if err != nil {
 				return err
 			}
 			if !addrid.Valid || !aidx.Valid {
 				// we received an entry without any index. This would happen only on the first entry when there are no resources for this address.
 				// ensure this is the first entry, set the round and return
 				if len(data) != 0 {
 					return fmt.Errorf("LookupLimitedResources: unexpected invalid result on non-first resource record: (%v, %v)", addrid.Valid, aidx.Valid)
 				}
 				rnd = dbRound
 				break
 			}
 			var actResData trackerdb.ResourcesData
 			var crtResData trackerdb.ResourcesData
 			err = protocol.Decode(actAssetBuf, &actResData)
 			if err != nil {
 				return err
 			}
 
 			var prdwc trackerdb.PersistedResourcesDataWithCreator
 			if len(crtAssetBuf) > 0 {
 				err = protocol.Decode(crtAssetBuf, &crtResData)
 				if err != nil {
 					return err
 				}
 
-				// Update asset holding data in the creator resource data
+				// Since there is a creator, we want to return all of the asset params along with the asset holdings.
+				// The most simple way to do this is to set the necessary asset holding data on the creator resource data
+				// retrieved from the database. Note that this is unique way of setting resource flags, making this structure
+				// not suitable for use in other contexts (where the params would only be present colocated with the asset holding
+				// of the creator).
 				crtResData.Amount = actResData.Amount
-				crtResData.Freeze = actResData.Freeze
+				crtResData.Frozen = actResData.Frozen
 				crtResData.ResourceFlags = actResData.ResourceFlags
 
 				creatorAddr := basics.Address{}
 				copy(creatorAddr[:], creatorAddrBuf)
 
 				prdwc = trackerdb.PersistedResourcesDataWithCreator{
 					PersistedResourcesData: trackerdb.PersistedResourcesData{
 						AcctRef: sqlRowRef{addrid.Int64},
 						Aidx:    basics.CreatableIndex(aidx.Int64),
 						Data:    crtResData,
 						Round:   dbRound,
 					},
 					Creator: creatorAddr,
 				}
 			} else { // no creator found, asset was likely deleted, will not have asset params
 				prdwc = trackerdb.PersistedResourcesDataWithCreator{
 					PersistedResourcesData: trackerdb.PersistedResourcesData{
 						AcctRef: sqlRowRef{addrid.Int64},
 						Aidx:    basics.CreatableIndex(aidx.Int64),
 						Data:    actResData,
 						Round:   dbRound,
 					},
 				}
 			}
 
 			data = append(data, prdwc)
 
 			rnd = dbRound
 		}
 		return nil
 	})
 	return
 }
 
 // LookupAccount looks up for a the account data given it's address. It returns the persistedAccountData, which includes the current database round and the matching
@@ -719,17 +740,17 @@
 		return nil, fmt.Errorf("no account could be found for rowid = nil: %w", err)
 	}
 	addrid := accountRef.(sqlRowRef).rowid
 	var ctype basics.CreatableType
 	if data.IsAsset() && data.IsApp() {
 		return nil, fmt.Errorf("unable to resolve single creatable type for account ref %d, creatable idx %d", addrid, aidx)
 	} else if data.IsAsset() {
 		ctype = basics.AssetCreatable
 	} else if data.IsApp() {
 		ctype = basics.AppCreatable
 	} else {
 		return nil, fmt.Errorf("unable to resolve creatable type for account ref %d, creatable idx %d", addrid, aidx)
 	}
 	result, err := w.insertResourceStmt.Exec(addrid, aidx, protocol.Encode(&data), ctype)
 	if err != nil {
 		return
 	}