From c7d39fbaec1999fec71cadb092bc4d0fa52be0bb Mon Sep 17 00:00:00 2001
From: Zeph Grunschlag <tzaffi@users.noreply.github.com>
Date: Wed, 16 Feb 2022 11:59:06 -0600
Subject: [PATCH 01/29] Use fetch/reset instead of pull for go-algorand in
 nightly test. (#885)

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index ddd15a9df..92585f6e9 100644
--- a/Makefile
+++ b/Makefile
@@ -75,7 +75,7 @@ test-generate:
 	test/test_generate.py
 
 nightly-setup:
-	cd third_party/go-algorand && git pull origin master
+	cd third_party/go-algorand && git fetch && git reset --hard origin/master
 
 nightly-teardown:
 	git submodule update

From 3cafaad3c2c61e3e9d6e8686738d462f40b10418 Mon Sep 17 00:00:00 2001
From: AlgoStephenAkiki <85183435+AlgoStephenAkiki@users.noreply.github.com>
Date: Wed, 16 Feb 2022 14:39:33 -0500
Subject: [PATCH 02/29] Configurable query parameters runtime data structures.
 (#873)

---
 api/disabled_parameters.go      | 149 +++++++++++++++++++++++++++++
 api/disabled_parameters_test.go | 163 ++++++++++++++++++++++++++++++++
 api/handlers.go                 |  55 +++++++++++
 api/server.go                   |   7 ++
 4 files changed, 374 insertions(+)
 create mode 100644 api/disabled_parameters.go
 create mode 100644 api/disabled_parameters_test.go

diff --git a/api/disabled_parameters.go b/api/disabled_parameters.go
new file mode 100644
index 000000000..3a2d0c4c0
--- /dev/null
+++ b/api/disabled_parameters.go
@@ -0,0 +1,149 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/getkin/kin-openapi/openapi3"
+	"github.com/labstack/echo/v4"
+)
+
+// EndpointConfig is a data structure that contains whether the
+// endpoint is disabled (with a boolean) as well as a set that
+// contains disabled optional parameters.  The disabled optional parameter
+// set is keyed by the name of the variable
+type EndpointConfig struct {
+	EndpointDisabled           bool
+	DisabledOptionalParameters map[string]bool
+}
+
+// NewEndpointConfig creates a new empty endpoint config
+func NewEndpointConfig() *EndpointConfig {
+	rval := &EndpointConfig{
+		EndpointDisabled:           false,
+		DisabledOptionalParameters: make(map[string]bool),
+	}
+
+	return rval
+}
+
+// DisabledMap a type that holds a map of disabled types
+// The key for a disabled map is the handler function name
+type DisabledMap struct {
+	Data map[string]*EndpointConfig
+}
+
+// NewDisabledMap creates a new empty disabled map
+func NewDisabledMap() *DisabledMap {
+	return &DisabledMap{
+		Data: make(map[string]*EndpointConfig),
+	}
+}
+
+// NewDisabledMapFromOA3 Creates a new disabled map from an openapi3 definition
+func NewDisabledMapFromOA3(swag *openapi3.Swagger) *DisabledMap {
+	rval := NewDisabledMap()
+	for _, item := range swag.Paths {
+		for _, opItem := range item.Operations() {
+
+			endpointConfig := NewEndpointConfig()
+
+			for _, pref := range opItem.Parameters {
+
+				// TODO how to enable it to be disabled
+				parameterIsDisabled := false
+				if !parameterIsDisabled {
+					// If the parameter is not disabled, then we don't need
+					// to do anything
+					continue
+				}
+
+				if pref.Value.Required {
+					// If an endpoint config required parameter is disabled, then the whole endpoint is disabled
+					endpointConfig.EndpointDisabled = true
+				} else {
+					// If the optional parameter is disabled, add it to the map
+					endpointConfig.DisabledOptionalParameters[pref.Value.Name] = true
+				}
+			}
+
+			rval.Data[opItem.OperationID] = endpointConfig
+
+		}
+
+	}
+
+	return rval
+}
+
+// ErrVerifyFailedEndpoint an error that signifies that the entire endpoint is disabled
+var ErrVerifyFailedEndpoint error = fmt.Errorf("endpoint is disabled")
+
+// ErrVerifyFailedParameter an error that signifies that a parameter was provided when it was disabled
+type ErrVerifyFailedParameter struct {
+	ParameterName string
+}
+
+func (evfp ErrVerifyFailedParameter) Error() string {
+	return fmt.Sprintf("provided disabled parameter: %s", evfp.ParameterName)
+}
+
+// DisabledParameterErrorReporter defines an error reporting interface
+// for the Verify functions
+type DisabledParameterErrorReporter interface {
+	Errorf(format string, args ...interface{})
+}
+
+// Verify returns nil if the function can continue (i.e. the parameters are valid and disabled
+// parameters are not supplied), otherwise VerifyFailedEndpoint if the endpoint failed and
+// VerifyFailedParameter if a disabled parameter was provided.
+func Verify(dm *DisabledMap, nameOfHandlerFunc string, ctx echo.Context, log DisabledParameterErrorReporter) error {
+
+	if dm == nil || dm.Data == nil {
+		return nil
+	}
+
+	if val, ok := dm.Data[nameOfHandlerFunc]; ok {
+		return val.verify(ctx, log)
+	}
+
+	// If the function name wasn't in the map something got messed up....
+	log.Errorf("verify function could not find name of handler function in map: %s", nameOfHandlerFunc)
+	// We want to fail-safe to not stop the indexer
+	return nil
+}
+
+func (ec *EndpointConfig) verify(ctx echo.Context, log DisabledParameterErrorReporter) error {
+
+	if ec.EndpointDisabled {
+		return ErrVerifyFailedEndpoint
+	}
+
+	queryParams := ctx.QueryParams()
+	formParams, formErr := ctx.FormParams()
+
+	if formErr != nil {
+		log.Errorf("retrieving form parameters for verification resulted in an error: %v", formErr)
+	}
+
+	for paramName := range ec.DisabledOptionalParameters {
+
+		// The optional param is disabled, check that it wasn't supplied...
+		queryValue := queryParams.Get(paramName)
+		if queryValue != "" {
+			// If the query value is non-zero, and it was disabled, we should return false
+			return ErrVerifyFailedParameter{paramName}
+		}
+
+		if formErr != nil {
+			continue
+		}
+
+		formValue := formParams.Get(paramName)
+		if formValue != "" {
+			// If the query value is non-zero, and it was disabled, we should return false
+			return ErrVerifyFailedParameter{paramName}
+		}
+	}
+
+	return nil
+}
diff --git a/api/disabled_parameters_test.go b/api/disabled_parameters_test.go
new file mode 100644
index 000000000..2e76391e8
--- /dev/null
+++ b/api/disabled_parameters_test.go
@@ -0,0 +1,163 @@
+package api
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/labstack/echo/v4"
+	"github.com/sirupsen/logrus/hooks/test"
+	"github.com/stretchr/testify/require"
+)
+
+// TestFailingParam tests that disabled parameters provided via
+// the FormParams() and QueryParams() functions of the context are appropriately handled
+func TestFailingParam(t *testing.T) {
+	type testingStruct struct {
+		name               string
+		setFormValues      func(*url.Values)
+		expectedError      error
+		expectedErrorCount int
+		mimeType           string
+	}
+	tests := []testingStruct{
+		{
+			"non-disabled param provided",
+			func(f *url.Values) {
+				f.Set("3", "Provided")
+			}, nil, 0, echo.MIMEApplicationForm,
+		},
+		{
+			"disabled param provided but empty",
+			func(f *url.Values) {
+				f.Set("1", "")
+			}, nil, 0, echo.MIMEApplicationForm,
+		},
+		{
+			"disabled param provided",
+			func(f *url.Values) {
+				f.Set("1", "Provided")
+			}, ErrVerifyFailedParameter{"1"}, 0, echo.MIMEApplicationForm,
+		},
+	}
+
+	testsPostOnly := []testingStruct{
+		{
+			"Error encountered for Form Params",
+			func(f *url.Values) {
+				f.Set("1", "Provided")
+			}, nil, 1, echo.MIMEMultipartForm,
+		},
+	}
+
+	ctxFactoryGet := func(e *echo.Echo, f *url.Values, t *testingStruct) *echo.Context {
+		req := httptest.NewRequest(http.MethodGet, "/?"+f.Encode(), nil)
+		ctx := e.NewContext(req, nil)
+		return &ctx
+	}
+
+	ctxFactoryPost := func(e *echo.Echo, f *url.Values, t *testingStruct) *echo.Context {
+		req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(f.Encode()))
+		req.Header.Add(echo.HeaderContentType, t.mimeType)
+		ctx := e.NewContext(req, nil)
+		return &ctx
+	}
+
+	runner := func(t *testing.T, tstruct *testingStruct, ctxFactory func(*echo.Echo, *url.Values, *testingStruct) *echo.Context) {
+		dm := NewDisabledMap()
+		e1 := NewEndpointConfig()
+		e1.EndpointDisabled = false
+		e1.DisabledOptionalParameters["1"] = true
+
+		dm.Data["K1"] = e1
+
+		e := echo.New()
+
+		f := make(url.Values)
+		tstruct.setFormValues(&f)
+
+		ctx := ctxFactory(e, &f, tstruct)
+
+		logger, hook := test.NewNullLogger()
+
+		err := Verify(dm, "K1", *ctx, logger)
+
+		require.Equal(t, tstruct.expectedError, err)
+		require.Len(t, hook.AllEntries(), tstruct.expectedErrorCount)
+	}
+
+	for _, test := range tests {
+		t.Run("Post-"+test.name, func(t *testing.T) {
+			runner(t, &test, ctxFactoryPost)
+		})
+
+		t.Run("Get-"+test.name, func(t *testing.T) {
+			runner(t, &test, ctxFactoryGet)
+		})
+
+	}
+
+	for _, test := range testsPostOnly {
+		t.Run("Post-"+test.name, func(t *testing.T) {
+			runner(t, &test, ctxFactoryPost)
+		})
+
+	}
+}
+
+// TestFailingEndpoint tests that an endpoint which has a disabled required parameter
+// returns a failed endpoint error
+func TestFailingEndpoint(t *testing.T) {
+	dm := NewDisabledMap()
+
+	e1 := NewEndpointConfig()
+	e1.EndpointDisabled = true
+	e1.DisabledOptionalParameters["1"] = true
+
+	dm.Data["K1"] = e1
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/?", nil)
+	ctx := e.NewContext(req, nil)
+
+	logger, hook := test.NewNullLogger()
+
+	err := Verify(dm, "K1", ctx, logger)
+
+	require.Equal(t, ErrVerifyFailedEndpoint, err)
+
+	require.Len(t, hook.AllEntries(), 0)
+}
+
+// TestVerifyNonExistentHandler tests that nonexistent endpoint is logged
+// but doesn't stop the indexer from functioning
+func TestVerifyNonExistentHandler(t *testing.T) {
+	dm := NewDisabledMap()
+
+	e1 := NewEndpointConfig()
+	e1.EndpointDisabled = false
+	e1.DisabledOptionalParameters["1"] = true
+
+	dm.Data["K1"] = e1
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/?", nil)
+	ctx := e.NewContext(req, nil)
+
+	logger, hook := test.NewNullLogger()
+
+	err := Verify(dm, "DoesntExist", ctx, logger)
+
+	require.Equal(t, nil, err)
+	require.Len(t, hook.AllEntries(), 1)
+
+	hook.Reset()
+
+	err = Verify(dm, "K1", ctx, logger)
+
+	require.Equal(t, nil, err)
+
+	require.Len(t, hook.AllEntries(), 0)
+}
diff --git a/api/handlers.go b/api/handlers.go
index 0bd7795b2..0137e68e0 100644
--- a/api/handlers.go
+++ b/api/handlers.go
@@ -38,6 +38,8 @@ type ServerImplementation struct {
 	timeout time.Duration
 
 	log *log.Logger
+
+	disabledParams *DisabledMap
 }
 
 /////////////////////
@@ -145,9 +147,17 @@ func (si *ServerImplementation) MakeHealthCheck(ctx echo.Context) error {
 	})
 }
 
+func (si *ServerImplementation) verifyHandler(operationID string, ctx echo.Context) error {
+	return Verify(si.disabledParams, operationID, ctx, si.log)
+}
+
 // LookupAccountByID queries indexer for a given account.
 // (GET /v2/accounts/{account-id})
 func (si *ServerImplementation) LookupAccountByID(ctx echo.Context, accountID string, params generated.LookupAccountByIDParams) error {
+	if err := si.verifyHandler("LookupAccountByID", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
 	addr, errors := decodeAddress(&accountID, "account-id", make([]string, 0))
 	if len(errors) != 0 {
 		return badRequest(ctx, errors[0])
@@ -183,6 +193,10 @@ func (si *ServerImplementation) LookupAccountByID(ctx echo.Context, accountID st
 // SearchForAccounts returns accounts matching the provided parameters
 // (GET /v2/accounts)
 func (si *ServerImplementation) SearchForAccounts(ctx echo.Context, params generated.SearchForAccountsParams) error {
+	if err := si.verifyHandler("SearchForAccounts", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
 	if !si.EnableAddressSearchRoundRewind && params.Round != nil {
 		return badRequest(ctx, errMultiAcctRewind)
 	}
@@ -242,6 +256,9 @@ func (si *ServerImplementation) SearchForAccounts(ctx echo.Context, params gener
 // LookupAccountTransactions looks up transactions associated with a particular account.
 // (GET /v2/accounts/{account-id}/transactions)
 func (si *ServerImplementation) LookupAccountTransactions(ctx echo.Context, accountID string, params generated.LookupAccountTransactionsParams) error {
+	if err := si.verifyHandler("LookupAccountTransactions", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
 	// Check that a valid account was provided
 	_, errors := decodeAddress(strPtr(accountID), "account-id", make([]string, 0))
 	if len(errors) != 0 {
@@ -277,6 +294,9 @@ func (si *ServerImplementation) LookupAccountTransactions(ctx echo.Context, acco
 // SearchForApplications returns applications for the provided parameters.
 // (GET /v2/applications)
 func (si *ServerImplementation) SearchForApplications(ctx echo.Context, params generated.SearchForApplicationsParams) error {
+	if err := si.verifyHandler("SearchForApplications", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
 	apps, round, err := si.fetchApplications(ctx.Request().Context(), params)
 	if err != nil {
 		return indexerError(ctx, fmt.Errorf("%s: %w", errFailedSearchingApplication, err))
@@ -298,6 +318,9 @@ func (si *ServerImplementation) SearchForApplications(ctx echo.Context, params g
 // LookupApplicationByID returns one application for the requested ID.
 // (GET /v2/applications/{application-id})
 func (si *ServerImplementation) LookupApplicationByID(ctx echo.Context, applicationID uint64, params generated.LookupApplicationByIDParams) error {
+	if err := si.verifyHandler("LookupApplicationByID", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
 	p := generated.SearchForApplicationsParams{
 		ApplicationId: &applicationID,
 		IncludeAll:    params.IncludeAll,
@@ -326,6 +349,10 @@ func (si *ServerImplementation) LookupApplicationByID(ctx echo.Context, applicat
 // LookupApplicationLogsByID returns one application logs
 // (GET /v2/applications/{application-id}/logs)
 func (si *ServerImplementation) LookupApplicationLogsByID(ctx echo.Context, applicationID uint64, params generated.LookupApplicationLogsByIDParams) error {
+	if err := si.verifyHandler("LookupApplicationLogsByID", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
 	searchParams := generated.SearchForTransactionsParams{
 		AssetId:       nil,
 		ApplicationId: uint64Ptr(applicationID),
@@ -385,6 +412,10 @@ func (si *ServerImplementation) LookupApplicationLogsByID(ctx echo.Context, appl
 // LookupAssetByID looks up a particular asset
 // (GET /v2/assets/{asset-id})
 func (si *ServerImplementation) LookupAssetByID(ctx echo.Context, assetID uint64, params generated.LookupAssetByIDParams) error {
+	if err := si.verifyHandler("LookupAssetByID", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
 	search := generated.SearchForAssetsParams{
 		AssetId:    uint64Ptr(assetID),
 		Limit:      uint64Ptr(1),
@@ -417,6 +448,10 @@ func (si *ServerImplementation) LookupAssetByID(ctx echo.Context, assetID uint64
 // LookupAssetBalances looks up balances for a particular asset
 // (GET /v2/assets/{asset-id}/balances)
 func (si *ServerImplementation) LookupAssetBalances(ctx echo.Context, assetID uint64, params generated.LookupAssetBalancesParams) error {
+	if err := si.verifyHandler("LookupAssetBalances", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
 	query := idb.AssetBalanceQuery{
 		AssetID:        assetID,
 		AmountGT:       params.CurrencyGreaterThan,
@@ -453,6 +488,10 @@ func (si *ServerImplementation) LookupAssetBalances(ctx echo.Context, assetID ui
 // LookupAssetTransactions looks up transactions associated with a particular asset
 // (GET /v2/assets/{asset-id}/transactions)
 func (si *ServerImplementation) LookupAssetTransactions(ctx echo.Context, assetID uint64, params generated.LookupAssetTransactionsParams) error {
+	if err := si.verifyHandler("LookupAssetTransactions", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
 	searchParams := generated.SearchForTransactionsParams{
 		AssetId:             uint64Ptr(assetID),
 		ApplicationId:       nil,
@@ -481,6 +520,10 @@ func (si *ServerImplementation) LookupAssetTransactions(ctx echo.Context, assetI
 // SearchForAssets returns assets matching the provided parameters
 // (GET /v2/assets)
 func (si *ServerImplementation) SearchForAssets(ctx echo.Context, params generated.SearchForAssetsParams) error {
+	if err := si.verifyHandler("SearchForAssets", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
 	options, err := assetParamsToAssetQuery(params)
 	if err != nil {
 		return badRequest(ctx, err.Error())
@@ -506,6 +549,10 @@ func (si *ServerImplementation) SearchForAssets(ctx echo.Context, params generat
 // LookupBlock returns the block for a given round number
 // (GET /v2/blocks/{round-number})
 func (si *ServerImplementation) LookupBlock(ctx echo.Context, roundNumber uint64) error {
+	if err := si.verifyHandler("LookupBlock", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
 	blk, err := si.fetchBlock(ctx.Request().Context(), roundNumber)
 	if errors.Is(err, idb.ErrorBlockNotFound) {
 		return notFound(ctx, fmt.Sprintf("%s '%d': %v", errLookingUpBlockForRound, roundNumber, err))
@@ -519,6 +566,10 @@ func (si *ServerImplementation) LookupBlock(ctx echo.Context, roundNumber uint64
 
 // LookupTransaction searches for the requested transaction ID.
 func (si *ServerImplementation) LookupTransaction(ctx echo.Context, txid string) error {
+	if err := si.verifyHandler("LookupTransaction", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
 	filter, err := transactionParamsToTransactionFilter(generated.SearchForTransactionsParams{
 		Txid: strPtr(txid),
 	})
@@ -556,6 +607,10 @@ func (si *ServerImplementation) LookupTransaction(ctx echo.Context, txid string)
 // SearchForTransactions returns transactions matching the provided parameters
 // (GET /v2/transactions)
 func (si *ServerImplementation) SearchForTransactions(ctx echo.Context, params generated.SearchForTransactionsParams) error {
+	if err := si.verifyHandler("SearchForTransactions", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
 	filter, err := transactionParamsToTransactionFilter(params)
 	if err != nil {
 		return badRequest(ctx, err.Error())
diff --git a/api/server.go b/api/server.go
index 286054c85..8fcef2b0a 100644
--- a/api/server.go
+++ b/api/server.go
@@ -77,12 +77,19 @@ func Serve(ctx context.Context, serveAddr string, db idb.IndexerDb, fetcherError
 		middleware = append(middleware, middlewares.MakeAuth("X-Indexer-API-Token", options.Tokens))
 	}
 
+	swag, err := generated.GetSwagger()
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	api := ServerImplementation{
 		EnableAddressSearchRoundRewind: options.DeveloperMode,
 		db:                             db,
 		fetcher:                        fetcherError,
 		timeout:                        options.handlerTimeout(),
 		log:                            log,
+		disabledParams:                 NewDisabledMapFromOA3(swag),
 	}
 
 	generated.RegisterHandlers(e, &api, middleware...)

From 860ed098a61f39ab1e9f10a128a812205d93d048 Mon Sep 17 00:00:00 2001
From: Michael Diamant <michaeldiamant@users.noreply.github.com>
Date: Fri, 18 Feb 2022 12:36:57 -0500
Subject: [PATCH 03/29] Default to including Python go-algorand E2E tests in
 buildtestdata.sh (#888)

Default to including Python go-algorand E2E tests in `buildtestdata.sh.`

* Prior to the PR, `buildtestdata.sh` did not include go-algorand E2E tests. The PR closes the test coverage gap.
* Additionally, exposes an environment variable to simplify user control of included tests. The exposed configuration improves workflows for local testing on select tests.
---
 misc/buildtestdata.sh | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/misc/buildtestdata.sh b/misc/buildtestdata.sh
index 263b7e4d6..0a5d1cf76 100755
--- a/misc/buildtestdata.sh
+++ b/misc/buildtestdata.sh
@@ -33,13 +33,18 @@ if [ -z "${E2EDATA}" ]; then
     E2EDATA="${HOME}/Algorand/e2edata"
 fi
 
+tests="${INDEXER_BTD_TESTS:-"test/scripts/e2e_subs/{*.py,*.sh}"}"
+echo "Configured tests = ${tests}"
+
 # TODO: EXPERIMENTAL
 # run faster rounds? 1000 down from 2000
 export ALGOSMALLLAMBDAMSEC=1000
 
 rm -rf "${E2EDATA}"
 mkdir -p "${E2EDATA}"
-(cd "${GOALGORAND}" && TEMPDIR="${E2EDATA}" python3 test/scripts/e2e_client_runner.py --keep-temps test/scripts/e2e_subs/*.sh)
+(cd "${GOALGORAND}" && \
+  TEMPDIR="${E2EDATA}" \
+  python3 test/scripts/e2e_client_runner.py --keep-temps "$tests")
 
 (cd "${E2EDATA}" && tar -j -c -f net_done.tar.bz2 --exclude node.log --exclude agreement.cdv net)
 
@@ -47,4 +52,4 @@ mkdir -p "${E2EDATA}"
 RSTAMP=$(TZ=UTC python -c 'import time; print("{:08x}".format(0xffffffff - int(time.time() - time.mktime((2020,1,1,0,0,0,-1,-1,-1)))))')
 
 echo "COPY AND PASTE THIS TO UPLOAD:"
-echo aws s3 cp --acl public-read "${E2EDATA}/net_done.tar.bz2" s3://algorand-testdata/indexer/e2e3/${RSTAMP}/net_done.tar.bz2
+echo aws s3 cp --acl public-read "${E2EDATA}/net_done.tar.bz2" s3://algorand-testdata/indexer/e2e3/"${RSTAMP}"/net_done.tar.bz2

From 6b0ebfdccf74606cb7433d073ee806a07aea90d4 Mon Sep 17 00:00:00 2001
From: Michael Diamant <michaeldiamant@users.noreply.github.com>
Date: Fri, 18 Feb 2022 15:59:31 -0500
Subject: [PATCH 04/29] Temporarily revert to inline glob search (#889)

https://github.com/algorand/indexer/pull/888 introduces a bug due to bash's ordering of brace and parameter expansion.  The commit supports parameter expansion at the expense of dropping the environment variable.

I'll restore external configuration in a subsequent PR.
---
 misc/buildtestdata.sh | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/misc/buildtestdata.sh b/misc/buildtestdata.sh
index 0a5d1cf76..cb1655d9f 100755
--- a/misc/buildtestdata.sh
+++ b/misc/buildtestdata.sh
@@ -33,9 +33,6 @@ if [ -z "${E2EDATA}" ]; then
     E2EDATA="${HOME}/Algorand/e2edata"
 fi
 
-tests="${INDEXER_BTD_TESTS:-"test/scripts/e2e_subs/{*.py,*.sh}"}"
-echo "Configured tests = ${tests}"
-
 # TODO: EXPERIMENTAL
 # run faster rounds? 1000 down from 2000
 export ALGOSMALLLAMBDAMSEC=1000
@@ -44,7 +41,7 @@ rm -rf "${E2EDATA}"
 mkdir -p "${E2EDATA}"
 (cd "${GOALGORAND}" && \
   TEMPDIR="${E2EDATA}" \
-  python3 test/scripts/e2e_client_runner.py --keep-temps "$tests")
+  python3 test/scripts/e2e_client_runner.py --keep-temps test/scripts/e2e_subs/{*.py,*.sh})
 
 (cd "${E2EDATA}" && tar -j -c -f net_done.tar.bz2 --exclude node.log --exclude agreement.cdv net)
 

From e3ebf75a2a50e90f581ac84840a84fe78e2e4b5f Mon Sep 17 00:00:00 2001
From: Will Winder <wwinder.unh@gmail.com>
Date: Thu, 24 Feb 2022 06:45:54 -0500
Subject: [PATCH 05/29] Ensure query is canceled after account rewind. (#893)

---
 .circleci/config.yml      |  8 ++++++--
 accounting/rewind.go      | 11 ++++++++++-
 accounting/rewind_test.go |  6 ++++--
 api/handlers.go           |  6 ++++++
 4 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 2f3b07ea8..c4a692dfa 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -104,7 +104,9 @@ commands:
       - run: make lint
       - run: make check
       - run: make integration
-      - run: make test
+      - run:
+          command: make test
+          no_output_timeout: 15m
       - run: make test-generate
       - run: make fakepackage
       - run: make e2e
@@ -115,7 +117,9 @@ commands:
       - run: make lint
       - run: make check
       - run: make integration
-      - run: make test
+      - run:
+          command: make test
+          no_output_timeout: 15m
       - run: make test-generate
       - run: make fakepackage
       - run: make e2e
diff --git a/accounting/rewind.go b/accounting/rewind.go
index 82dabb110..dfa1290e0 100644
--- a/accounting/rewind.go
+++ b/accounting/rewind.go
@@ -99,7 +99,16 @@ func AccountAtRound(ctx context.Context, account models.Account, round uint64, d
 		MinRound: round + 1,
 		MaxRound: account.Round,
 	}
-	txns, r := db.Transactions(ctx, tf)
+	ctx2, cf := context.WithCancel(ctx)
+	// In case of a panic before the next defer, call cf() here.
+	defer cf()
+	txns, r := db.Transactions(ctx2, tf)
+	// In case of an error, make sure the context is cancelled, and the channel is cleaned up.
+	defer func() {
+		cf()
+		for range txns {
+		}
+	}()
 	if r < account.Round {
 		err = ConsistencyError{fmt.Sprintf("queried round r: %d < account.Round: %d", r, account.Round)}
 		return
diff --git a/accounting/rewind_test.go b/accounting/rewind_test.go
index 00bd796cf..dbd79ed3b 100644
--- a/accounting/rewind_test.go
+++ b/accounting/rewind_test.go
@@ -67,10 +67,12 @@ func TestStaleTransactions1(t *testing.T) {
 		Round:   8,
 	}
 
-	var outCh <-chan idb.TxnRow
+	ch := make(chan idb.TxnRow)
+	var outCh <-chan idb.TxnRow = ch
+	close(ch)
 
 	db := &mocks.IndexerDb{}
-	db.On("GetSpecialAccounts").Return(transactions.SpecialAddresses{}, nil)
+	db.On("GetSpecialAccounts", mock.Anything).Return(transactions.SpecialAddresses{}, nil)
 	db.On("Transactions", mock.Anything, mock.Anything).Return(outCh, uint64(7)).Once()
 
 	account, err := AccountAtRound(context.Background(), account, 6, db)
diff --git a/api/handlers.go b/api/handlers.go
index 0137e68e0..ad2d07903 100644
--- a/api/handlers.go
+++ b/api/handlers.go
@@ -879,6 +879,12 @@ func (si *ServerImplementation) fetchAccounts(ctx context.Context, options idb.A
 		var accountchan <-chan idb.AccountRow
 		accountchan, round = si.db.GetAccounts(ctx, options)
 
+		// Make sure accountchan is empty at the end of processing.
+		defer func() {
+			for range accountchan {
+			}
+		}()
+
 		if (atRound != nil) && (*atRound > round) {
 			return fmt.Errorf("%s: the requested round %d > the current round %d",
 				errRewindingAccount, *atRound, round)

From 0b6d8142b4726aa78f66cc2611022ef0c531765e Mon Sep 17 00:00:00 2001
From: Jack Smith <jack.smith@algorand.com>
Date: Thu, 24 Feb 2022 07:54:17 -0500
Subject: [PATCH 06/29] Version bump

---
 .version                | 2 +-
 third_party/go-algorand | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.version b/.version
index 2701a226a..c8e38b614 100644
--- a/.version
+++ b/.version
@@ -1 +1 @@
-2.8.4
+2.9.0
diff --git a/third_party/go-algorand b/third_party/go-algorand
index f880d8f7a..d2289a52d 160000
--- a/third_party/go-algorand
+++ b/third_party/go-algorand
@@ -1 +1 @@
-Subproject commit f880d8f7a88fb96e735838423c03665fda7019f8
+Subproject commit d2289a52d517b1e7e0a23b6936305520895d36d5

From ec1ef099cfdb02d0f259884fbbdd546bf1fc55a6 Mon Sep 17 00:00:00 2001
From: Jack Smith <jack.smith@algorand.com>
Date: Thu, 24 Feb 2022 07:55:55 -0500
Subject: [PATCH 07/29] Revert "Version bump"

This reverts commit 0b6d8142b4726aa78f66cc2611022ef0c531765e.
---
 .version                | 2 +-
 third_party/go-algorand | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.version b/.version
index c8e38b614..2701a226a 100644
--- a/.version
+++ b/.version
@@ -1 +1 @@
-2.9.0
+2.8.4
diff --git a/third_party/go-algorand b/third_party/go-algorand
index d2289a52d..f880d8f7a 160000
--- a/third_party/go-algorand
+++ b/third_party/go-algorand
@@ -1 +1 @@
-Subproject commit d2289a52d517b1e7e0a23b6936305520895d36d5
+Subproject commit f880d8f7a88fb96e735838423c03665fda7019f8

From a45137176b73aa10660a12faa0ef12a8c43d1b51 Mon Sep 17 00:00:00 2001
From: Jack Smith <jack.smith@algorand.com>
Date: Thu, 24 Feb 2022 07:56:36 -0500
Subject: [PATCH 08/29] Version bump

---
 .version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.version b/.version
index 2701a226a..c8e38b614 100644
--- a/.version
+++ b/.version
@@ -1 +1 @@
-2.8.4
+2.9.0

From 48035a6f833e4cb6073395144c93476b201c4ae9 Mon Sep 17 00:00:00 2001
From: Jack Smith <jack.smith@algorand.com>
Date: Thu, 24 Feb 2022 08:15:11 -0500
Subject: [PATCH 09/29] Version bump

---
 .version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.version b/.version
index c8e38b614..d56b8a8e7 100644
--- a/.version
+++ b/.version
@@ -1 +1 @@
-2.9.0
+2.9.0-rc3

From a4687cb61fb6bd3a6846099139ea48cef55450fd Mon Sep 17 00:00:00 2001
From: Jack Smith <jack.smith@algorand.com>
Date: Thu, 24 Feb 2022 09:12:51 -0500
Subject: [PATCH 10/29] reverting version bump

---
 .version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.version b/.version
index d56b8a8e7..2701a226a 100644
--- a/.version
+++ b/.version
@@ -1 +1 @@
-2.9.0-rc3
+2.8.4

From 1216e7957d5fba7c6a858e244a2aaf7e99412e5d Mon Sep 17 00:00:00 2001
From: AlgoStephenAkiki <85183435+AlgoStephenAkiki@users.noreply.github.com>
Date: Thu, 24 Feb 2022 10:47:09 -0500
Subject: [PATCH 11/29] Disable Parameters in REST API (#892)

* Disable Parameters in REST API

Resolves #3582

Puts in the infrastructure and disables certain parameters in the REST
API for poor performing queries.

* PR comments
---
 api/disabled_parameters.go      | 184 +++++++++++++++++++++++++++++---
 api/disabled_parameters_test.go |  24 +++--
 api/server.go                   |  11 +-
 3 files changed, 198 insertions(+), 21 deletions(-)

diff --git a/api/disabled_parameters.go b/api/disabled_parameters.go
index 3a2d0c4c0..33fd3eaed 100644
--- a/api/disabled_parameters.go
+++ b/api/disabled_parameters.go
@@ -2,6 +2,8 @@ package api
 
 import (
 	"fmt"
+	"net/http"
+	"strings"
 
 	"github.com/getkin/kin-openapi/openapi3"
 	"github.com/labstack/echo/v4"
@@ -16,8 +18,8 @@ type EndpointConfig struct {
 	DisabledOptionalParameters map[string]bool
 }
 
-// NewEndpointConfig creates a new empty endpoint config
-func NewEndpointConfig() *EndpointConfig {
+// makeEndpointConfig creates a new empty endpoint config
+func makeEndpointConfig() *EndpointConfig {
 	rval := &EndpointConfig{
 		EndpointDisabled:           false,
 		DisabledOptionalParameters: make(map[string]bool),
@@ -29,28 +31,182 @@ func NewEndpointConfig() *EndpointConfig {
 // DisabledMap a type that holds a map of disabled types
 // The key for a disabled map is the handler function name
 type DisabledMap struct {
+	// Key -> Function Name/Operation ID
 	Data map[string]*EndpointConfig
 }
 
-// NewDisabledMap creates a new empty disabled map
-func NewDisabledMap() *DisabledMap {
+// MakeDisabledMap creates a new empty disabled map
+func MakeDisabledMap() *DisabledMap {
 	return &DisabledMap{
 		Data: make(map[string]*EndpointConfig),
 	}
 }
 
-// NewDisabledMapFromOA3 Creates a new disabled map from an openapi3 definition
-func NewDisabledMapFromOA3(swag *openapi3.Swagger) *DisabledMap {
-	rval := NewDisabledMap()
-	for _, item := range swag.Paths {
-		for _, opItem := range item.Operations() {
+// DisabledMapConfig is a type that holds the configuration for setting up
+// a DisabledMap
+type DisabledMapConfig struct {
+	// Key -> Path of REST endpoint (i.e. /v2/accounts/{account-id}/transactions)
+	// Value -> Operation "get, post, etc" -> Sub-value: List of parameters disabled for that endpoint
+	Data map[string]map[string][]string
+}
+
+// isDisabled Returns true if the parameter is disabled for the given path
+func (dmc *DisabledMapConfig) isDisabled(restPath string, operationName string, parameterName string) bool {
+	parameterList, exists := dmc.Data[restPath][operationName]
+	if !exists {
+		return false
+	}
+
+	for _, parameter := range parameterList {
+		if parameterName == parameter {
+			return true
+		}
+	}
+	return false
+}
+
+func (dmc *DisabledMapConfig) addEntry(restPath string, operationName string, parameterNames []string) {
+
+	if dmc.Data == nil {
+		dmc.Data = make(map[string]map[string][]string)
+	}
+
+	if dmc.Data[restPath] == nil {
+		dmc.Data[restPath] = make(map[string][]string)
+	}
+
+	dmc.Data[restPath][operationName] = parameterNames
+}
+
+// MakeDisabledMapConfig creates a new disabled map configuration
+func MakeDisabledMapConfig() *DisabledMapConfig {
+	return &DisabledMapConfig{
+		Data: make(map[string]map[string][]string),
+	}
+}
 
-			endpointConfig := NewEndpointConfig()
+// GetDefaultDisabledMapConfigForPostgres will generate a configuration that will block certain
+// parameters.  Should be used only for the postgres implementation
+func GetDefaultDisabledMapConfigForPostgres() *DisabledMapConfig {
+	rval := MakeDisabledMapConfig()
+
+	// Some syntactic sugar
+	get := func(restPath string, parameterNames []string) {
+		rval.addEntry(restPath, http.MethodGet, parameterNames)
+	}
+
+	get("/v2/accounts", []string{"currency-greater-than", "currency-less-than"})
+	get("/v2/accounts/{account-id}/transactions", []string{"note-prefix", "tx-type", "sig-type", "asset-id", "before-time", "after-time", "rekey-to"})
+	get("/v2/assets", []string{"name", "unit"})
+	get("/v2/assets/{asset-id}/balances", []string{"round", "currency-greater-than", "currency-less-than"})
+	get("/v2/transactions", []string{"note-prefix", "tx-type", "sig-type", "asset-id", "before-time", "after-time", "currency-greater-than", "currency-less-than", "address-role", "exclude-close-to", "rekey-to", "application-id"})
+	get("/v2/assets/{asset-id}/transactions", []string{"note-prefix", "tx-type", "sig-type", "asset-id", "before-time", "after-time", "currency-greater-than", "currency-less-than", "address-role", "exclude-close-to", "rekey-to"})
+
+	return rval
+}
+
+// ErrDisabledMapConfig contains any mis-spellings that could be present in a configuration
+type ErrDisabledMapConfig struct {
+	// Key -> REST Path that was mis-spelled
+	// Value -> Operation "get, post, etc" -> Sub-value: Any parameters that were found to be mis-spelled in a valid REST PATH
+	BadEntries map[string]map[string][]string
+}
+
+func (edmc *ErrDisabledMapConfig) Error() string {
+	var sb strings.Builder
+	for k, v := range edmc.BadEntries {
+
+		// If the length of the list is zero then it is a mis-spelled REST path
+		if len(v) == 0 {
+			_, _ = sb.WriteString(fmt.Sprintf("Mis-spelled REST Path: %s\n", k))
+			continue
+		}
+
+		for op, param := range v {
+			_, _ = sb.WriteString(fmt.Sprintf("REST Path %s (Operation: %s) contains mis-spelled parameters: %s\n", k, op, strings.Join(param, ",")))
+		}
+	}
+	return sb.String()
+}
+
+// makeErrDisabledMapConfig returns a new disabled map config error
+func makeErrDisabledMapConfig() *ErrDisabledMapConfig {
+	return &ErrDisabledMapConfig{
+		BadEntries: make(map[string]map[string][]string),
+	}
+}
+
+// validate makes sure that all keys and values in the Disabled Map Configuration
+// are actually spelled right.  What might happen is that a user might
+// accidentally mis-spell an entry, so we want to make sure to mitigate against
+// that by checking the openapi definition
+func (dmc *DisabledMapConfig) validate(swag *openapi3.Swagger) error {
+	potentialRval := makeErrDisabledMapConfig()
+
+	for recordedPath, recordedOp := range dmc.Data {
+		swagPath, exists := swag.Paths[recordedPath]
+		if !exists {
+			// This means that the rest endpoint itself is mis-spelled
+			potentialRval.BadEntries[recordedPath] = map[string][]string{}
+			continue
+		}
+
+		for opName, recordedParams := range recordedOp {
+			// This will panic if it is an illegal name so no need to check for nil
+			swagOperation := swagPath.GetOperation(opName)
+
+			for _, recordedParam := range recordedParams {
+				found := false
+
+				for _, swagParam := range swagOperation.Parameters {
+					if recordedParam == swagParam.Value.Name {
+						found = true
+						break
+					}
+				}
+
+				if found {
+					continue
+				}
+
+				// If we didn't find it then it's time to add it to the entry
+				if potentialRval.BadEntries[recordedPath] == nil {
+					potentialRval.BadEntries[recordedPath] = make(map[string][]string)
+				}
+
+				potentialRval.BadEntries[recordedPath][opName] = append(potentialRval.BadEntries[recordedPath][opName], recordedParam)
+			}
+		}
+	}
+
+	// If we have no entries then don't return an error
+	if len(potentialRval.BadEntries) != 0 {
+		return potentialRval
+	}
+
+	return nil
+}
+
+// MakeDisabledMapFromOA3 Creates a new disabled map from an openapi3 definition
+func MakeDisabledMapFromOA3(swag *openapi3.Swagger, config *DisabledMapConfig) (*DisabledMap, error) {
+
+	err := config.validate(swag)
+
+	if err != nil {
+		return nil, err
+	}
+
+	rval := MakeDisabledMap()
+	for restPath, item := range swag.Paths {
+		for opName, opItem := range item.Operations() {
+
+			endpointConfig := makeEndpointConfig()
 
 			for _, pref := range opItem.Parameters {
 
-				// TODO how to enable it to be disabled
-				parameterIsDisabled := false
+				paramName := pref.Value.Name
+
+				parameterIsDisabled := config.isDisabled(restPath, opName, paramName)
 				if !parameterIsDisabled {
 					// If the parameter is not disabled, then we don't need
 					// to do anything
@@ -62,7 +218,7 @@ func NewDisabledMapFromOA3(swag *openapi3.Swagger) *DisabledMap {
 					endpointConfig.EndpointDisabled = true
 				} else {
 					// If the optional parameter is disabled, add it to the map
-					endpointConfig.DisabledOptionalParameters[pref.Value.Name] = true
+					endpointConfig.DisabledOptionalParameters[paramName] = true
 				}
 			}
 
@@ -72,7 +228,7 @@ func NewDisabledMapFromOA3(swag *openapi3.Swagger) *DisabledMap {
 
 	}
 
-	return rval
+	return rval, err
 }
 
 // ErrVerifyFailedEndpoint an error that signifies that the entire endpoint is disabled
diff --git a/api/disabled_parameters_test.go b/api/disabled_parameters_test.go
index 2e76391e8..95508a35f 100644
--- a/api/disabled_parameters_test.go
+++ b/api/disabled_parameters_test.go
@@ -10,8 +10,20 @@ import (
 	"github.com/labstack/echo/v4"
 	"github.com/sirupsen/logrus/hooks/test"
 	"github.com/stretchr/testify/require"
+
+	"github.com/algorand/indexer/api/generated/v2"
 )
 
+func TestValidate(t *testing.T) {
+	// Validates that the default config is correctly spelled
+	dmc := GetDefaultDisabledMapConfigForPostgres()
+
+	swag, err := generated.GetSwagger()
+	require.NoError(t, err)
+
+	require.NoError(t, dmc.validate(swag))
+}
+
 // TestFailingParam tests that disabled parameters provided via
 // the FormParams() and QueryParams() functions of the context are appropriately handled
 func TestFailingParam(t *testing.T) {
@@ -66,8 +78,8 @@ func TestFailingParam(t *testing.T) {
 	}
 
 	runner := func(t *testing.T, tstruct *testingStruct, ctxFactory func(*echo.Echo, *url.Values, *testingStruct) *echo.Context) {
-		dm := NewDisabledMap()
-		e1 := NewEndpointConfig()
+		dm := MakeDisabledMap()
+		e1 := makeEndpointConfig()
 		e1.EndpointDisabled = false
 		e1.DisabledOptionalParameters["1"] = true
 
@@ -110,9 +122,9 @@ func TestFailingParam(t *testing.T) {
 // TestFailingEndpoint tests that an endpoint which has a disabled required parameter
 // returns a failed endpoint error
 func TestFailingEndpoint(t *testing.T) {
-	dm := NewDisabledMap()
+	dm := MakeDisabledMap()
 
-	e1 := NewEndpointConfig()
+	e1 := makeEndpointConfig()
 	e1.EndpointDisabled = true
 	e1.DisabledOptionalParameters["1"] = true
 
@@ -134,9 +146,9 @@ func TestFailingEndpoint(t *testing.T) {
 // TestVerifyNonExistentHandler tests that nonexistent endpoint is logged
 // but doesn't stop the indexer from functioning
 func TestVerifyNonExistentHandler(t *testing.T) {
-	dm := NewDisabledMap()
+	dm := MakeDisabledMap()
 
-	e1 := NewEndpointConfig()
+	e1 := makeEndpointConfig()
 	e1.EndpointDisabled = false
 	e1.DisabledOptionalParameters["1"] = true
 
diff --git a/api/server.go b/api/server.go
index 8fcef2b0a..b808cfdfd 100644
--- a/api/server.go
+++ b/api/server.go
@@ -83,13 +83,22 @@ func Serve(ctx context.Context, serveAddr string, db idb.IndexerDb, fetcherError
 		log.Fatal(err)
 	}
 
+	// TODO enable this when command line options allows for disabling/enabling overrides
+	//disabledMapConfig := GetDefaultDisabledMapConfigForPostgres()
+	disabledMapConfig := MakeDisabledMapConfig()
+
+	disabledMap, err := MakeDisabledMapFromOA3(swag, disabledMapConfig)
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	api := ServerImplementation{
 		EnableAddressSearchRoundRewind: options.DeveloperMode,
 		db:                             db,
 		fetcher:                        fetcherError,
 		timeout:                        options.handlerTimeout(),
 		log:                            log,
-		disabledParams:                 NewDisabledMapFromOA3(swag),
+		disabledParams:                 disabledMap,
 	}
 
 	generated.RegisterHandlers(e, &api, middleware...)

From df2779cd1536d0a69fe66843e0d2eb05d428d0cf Mon Sep 17 00:00:00 2001
From: shiqizng <80276844+shiqizng@users.noreply.github.com>
Date: Thu, 24 Feb 2022 13:56:03 -0500
Subject: [PATCH 12/29] monitoring dashboard (#876)

*add monitoring dashboard
---
 cmd/algorand-indexer/daemon.go               |    8 +-
 fetcher/fetcher.go                           |   13 +
 monitoring/Dockerfile-indexer                |   33 +
 monitoring/README.md                         |   60 +
 monitoring/dashboard.json                    | 1198 ++++++++++++++++++
 monitoring/docker-compose.yml                |   61 +
 monitoring/examples/widgets.png              |  Bin 0 -> 366340 bytes
 monitoring/grafana.ini                       |    7 +
 monitoring/grafana_prometheus_datasource.yml |   28 +
 monitoring/prometheus.yml                    |   30 +
 util/metrics/metrics.go                      |   18 +-
 11 files changed, 1452 insertions(+), 4 deletions(-)
 create mode 100644 monitoring/Dockerfile-indexer
 create mode 100644 monitoring/README.md
 create mode 100644 monitoring/dashboard.json
 create mode 100644 monitoring/docker-compose.yml
 create mode 100644 monitoring/examples/widgets.png
 create mode 100644 monitoring/grafana.ini
 create mode 100644 monitoring/grafana_prometheus_datasource.yml
 create mode 100644 monitoring/prometheus.yml

diff --git a/cmd/algorand-indexer/daemon.go b/cmd/algorand-indexer/daemon.go
index f0f268c43..c587199f0 100644
--- a/cmd/algorand-indexer/daemon.go
+++ b/cmd/algorand-indexer/daemon.go
@@ -213,8 +213,14 @@ func handleBlock(block *rpcs.EncodedBlockCert, imp importer.Importer) error {
 	// Ignore round 0 (which is empty).
 	if block.Block.Round() > 0 {
 		metrics.BlockImportTimeSeconds.Observe(dt.Seconds())
-		metrics.ImportedTxnsPerBlock.Observe(float64(len(block.Block.Payset)))
 		metrics.ImportedRoundGauge.Set(float64(block.Block.Round()))
+		txnCountByType := make(map[string]int)
+		for _, txn := range block.Block.Payset {
+			txnCountByType[string(txn.Txn.Type)]++
+		}
+		for k, v := range txnCountByType {
+			metrics.ImportedTxnsPerBlock.WithLabelValues(k).Set(float64(v))
+		}
 	}
 
 	logger.Infof("round r=%d (%d txn) imported in %s", block.Block.Round(), len(block.Block.Payset), dt.String())
diff --git a/fetcher/fetcher.go b/fetcher/fetcher.go
index 38eedd4bf..b7da57690 100644
--- a/fetcher/fetcher.go
+++ b/fetcher/fetcher.go
@@ -13,6 +13,7 @@ import (
 	"github.com/algorand/go-algorand-sdk/client/v2/algod"
 	"github.com/algorand/go-algorand/protocol"
 	"github.com/algorand/go-algorand/rpcs"
+	"github.com/algorand/indexer/util/metrics"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -111,7 +112,13 @@ func (bot *fetcherImpl) catchupLoop(ctx context.Context) error {
 	var blockbytes []byte
 	aclient := bot.Algod()
 	for {
+		start := time.Now()
+
 		blockbytes, err = aclient.BlockRaw(bot.nextRound).Do(ctx)
+
+		dt := time.Since(start)
+		metrics.GetAlgodRawBlockTimeSeconds.Observe(dt.Seconds())
+
 		if err != nil {
 			// If context has expired.
 			if ctx.Err() != nil {
@@ -150,7 +157,13 @@ func (bot *fetcherImpl) followLoop(ctx context.Context) error {
 					"r=%d error getting status %d", retries, bot.nextRound)
 				continue
 			}
+			start := time.Now()
+
 			blockbytes, err = aclient.BlockRaw(bot.nextRound).Do(ctx)
+
+			dt := time.Since(start)
+			metrics.GetAlgodRawBlockTimeSeconds.Observe(dt.Seconds())
+
 			if err == nil {
 				break
 			} else if ctx.Err() != nil { // if context has expired
diff --git a/monitoring/Dockerfile-indexer b/monitoring/Dockerfile-indexer
new file mode 100644
index 000000000..453880375
--- /dev/null
+++ b/monitoring/Dockerfile-indexer
@@ -0,0 +1,33 @@
+ARG GO_VERSION=1.17.5
+FROM golang:$GO_VERSION
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update && apt-get install -y apt-utils curl git git-core bsdmainutils python3
+
+
+# Build go-algorand
+RUN mkdir /work
+WORKDIR /work
+ADD . ./
+WORKDIR /work/third_party/go-algorand
+RUN ./scripts/configure_dev.sh
+RUN make
+
+# Build indexer
+WORKDIR /work
+RUN make
+WORKDIR /work/cmd/algorand-indexer
+ENV CGO_ENABLED="1"
+RUN go build
+
+# The sleep is to wait until postgres starts
+CMD ["/bin/sh", "-c", "\
+  echo $ALGOD_NET && \
+  echo $CONNECTION_STRING &&\
+  sleep 5 && \
+  ./algorand-indexer daemon \
+    --server \":${PORT}\" \
+    -P \"${CONNECTION_STRING}\" \
+    --metrics-mode VERBOSE \
+    --algod-net \"${ALGOD_NET}\" \
+    --algod-token ${ALGOD_TOKEN}"]
\ No newline at end of file
diff --git a/monitoring/README.md b/monitoring/README.md
new file mode 100644
index 000000000..196f1c336
--- /dev/null
+++ b/monitoring/README.md
@@ -0,0 +1,60 @@
+## Indexer Monitoring Dashboard
+A monitoring dashboard displaying indexer performance metrics. 
+
+### To start a monitoring dashboard
+### Prerequisite
+ - Algorand indexer is running with metrics-mode set to ON or VERBOSE 
+
+Data sources for Grafana are set in `grafana_prometheus_datasource.yml`. Check that configurations for
+Prometheus source and PostgresSQL source are correct or Grafana will not have the metrics.
+
+Also, Prometheus target should be updated to listen to a correct indexer address (host:port). The default target assumes
+the indexer is running on prometheus container's host at port 8888. Check `<prometheus-url>/targets` to see whether Prometheus
+connects to the target successfully. 
+
+```json
+static_configs:
+- targets: ['host.docker.internal:8888'] 
+```
+
+Run,
+
+`docker-compose up -d prometheus grafana` 
+
+- Check metrics are written to <indexer-url>/metrics 
+- Grafana is running on http://localhost:3000; default login (admin/admin)
+
+
+
+### View metrics on grafana
+
+- Go to Import and upload dashboard.json
+- Run `create extension pg_stat_statements;` sql on db to enable query stats from Postgres. 
+  - If getting error such as `elation "pg_stat_statements" does not exist`, check `pg_stat_statements` is 
+   loaded to shared_preload_libraries in postgresql.conf or added in db start up command `-c shared_preload_libraries=pg_stat_statements`. 
+
+![](examples/widgets.png)
+
+
+**Default widgets**:
+
+Importing
+- Block import time
+- Transactions per block by type
+- TPS
+- Round #
+
+Query
+
+- Request duration
+- Request duraton by url
+- Postgres Eval Time
+
+System
+
+- average CPU usage
+- average Heap Alloc
+- Postgres table info
+- Postgres queries info
+
+
diff --git a/monitoring/dashboard.json b/monitoring/dashboard.json
new file mode 100644
index 000000000..066c9668f
--- /dev/null
+++ b/monitoring/dashboard.json
@@ -0,0 +1,1198 @@
+{
+  "__inputs": [
+    {
+      "name": "DS_INDEXERPROMETHEUS",
+      "label": "IndexerPrometheus",
+      "description": "",
+      "type": "datasource",
+      "pluginId": "prometheus",
+      "pluginName": "Prometheus"
+    },
+    {
+      "name": "DS_POSTGRESQL",
+      "label": "PostgreSQL",
+      "description": "",
+      "type": "datasource",
+      "pluginId": "postgres",
+      "pluginName": "PostgreSQL"
+    }
+  ],
+  "__elements": [],
+  "__requires": [
+    {
+      "type": "grafana",
+      "id": "grafana",
+      "name": "Grafana",
+      "version": "8.3.6"
+    },
+    {
+      "type": "panel",
+      "id": "histogram",
+      "name": "Histogram",
+      "version": ""
+    },
+    {
+      "type": "datasource",
+      "id": "postgres",
+      "name": "PostgreSQL",
+      "version": "1.0.0"
+    },
+    {
+      "type": "datasource",
+      "id": "prometheus",
+      "name": "Prometheus",
+      "version": "1.0.0"
+    },
+    {
+      "type": "panel",
+      "id": "table",
+      "name": "Table",
+      "version": ""
+    },
+    {
+      "type": "panel",
+      "id": "timeseries",
+      "name": "Time series",
+      "version": ""
+    }
+  ],
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": "-- Grafana --",
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "target": {
+          "limit": 100,
+          "matchAny": false,
+          "tags": [],
+          "type": "dashboard"
+        },
+        "type": "dashboard"
+      }
+    ]
+  },
+  "editable": true,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 0,
+  "id": null,
+  "links": [],
+  "liveNow": false,
+  "panels": [
+    {
+      "collapsed": false,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 0
+      },
+      "id": 22,
+      "panels": [],
+      "title": "Query",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_INDEXERPROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "custom": {
+            "fillOpacity": 80,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineWidth": 1
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 0,
+        "y": 1
+      },
+      "id": 12,
+      "options": {
+        "bucketOffset": 0,
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "histogram_quantile(0.95, sum(rate(indexer_request_duration_seconds_bucket[5m])) by (le))",
+          "interval": "",
+          "legendFormat": "request duration (sec)",
+          "refId": "A"
+        }
+      ],
+      "title": "Request Duration",
+      "type": "histogram"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_INDEXERPROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "custom": {
+            "fillOpacity": 80,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineWidth": 1
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 12,
+        "y": 1
+      },
+      "id": 28,
+      "options": {
+        "bucketOffset": 0,
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "histogram_quantile(0.95, sum(rate(indexer_request_duration_seconds_bucket[5m])) by (le, url))",
+          "interval": "",
+          "legendFormat": "",
+          "refId": "A"
+        }
+      ],
+      "title": "Request Duration by URL",
+      "type": "histogram"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_INDEXERPROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 0,
+        "y": 10
+      },
+      "id": 24,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "rate(indexer_daemon_postgres_eval_time_sec_sum[1m])",
+          "interval": "",
+          "legendFormat": "eval_time(sec)",
+          "refId": "A"
+        }
+      ],
+      "title": "Postgres Eval Time",
+      "type": "timeseries"
+    },
+    {
+      "collapsed": false,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 19
+      },
+      "id": 20,
+      "panels": [],
+      "title": "System",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_INDEXERPROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 20
+      },
+      "id": 16,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "rate(process_cpu_seconds_total[1m])",
+          "interval": "",
+          "legendFormat": "",
+          "refId": "A"
+        }
+      ],
+      "title": "CPU",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_INDEXERPROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 20
+      },
+      "id": 18,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "rate(go_memstats_heap_alloc_bytes[$__interval])",
+          "interval": "",
+          "legendFormat": "alloc_bytes",
+          "refId": "A"
+        }
+      ],
+      "title": "Heap Alloc",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "postgres",
+        "uid": "${DS_POSTGRESQL}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "custom": {
+            "align": "auto",
+            "displayMode": "auto"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 11,
+        "w": 12,
+        "x": 0,
+        "y": 28
+      },
+      "id": 26,
+      "options": {
+        "footer": {
+          "fields": "",
+          "reducer": [
+            "sum"
+          ],
+          "show": false
+        },
+        "showHeader": true
+      },
+      "pluginVersion": "8.3.6",
+      "targets": [
+        {
+          "datasource": {
+            "type": "postgres",
+            "uid": "${DS_POSTGRESQL}"
+          },
+          "format": "table",
+          "group": [],
+          "metricColumn": "none",
+          "rawQuery": true,
+          "rawSql": "SELECT relname, seq_tup_read,idx_scan,idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_live_tup,\nn_dead_tup,last_vacuum,last_autovacuum\n\nFROM pg_stat_user_tables",
+          "refId": "A",
+          "select": [
+            [
+              {
+                "params": [
+                  "*"
+                ],
+                "type": "column"
+              }
+            ]
+          ],
+          "table": "pg_stat_database",
+          "timeColumn": "time",
+          "where": []
+        }
+      ],
+      "title": "postgres db",
+      "type": "table"
+    },
+    {
+      "datasource": {
+        "type": "postgres",
+        "uid": "${DS_POSTGRESQL}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "custom": {
+            "align": "auto",
+            "displayMode": "auto"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "query"
+            },
+            "properties": [
+              {
+                "id": "custom.width",
+                "value": 167
+              }
+            ]
+          }
+        ]
+      },
+      "gridPos": {
+        "h": 11,
+        "w": 12,
+        "x": 12,
+        "y": 28
+      },
+      "id": 27,
+      "options": {
+        "footer": {
+          "fields": "",
+          "reducer": [
+            "sum"
+          ],
+          "show": false
+        },
+        "showHeader": true,
+        "sortBy": [
+          {
+            "desc": true,
+            "displayName": "mean_exec_time"
+          }
+        ]
+      },
+      "pluginVersion": "8.3.6",
+      "targets": [
+        {
+          "datasource": {
+            "type": "postgres",
+            "uid": "${DS_POSTGRESQL}"
+          },
+          "format": "table",
+          "group": [],
+          "metricColumn": "none",
+          "rawQuery": true,
+          "rawSql": "SELECT query, calls,rows,mean_exec_time, \nmin_exec_time,max_exec_time\nFROM pg_stat_statements\nORDER BY mean_exec_time DESC",
+          "refId": "A",
+          "select": [
+            [
+              {
+                "params": [
+                  "*"
+                ],
+                "type": "column"
+              }
+            ]
+          ],
+          "table": "pg_stat_database",
+          "timeColumn": "time",
+          "where": []
+        }
+      ],
+      "title": "Queries",
+      "type": "table"
+    },
+    {
+      "collapsed": false,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 39
+      },
+      "id": 14,
+      "panels": [],
+      "title": "Importing",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_INDEXERPROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 0,
+        "y": 40
+      },
+      "id": 6,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "sum(avg_over_time(indexer_daemon_imported_tx_per_block[10m])/4.3)",
+          "interval": "",
+          "legendFormat": "TPS",
+          "refId": "A"
+        }
+      ],
+      "title": "TPS",
+      "transformations": [],
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_INDEXERPROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "txns per block"
+            },
+            "properties": [
+              {
+                "id": "color",
+                "value": {
+                  "fixedColor": "dark-red",
+                  "mode": "fixed"
+                }
+              },
+              {
+                "id": "custom.axisPlacement",
+                "value": "right"
+              },
+              {
+                "id": "custom.drawStyle",
+                "value": "line"
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "Total import time (sec)"
+            },
+            "properties": [
+              {
+                "id": "custom.lineWidth",
+                "value": 2
+              }
+            ]
+          }
+        ]
+      },
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 12,
+        "y": 40
+      },
+      "id": 4,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "rate(indexer_daemon_get_algod_raw_block_time_sec_sum{}[1m])",
+          "format": "time_series",
+          "instant": false,
+          "interval": "",
+          "legendFormat": "Get Algod Raw Block Response time(sec)",
+          "refId": "A"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "sum(avg_over_time(indexer_daemon_imported_tx_per_block[1m]))",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "txns per block",
+          "refId": "B"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "rate(indexer_daemon_import_time_sec_sum[1m])",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "block import time (sec)",
+          "refId": "C"
+        }
+      ],
+      "title": "Block import",
+      "transformations": [
+        {
+          "id": "calculateField",
+          "options": {
+            "alias": "Total import time (sec)",
+            "binary": {
+              "left": "Get Algod Raw Block Response time(sec)",
+              "operator": "+",
+              "reducer": "sum",
+              "right": "block import time (sec)"
+            },
+            "mode": "binary",
+            "reduce": {
+              "reducer": "sum"
+            },
+            "replaceFields": false
+          }
+        }
+      ],
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_INDEXERPROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "rounds imported"
+            },
+            "properties": [
+              {
+                "id": "custom.axisPlacement",
+                "value": "right"
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byName",
+              "options": "rate"
+            },
+            "properties": [
+              {
+                "id": "custom.axisPlacement",
+                "value": "right"
+              }
+            ]
+          }
+        ]
+      },
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 0,
+        "y": 49
+      },
+      "id": 2,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "indexer_daemon_imported_round{}",
+          "interval": "",
+          "legendFormat": "total rounds",
+          "refId": "A"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "delta(indexer_daemon_imported_round[$__interval])",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "rounds imported",
+          "refId": "B"
+        }
+      ],
+      "title": "Round",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_INDEXERPROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 0,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "auto",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 9,
+        "w": 12,
+        "x": 12,
+        "y": 49
+      },
+      "id": 8,
+      "options": {
+        "legend": {
+          "calcs": [],
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "single",
+          "sort": "none"
+        }
+      },
+      "pluginVersion": "8.4.0-beta1",
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_INDEXERPROMETHEUS}"
+          },
+          "exemplar": true,
+          "expr": "indexer_daemon_imported_tx_per_block",
+          "interval": "",
+          "legendFormat": "{{txn_type}}",
+          "refId": "A"
+        }
+      ],
+      "title": "Txns per block by Type",
+      "type": "timeseries"
+    }
+  ],
+  "refresh": "",
+  "schemaVersion": 34,
+  "style": "dark",
+  "tags": [],
+  "templating": {
+    "list": []
+  },
+  "time": {
+    "from": "now-5m",
+    "to": "now"
+  },
+  "timepicker": {},
+  "timezone": "",
+  "title": "Monitoring",
+  "uid": "ArMgIZ-7z",
+  "version": 3,
+  "weekStart": ""
+}
\ No newline at end of file
diff --git a/monitoring/docker-compose.yml b/monitoring/docker-compose.yml
new file mode 100644
index 000000000..afc8431fb
--- /dev/null
+++ b/monitoring/docker-compose.yml
@@ -0,0 +1,61 @@
+version: '3'
+services:
+  indexer:
+    container_name: "indexer"
+    build:
+      context: ./../
+      dockerfile: "./monitoring/Dockerfile-indexer"
+    environment:
+      PORT: 8888
+      CONNECTION_STRING: ${DB_CONNECTION:-"host=indexer-db port=5432 user=algorand password=algorand dbname=indexer_db sslmode=disable"}
+      ALGOD_NET: ${ALGOD_NET}
+      ALGOD_TOKEN: ${ALGOD_TOKEN}
+    ports:
+      - 8888:8888
+    depends_on:
+      - indexer-db
+
+  indexer-db:
+    image: "postgres:13-alpine"
+    container_name: "indexer-postgres"
+    ports:
+      - 5555:5432
+    environment:
+      POSTGRES_USER: algorand
+      POSTGRES_PASSWORD: algorand
+      POSTGRES_DB: indexer_db
+    command:
+      - "postgres"
+      - "-c"
+      - "shared_preload_libraries=pg_stat_statements"
+
+  prometheus:
+    image: "prom/prometheus"
+    container_name: "prometheus"
+    ports:
+      - 9090:9090
+    volumes:
+      # Install prometheus config
+      - ./prometheus.yml:/etc/prometheus/prometheus.yml
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+
+  grafana:
+    image: "grafana/grafana:8.4.2"
+    container_name: "grafana"
+    ports:
+      - 3000:3000
+    environment:
+      GF_PATHS_CONFIG: /etc/grafana/ours.ini
+    volumes:
+      - ./grafana.ini:/etc/grafana/ours.ini
+      - ./grafana_prometheus_datasource.yml:/etc/grafana/provisioning/datasources/prometheus.yml
+      # Modify the dashboard with the web interface. Once finished export the
+      # JSON from the share menu (from the dashboard page), convert the JSON to
+      # YAML, and update this YAML file.
+      #
+      # This didn't work, maybe because the metrics don't exist when initialized?
+      # The dashboard can be imported manually.
+      #- ./grafana_indexer_dashboard.yml:/etc/grafana/provisioning/dashboards/indexer.yml
+
+
diff --git a/monitoring/examples/widgets.png b/monitoring/examples/widgets.png
new file mode 100644
index 0000000000000000000000000000000000000000..8a50ea3b96161f9987387b18453d9d17ffb448f0
GIT binary patch
literal 366340
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%0AHV7)3hX$iauNTY5#pD|3Ld+&|2H`%`<4M*_%
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

literal 0
HcmV?d00001

diff --git a/monitoring/grafana.ini b/monitoring/grafana.ini
new file mode 100644
index 000000000..11c1fc1b3
--- /dev/null
+++ b/monitoring/grafana.ini
@@ -0,0 +1,7 @@
+[auth.anonymous]
+# enable anonymous access
+enabled = true
+
+# specify organization name that should be used for unauthenticated users
+org_name = Algorand
+
diff --git a/monitoring/grafana_prometheus_datasource.yml b/monitoring/grafana_prometheus_datasource.yml
new file mode 100644
index 000000000..ccb869ec1
--- /dev/null
+++ b/monitoring/grafana_prometheus_datasource.yml
@@ -0,0 +1,28 @@
+# config file version
+apiVersion: 1
+
+# list of datasources to insert/update depending
+# what's available in the database
+datasources:
+  - name: IndexerPrometheus
+    type: prometheus
+    # Access mode - proxy (server in the UI) or direct (browser in the UI).
+    access: proxy
+    httpMethod: POST
+    # The default connects to a local instance running in Docker. May be updated
+    # to connect to any live prometheus instance
+    url: http://prometheus:9090
+    version: 1
+    editable: false
+
+  - name: PostgresSQL
+    type: postgres
+    # The default connects to a local instance running in Docker. May be updated
+    # to connect to any live PostgresDB instance
+    url: indexer-db:5432
+    database: indexer_db
+    user: algorand
+    secureJsonData:
+      password: 'algorand'
+    jsonData:
+      sslmode: "disable"
\ No newline at end of file
diff --git a/monitoring/prometheus.yml b/monitoring/prometheus.yml
new file mode 100644
index 000000000..947d70806
--- /dev/null
+++ b/monitoring/prometheus.yml
@@ -0,0 +1,30 @@
+# my global config
+global:
+  scrape_interval:     5s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
+  evaluation_interval: 5s # Evaluate rules every 15 seconds. The default is every 1 minute.
+  # scrape_timeout is set to the global default (10s).
+
+# Alertmanager configuration
+alerting:
+  alertmanagers:
+  - static_configs:
+    - targets:
+      # - alertmanager:9093
+
+# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
+rule_files:
+  # - "first_rules.yml"
+  # - "second_rules.yml"
+
+# A scrape configuration containing exactly one endpoint to scrape:
+# Here it's Prometheus itself.
+scrape_configs:
+  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
+  - job_name: 'scrape_indexer'
+
+    # metrics_path defaults to '/metrics'
+    # scheme defaults to 'http'.
+
+    static_configs:
+    - targets: ['host.docker.internal:8888']
+
diff --git a/util/metrics/metrics.go b/util/metrics/metrics.go
index a918a13ab..bffdd452a 100644
--- a/util/metrics/metrics.go
+++ b/util/metrics/metrics.go
@@ -10,6 +10,7 @@ func RegisterPrometheusMetrics() {
 	prometheus.Register(ImportedRoundGauge)
 	prometheus.Register(BlockUploadTimeSeconds)
 	prometheus.Register(PostgresEvalTimeSeconds)
+	prometheus.Register(GetAlgodRawBlockTimeSeconds)
 }
 
 // Prometheus metric names broken out for reuse.
@@ -19,6 +20,7 @@ const (
 	ImportedTxnsPerBlockName = "imported_tx_per_block"
 	ImportedRoundGaugeName   = "imported_round"
 	PostgresEvalName         = "postgres_eval_time_sec"
+	GetAlgodRawBlockTimeName = "get_algod_raw_block_time_sec"
 )
 
 // AllMetricNames is a reference for all the custom metric names.
@@ -28,6 +30,7 @@ var AllMetricNames = []string{
 	ImportedTxnsPerBlockName,
 	ImportedRoundGaugeName,
 	PostgresEvalName,
+	GetAlgodRawBlockTimeName,
 }
 
 // Initialize the prometheus objects.
@@ -46,12 +49,14 @@ var (
 			Help:      "Block upload time in seconds.",
 		})
 
-	ImportedTxnsPerBlock = prometheus.NewSummary(
-		prometheus.SummaryOpts{
+	ImportedTxnsPerBlock = prometheus.NewGaugeVec(
+		prometheus.GaugeOpts{
 			Subsystem: "indexer_daemon",
 			Name:      ImportedTxnsPerBlockName,
 			Help:      "Transactions per block.",
-		})
+		},
+		[]string{"txn_type"},
+	)
 
 	ImportedRoundGauge = prometheus.NewGauge(
 		prometheus.GaugeOpts{
@@ -66,4 +71,11 @@ var (
 			Name:      PostgresEvalName,
 			Help:      "Time spent calling Eval function in seconds.",
 		})
+
+	GetAlgodRawBlockTimeSeconds = prometheus.NewSummary(
+		prometheus.SummaryOpts{
+			Subsystem: "indexer_daemon",
+			Name:      GetAlgodRawBlockTimeName,
+			Help:      "Total response time from Algod's raw block endpoint in seconds.",
+		})
 )

From 2aad7dbf5a4f368e3804b6995ae8dc41dd939a6a Mon Sep 17 00:00:00 2001
From: shiqizng <80276844+shiqizng@users.noreply.github.com>
Date: Fri, 25 Feb 2022 17:00:37 -0500
Subject: [PATCH 13/29] Fix e2e test to support inner transactions. (#899)

---
 cmd/e2equeries/main.go |  9 +++++++--
 misc/buildtestdata.sh  |  2 +-
 misc/e2elive.py        |  2 +-
 util/test/testutil.go  | 10 ++++++----
 4 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/cmd/e2equeries/main.go b/cmd/e2equeries/main.go
index a786f97ca..35419e5ef 100644
--- a/cmd/e2equeries/main.go
+++ b/cmd/e2equeries/main.go
@@ -44,7 +44,12 @@ func main() {
 	rowchan, _ := db.Transactions(context.Background(), rekeyTxnQuery)
 	for txnrow := range rowchan {
 		maybeFail(txnrow.Error, "err rekey txn %v\n", txnrow.Error)
-		rekeyedAuthAddrs = append(rekeyedAuthAddrs, txnrow.Txn.Txn.RekeyTo)
+
+		t := txnrow.Txn
+		if txnrow.RootTxn != nil {
+			t = txnrow.RootTxn
+		}
+		rekeyedAuthAddrs = append(rekeyedAuthAddrs, t.Txn.RekeyTo)
 	}
 
 	// some rekeys get rekeyed back; some rekeyed accounts get deleted, just want to find at least one
@@ -63,7 +68,7 @@ func main() {
 	}
 	if !foundRekey {
 		// this will report the error in a handy way
-		printAccountQuery(db, idb.AccountQueryOptions{EqualToAuthAddr: rekeyedAuthAddrs[0][:], Limit: 1})
+		printAccountQuery(db, idb.AccountQueryOptions{EqualToAuthAddr: rekeyedAuthAddrs[0][:], Limit: 0})
 	}
 
 	// find an asset with > 1 account
diff --git a/misc/buildtestdata.sh b/misc/buildtestdata.sh
index cb1655d9f..54f8b4604 100755
--- a/misc/buildtestdata.sh
+++ b/misc/buildtestdata.sh
@@ -49,4 +49,4 @@ mkdir -p "${E2EDATA}"
 RSTAMP=$(TZ=UTC python -c 'import time; print("{:08x}".format(0xffffffff - int(time.time() - time.mktime((2020,1,1,0,0,0,-1,-1,-1)))))')
 
 echo "COPY AND PASTE THIS TO UPLOAD:"
-echo aws s3 cp --acl public-read "${E2EDATA}/net_done.tar.bz2" s3://algorand-testdata/indexer/e2e3/"${RSTAMP}"/net_done.tar.bz2
+echo aws s3 cp --acl public-read "${E2EDATA}/net_done.tar.bz2" s3://algorand-testdata/indexer/e2e4/"${RSTAMP}"/net_done.tar.bz2
diff --git a/misc/e2elive.py b/misc/e2elive.py
index 71b11c9ec..327ad1dc5 100644
--- a/misc/e2elive.py
+++ b/misc/e2elive.py
@@ -59,7 +59,7 @@ def main():
         s3 = boto3.client('s3', config=Config(signature_version=UNSIGNED))
         tarname = 'net_done.tar.bz2'
         tarpath = os.path.join(tempdir, tarname)
-        firstFromS3Prefix(s3, bucket, 'indexer/e2e3', tarname, outpath=tarpath)
+        firstFromS3Prefix(s3, bucket, 'indexer/e2e4', tarname, outpath=tarpath)
         source_is_tar = True
         sourcenet = tarpath
     tempnet = os.path.join(tempdir, 'net')
diff --git a/util/test/testutil.go b/util/test/testutil.go
index 759be3e52..d97f731ed 100644
--- a/util/test/testutil.go
+++ b/util/test/testutil.go
@@ -101,12 +101,14 @@ func PrintTxnQuery(db idb.IndexerDb, q idb.TransactionFilter) {
 	for txnrow := range rowchan {
 		util.MaybeFail(txnrow.Error, "err %v\n", txnrow.Error)
 		stxn := txnrow.Txn
-		tjs := util.JSONOneLine(stxn.Txn)
-		info("%d:%d %s sr=%d rr=%d ca=%d cr=%d t=%s\n", txnrow.Round, txnrow.Intra, tjs, stxn.SenderRewards, stxn.ReceiverRewards, stxn.ClosingAmount, stxn.CloseRewards, txnrow.RoundTime.String())
-		count++
+		if stxn != nil {
+			tjs := util.JSONOneLine(stxn.Txn)
+			info("%d:%d %s sr=%d rr=%d ca=%d cr=%d t=%s\n", txnrow.Round, txnrow.Intra, tjs, stxn.SenderRewards, stxn.ReceiverRewards, stxn.ClosingAmount, stxn.CloseRewards, txnrow.RoundTime.String())
+			count++
+		}
 	}
 	info("%d txns\n", count)
-	if q.Limit != 0 && q.Limit != count {
+	if q.Limit != 0 && count < 2 || count > 100 {
 		fmt.Fprintf(os.Stderr, "txn q CAME UP SHORT, limit=%d actual=%d, q=%#v\n", q.Limit, count, q)
 		myStackTrace()
 		exitValue = 1

From 8d85bf4689d3278bfff1b4d92b79367753f73592 Mon Sep 17 00:00:00 2001
From: Will Winder <wwinder.unh@gmail.com>
Date: Mon, 28 Feb 2022 10:57:41 -0500
Subject: [PATCH 14/29] Include block-generator and validator as
 algorand-indexer subcommands. (#891)

---
 cmd/algorand-indexer/main.go                  |  38 ++--
 cmd/block-generator/core/commands.go          |  20 ++
 cmd/block-generator/{ => generator}/daemon.go |  19 +-
 cmd/block-generator/main.go                   |   9 +-
 cmd/block-generator/runner.go                 |  44 -----
 cmd/block-generator/runner/runner.go          |  44 +++++
 cmd/import-validator/core/command.go          |   2 +-
 cmd/validator/core/command.go                 | 187 ++++++++++++++++++
 cmd/validator/main.go                         | 170 +---------------
 9 files changed, 291 insertions(+), 242 deletions(-)
 create mode 100644 cmd/block-generator/core/commands.go
 rename cmd/block-generator/{ => generator}/daemon.go (52%)
 delete mode 100644 cmd/block-generator/runner.go
 create mode 100644 cmd/block-generator/runner/runner.go
 create mode 100644 cmd/validator/core/command.go

diff --git a/cmd/algorand-indexer/main.go b/cmd/algorand-indexer/main.go
index 5b0c6486c..9243ced5a 100644
--- a/cmd/algorand-indexer/main.go
+++ b/cmd/algorand-indexer/main.go
@@ -12,7 +12,9 @@ import (
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/viper"
 
-	"github.com/algorand/indexer/cmd/import-validator/core"
+	bg "github.com/algorand/indexer/cmd/block-generator/core"
+	iv "github.com/algorand/indexer/cmd/import-validator/core"
+	v "github.com/algorand/indexer/cmd/validator/core"
 	"github.com/algorand/indexer/config"
 	"github.com/algorand/indexer/idb"
 	"github.com/algorand/indexer/idb/dummy"
@@ -114,9 +116,16 @@ func indexerDbFromFlags(opts idb.IndexerDbOptions) (idb.IndexerDb, chan struct{}
 }
 
 func init() {
-	// Add hidden subcommands
-	core.ImportValidatorCmd.Hidden = true
-	rootCmd.AddCommand(core.ImportValidatorCmd)
+	// Utilities subcommand for more convenient access to useful testing utilities.
+	utilsCmd := &cobra.Command{
+		Use:   "util",
+		Short: "Utilities for testing Indexer operation and correctness.",
+		Long:  "Utilities used for Indexer development. These are low level tools that may require low level knowledge of Indexer deployment and operation. They are included as part of this binary for ease of deployment and automation, and to publicize their existance to people who may find them useful. More detailed documention may be found on github in README files located the different 'cmd' directories.",
+	}
+	utilsCmd.AddCommand(iv.ImportValidatorCmd)
+	utilsCmd.AddCommand(v.ValidatorCmd)
+	utilsCmd.AddCommand(bg.BlockGenerator)
+	rootCmd.AddCommand(utilsCmd)
 
 	logger = log.New()
 	logger.SetFormatter(&log.JSONFormatter{
@@ -129,14 +138,19 @@ func init() {
 	importCmd.Hidden = true
 	rootCmd.AddCommand(daemonCmd)
 
-	rootCmd.PersistentFlags().StringVarP(&logLevel, "loglevel", "l", "info", "verbosity of logs: [error, warn, info, debug, trace]")
-	rootCmd.PersistentFlags().StringVarP(&logFile, "logfile", "f", "", "file to write logs to, if unset logs are written to standard out")
-	rootCmd.PersistentFlags().StringVarP(&postgresAddr, "postgres", "P", "", "connection string for postgres database")
-	rootCmd.PersistentFlags().BoolVarP(&dummyIndexerDb, "dummydb", "n", false, "use dummy indexer db")
-	rootCmd.PersistentFlags().StringVarP(&cpuProfile, "cpuprofile", "", "", "file to record cpu profile to")
-	rootCmd.PersistentFlags().StringVarP(&pidFilePath, "pidfile", "", "", "file to write daemon's process id to")
-	rootCmd.PersistentFlags().StringVarP(&configFile, "configfile", "c", "", "file path to configuration file (indexer.yml)")
-	rootCmd.PersistentFlags().BoolVarP(&doVersion, "version", "v", false, "print version and exit")
+	// Not applied globally to avoid adding to utility commands.
+	addFlags := func(cmd *cobra.Command) {
+		cmd.Flags().StringVarP(&logLevel, "loglevel", "l", "info", "verbosity of logs: [error, warn, info, debug, trace]")
+		cmd.Flags().StringVarP(&logFile, "logfile", "f", "", "file to write logs to, if unset logs are written to standard out")
+		cmd.Flags().StringVarP(&postgresAddr, "postgres", "P", "", "connection string for postgres database")
+		cmd.Flags().BoolVarP(&dummyIndexerDb, "dummydb", "n", false, "use dummy indexer db")
+		cmd.Flags().StringVarP(&cpuProfile, "cpuprofile", "", "", "file to record cpu profile to")
+		cmd.Flags().StringVarP(&pidFilePath, "pidfile", "", "", "file to write daemon's process id to")
+		cmd.Flags().StringVarP(&configFile, "configfile", "c", "", "file path to configuration file (indexer.yml)")
+		cmd.Flags().BoolVarP(&doVersion, "version", "v", false, "print version and exit")
+	}
+	addFlags(daemonCmd)
+	addFlags(importCmd)
 
 	viper.RegisterAlias("postgres", "postgres-connection-string")
 
diff --git a/cmd/block-generator/core/commands.go b/cmd/block-generator/core/commands.go
new file mode 100644
index 000000000..a28674fea
--- /dev/null
+++ b/cmd/block-generator/core/commands.go
@@ -0,0 +1,20 @@
+package core
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/algorand/indexer/cmd/block-generator/generator"
+	"github.com/algorand/indexer/cmd/block-generator/runner"
+)
+
+// BlockGenerator related cobra commands, ready to be executed or included as subcommands.
+var BlockGenerator *cobra.Command
+
+func init() {
+	BlockGenerator = &cobra.Command{
+		Use:   `block-generator`,
+		Short: `Block generator testing tools.`,
+	}
+	BlockGenerator.AddCommand(runner.RunnerCmd)
+	BlockGenerator.AddCommand(generator.DaemonCmd)
+}
diff --git a/cmd/block-generator/daemon.go b/cmd/block-generator/generator/daemon.go
similarity index 52%
rename from cmd/block-generator/daemon.go
rename to cmd/block-generator/generator/daemon.go
index 780c726c7..ac60a40ed 100644
--- a/cmd/block-generator/daemon.go
+++ b/cmd/block-generator/generator/daemon.go
@@ -1,34 +1,33 @@
-package main
+package generator
 
 import (
 	"fmt"
 	"math/rand"
 
 	"github.com/spf13/cobra"
-
-	"github.com/algorand/indexer/cmd/block-generator/generator"
 )
 
+// DaemonCmd starts a block generator daemon.
+var DaemonCmd *cobra.Command
+
 func init() {
 	rand.Seed(12345)
 
 	var configFile string
 	var port uint64
 
-	var daemonCmd = &cobra.Command{
+	DaemonCmd = &cobra.Command{
 		Use:   "daemon",
 		Short: "Start the generator daemon in standalone mode.",
 		Run: func(cmd *cobra.Command, args []string) {
 			addr := fmt.Sprintf(":%d", port)
-			srv, _ := generator.MakeServer(configFile, addr)
+			srv, _ := MakeServer(configFile, addr)
 			srv.ListenAndServe()
 		},
 	}
 
-	daemonCmd.Flags().StringVarP(&configFile, "config", "c", "", "Specify the block configuration yaml file.")
-	daemonCmd.Flags().Uint64VarP(&port, "port", "p", 4010, "Port to start the server at.")
-
-	daemonCmd.MarkFlagRequired("config")
+	DaemonCmd.Flags().StringVarP(&configFile, "config", "c", "", "Specify the block configuration yaml file.")
+	DaemonCmd.Flags().Uint64VarP(&port, "port", "p", 4010, "Port to start the server at.")
 
-	rootCmd.AddCommand(daemonCmd)
+	DaemonCmd.MarkFlagRequired("config")
 }
diff --git a/cmd/block-generator/main.go b/cmd/block-generator/main.go
index 26622fa9b..810321f17 100644
--- a/cmd/block-generator/main.go
+++ b/cmd/block-generator/main.go
@@ -1,12 +1,7 @@
 package main
 
-import "github.com/spf13/cobra"
-
-var rootCmd = &cobra.Command{
-	Use:   `block-generator`,
-	Short: `Block generator testing tools.`,
-}
+import "github.com/algorand/indexer/cmd/block-generator/core"
 
 func main() {
-	rootCmd.Execute()
+	core.BlockGenerator.Execute()
 }
diff --git a/cmd/block-generator/runner.go b/cmd/block-generator/runner.go
deleted file mode 100644
index 0a231ea69..000000000
--- a/cmd/block-generator/runner.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"math/rand"
-	"time"
-
-	"github.com/spf13/cobra"
-
-	"github.com/algorand/indexer/cmd/block-generator/runner"
-)
-
-func init() {
-	rand.Seed(12345)
-	var runnerArgs runner.Args
-
-	var runnerCmd = &cobra.Command{
-		Use:   "runner",
-		Short: "Run test suite and collect results.",
-		Run: func(cmd *cobra.Command, args []string) {
-			if err := runner.Run(runnerArgs); err != nil {
-				fmt.Println(err)
-			}
-		},
-	}
-
-	runnerCmd.Flags().StringVarP(&runnerArgs.Path, "scenario", "s", "", "Directory containing scenarios, or specific scenario file.")
-	runnerCmd.Flags().StringVarP(&runnerArgs.IndexerBinary, "indexer-binary", "i", "", "Path to indexer binary.")
-	runnerCmd.Flags().Uint64VarP(&runnerArgs.IndexerPort, "indexer-port", "p", 4010, "Port to start the server at. This is useful if you have a prometheus server for collecting additional data.")
-	runnerCmd.Flags().StringVarP(&runnerArgs.PostgresConnectionString, "postgres-connection-string", "c", "", "Postgres connection string.")
-	runnerCmd.Flags().DurationVarP(&runnerArgs.RunDuration, "test-duration", "d", 5*time.Minute, "Duration to use for each scenario.")
-	runnerCmd.Flags().StringVarP(&runnerArgs.ReportDirectory, "report-directory", "r", "", "Location to place test reports.")
-	runnerCmd.Flags().StringVarP(&runnerArgs.LogLevel, "log-level", "l", "error", "LogLevel to use when starting Indexer. [error, warn, info, debug, trace]")
-	runnerCmd.Flags().StringVarP(&runnerArgs.CPUProfilePath, "cpuprofile", "", "", "Path where Indexer writes its CPU profile.")
-	runnerCmd.Flags().BoolVarP(&runnerArgs.ResetReportDir, "reset", "", false, "If set any existing report directory will be deleted before running tests.")
-	runnerCmd.Flags().BoolVarP(&runnerArgs.RunValidation, "validate", "", false, "If set the validator will run after test-duration has elapsed to verify data is correct. An extra line in each report indicates validator success or failure.")
-
-	runnerCmd.MarkFlagRequired("scenario")
-	runnerCmd.MarkFlagRequired("indexer-binary")
-	runnerCmd.MarkFlagRequired("postgres-connection-string")
-	runnerCmd.MarkFlagRequired("report-directory")
-
-	rootCmd.AddCommand(runnerCmd)
-}
diff --git a/cmd/block-generator/runner/runner.go b/cmd/block-generator/runner/runner.go
new file mode 100644
index 000000000..5d42a879a
--- /dev/null
+++ b/cmd/block-generator/runner/runner.go
@@ -0,0 +1,44 @@
+package runner
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+// RunnerCmd launches the block-generator test suite runner.
+var RunnerCmd *cobra.Command
+
+func init() {
+	rand.Seed(12345)
+	var runnerArgs Args
+
+	RunnerCmd = &cobra.Command{
+		Use:   "runner",
+		Short: "Run test suite and collect results.",
+		Long:  "Run an automated test suite using the block-generator daemon and a provided algorand-indexer binary. Results are captured to a specified output directory.",
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := Run(runnerArgs); err != nil {
+				fmt.Println(err)
+			}
+		},
+	}
+
+	RunnerCmd.Flags().StringVarP(&runnerArgs.Path, "scenario", "s", "", "Directory containing scenarios, or specific scenario file.")
+	RunnerCmd.Flags().StringVarP(&runnerArgs.IndexerBinary, "indexer-binary", "i", "", "Path to indexer binary.")
+	RunnerCmd.Flags().Uint64VarP(&runnerArgs.IndexerPort, "indexer-port", "p", 4010, "Port to start the server at. This is useful if you have a prometheus server for collecting additional data.")
+	RunnerCmd.Flags().StringVarP(&runnerArgs.PostgresConnectionString, "postgres-connection-string", "c", "", "Postgres connection string.")
+	RunnerCmd.Flags().DurationVarP(&runnerArgs.RunDuration, "test-duration", "d", 5*time.Minute, "Duration to use for each scenario.")
+	RunnerCmd.Flags().StringVarP(&runnerArgs.ReportDirectory, "report-directory", "r", "", "Location to place test reports.")
+	RunnerCmd.Flags().StringVarP(&runnerArgs.LogLevel, "log-level", "l", "error", "LogLevel to use when starting Indexer. [error, warn, info, debug, trace]")
+	RunnerCmd.Flags().StringVarP(&runnerArgs.CPUProfilePath, "cpuprofile", "", "", "Path where Indexer writes its CPU profile.")
+	RunnerCmd.Flags().BoolVarP(&runnerArgs.ResetReportDir, "reset", "", false, "If set any existing report directory will be deleted before running tests.")
+	RunnerCmd.Flags().BoolVarP(&runnerArgs.RunValidation, "validate", "", false, "If set the validator will run after test-duration has elapsed to verify data is correct. An extra line in each report indicates validator success or failure.")
+
+	RunnerCmd.MarkFlagRequired("scenario")
+	RunnerCmd.MarkFlagRequired("indexer-binary")
+	RunnerCmd.MarkFlagRequired("postgres-connection-string")
+	RunnerCmd.MarkFlagRequired("report-directory")
+}
diff --git a/cmd/import-validator/core/command.go b/cmd/import-validator/core/command.go
index b33ccffbc..8c07a8f5b 100644
--- a/cmd/import-validator/core/command.go
+++ b/cmd/import-validator/core/command.go
@@ -2,7 +2,7 @@ package core
 
 import "github.com/spf13/cobra"
 
-// ImportValidatorCmd is a configured cobra command to be executed, or included as a subcommand.
+// ImportValidatorCmd is the real-time import validator command.
 var ImportValidatorCmd *cobra.Command
 
 func init() {
diff --git a/cmd/validator/core/command.go b/cmd/validator/core/command.go
new file mode 100644
index 000000000..a5180f674
--- /dev/null
+++ b/cmd/validator/core/command.go
@@ -0,0 +1,187 @@
+package core
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+// ValidatorCmd is the account validator utility.
+var ValidatorCmd *cobra.Command
+
+func init() {
+	var (
+		config       Params
+		addr         string
+		threads      int
+		processorNum int
+		printCurl    bool
+	)
+
+	ValidatorCmd = &cobra.Command{
+		Use:   "validator",
+		Short: "validator",
+		Long:  "Compare algod and indexer to each other and report any discrepencies.",
+		Run: func(cmd *cobra.Command, _ []string) {
+			run(config, addr, threads, processorNum, printCurl)
+		},
+	}
+
+	ValidatorCmd.Flags().StringVar(&config.AlgodURL, "algod-url", "", "Algod url.")
+	ValidatorCmd.MarkFlagRequired("algod-url")
+	ValidatorCmd.Flags().StringVar(&config.AlgodToken, "algod-token", "", "Algod token.")
+	ValidatorCmd.Flags().StringVar(&config.IndexerURL, "indexer-url", "", "Indexer url.")
+	ValidatorCmd.MarkFlagRequired("indexer-url")
+	ValidatorCmd.Flags().StringVar(&config.IndexerToken, "indexer-token", "", "Indexer token.")
+	ValidatorCmd.Flags().IntVarP(&config.Retries, "retries", "", 5, "Number of retry attempts when a difference is detected.")
+	ValidatorCmd.Flags().IntVarP(&config.RetryDelayMS, "retry-delay", "", 1000, "Time in milliseconds to sleep between retries.")
+	ValidatorCmd.Flags().StringVar(&addr, "addr", "", "If provided validate a single address instead of reading Stdin.")
+	ValidatorCmd.Flags().IntVar(&threads, "threads", 4, "Number of worker threads to initialize.")
+	ValidatorCmd.Flags().IntVar(&threads, "processor", 0, "Choose compare algorithm [0 = Struct, 1 = Reflection]")
+	ValidatorCmd.Flags().BoolVar(&printCurl, "print-commands", false, "Print curl commands, including tokens, to query algod and indexer.")
+}
+
+func run(config Params, addr string, threads int, processorNum int, printCurl bool) {
+	if len(config.AlgodURL) == 0 {
+		ErrorLog.Fatalf("algod-url parameter is required.")
+	}
+	if len(config.AlgodToken) == 0 {
+		ErrorLog.Fatalf("algod-token parameter is required.")
+	}
+	if len(config.IndexerURL) == 0 {
+		ErrorLog.Fatalf("indexer-url parameter is required.")
+	}
+
+	results := make(chan Result, 10)
+
+	go func() {
+		if len(addr) != 0 {
+			processor, err := MakeProcessor(ProcessorID(processorNum))
+			if err != nil {
+				ErrorLog.Fatalf("%s.\n", err)
+			}
+
+			// Process a single address
+			CallProcessor(processor, addr, config, results)
+			close(results)
+		} else {
+			// Process from stdin
+			start(ProcessorID(processorNum), threads, config, results)
+		}
+	}()
+
+	// This will keep going until the results channel is closed.
+	numErrors := resultsPrinter(config, printCurl, results)
+	if numErrors > 0 {
+		os.Exit(1)
+	}
+}
+
+// start kicks off a bunch of  go routines to compare addresses, it also creates a work channel to feed the workers and
+// fills the work channel by reading from os.Stdin. Results are returned to the results channel.
+func start(processorID ProcessorID, threads int, config Params, results chan<- Result) {
+	work := make(chan string, 100*threads)
+
+	// Read addresses from stdin and pass along to workers
+	go func() {
+		scanner := bufio.NewScanner(os.Stdin)
+		for scanner.Scan() {
+			work <- scanner.Text()
+		}
+		close(work)
+	}()
+
+	Start(work, processorID, threads, config, results)
+}
+
+// resultChar picks the appropriate status character for the output.
+func resultChar(success bool, retries int) string {
+	if success && retries == 0 {
+		return "."
+	}
+	if success && retries > 9 {
+		return fmt.Sprintf("(%d)", retries)
+	}
+	if success {
+		return fmt.Sprintf("%d", retries)
+	}
+	return "X"
+}
+
+// resultsPrinter reads the results channel and prints it to the error log. Returns the number of errors.
+func resultsPrinter(config Params, printCurl bool, results <-chan Result) int {
+	numResults := 0
+	numErrors := 0
+	numRetries := 0
+	startTime := time.Now()
+
+	stats := func() {
+		endTime := time.Now()
+		duration := endTime.Sub(startTime)
+		fmt.Printf("\n\nNumber of errors: [%d / %d]\n", numErrors, numResults)
+		fmt.Printf("Retry count: %d\n", numRetries)
+		fmt.Printf("Checks per second: %f\n", float64(numResults+numRetries)/duration.Seconds())
+		fmt.Printf("Test duration: %s\n", time.Time{}.Add(duration).Format("15:04:05"))
+	}
+
+	// Print stats at the end when things terminate naturally.
+	defer stats()
+
+	// Also print stats as the program exits after being interrupted.
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, os.Interrupt, syscall.SIGTERM, syscall.SIGINT)
+	go func() {
+		<-quit
+		stats()
+		os.Exit(1)
+	}()
+
+	// Process results. Print progress to stdout and log errors to errorLog.
+	for r := range results {
+		if numResults%100 == 0 {
+			fmt.Printf("\n%-8d : ", numResults)
+		}
+		fmt.Printf("%s", resultChar(r.Equal, r.Retries))
+
+		numResults++
+		numRetries += r.Retries
+		if r.Error != nil || !r.Equal {
+			numErrors++
+			ErrorLog.Printf("===================================================================")
+			ErrorLog.Printf("%s", time.Now().Format("2006-01-02 3:4:5 PM"))
+			ErrorLog.Printf("Account: %s", r.Details.Address)
+			ErrorLog.Printf("Error #: %d", numErrors)
+			ErrorLog.Printf("Retries: %d", r.Retries)
+			ErrorLog.Printf("Rounds Match: %t", r.SameRound)
+
+			// Print error message if there is one.
+			if r.Error != nil {
+				ErrorLog.Printf("Processor error: %v\n", r.Error)
+			} else {
+				// Print error details if there are any.
+				if r.Details != nil {
+					ErrorLog.Printf("Algod Details:\n%s", r.Details.Algod)
+					ErrorLog.Printf("Indexer Details:\n%s", r.Details.Indexer)
+					ErrorLog.Printf("Differences:")
+					for _, diff := range r.Details.Diff {
+						ErrorLog.Printf("     - %s", diff)
+					}
+				}
+				// Optionally print curl command.
+				if printCurl {
+					ErrorLog.Printf("echo 'Algod:'")
+					ErrorLog.Printf("curl -q -s -H 'Authorization: Bearer %s' '%s/v2/accounts/%s?pretty'", config.AlgodToken, config.AlgodURL, r.Details.Address)
+					ErrorLog.Printf("echo 'Indexer:'")
+					ErrorLog.Printf("curl -q -s -H 'Authorization: Bearer %s' '%s/v2/accounts/%s?pretty'", config.IndexerToken, config.IndexerURL, r.Details.Address)
+				}
+			}
+		}
+	}
+
+	return numErrors
+}
diff --git a/cmd/validator/main.go b/cmd/validator/main.go
index c59403af4..4411bd793 100644
--- a/cmd/validator/main.go
+++ b/cmd/validator/main.go
@@ -1,173 +1,7 @@
 package main
 
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
-
-	"github.com/algorand/indexer/cmd/validator/core"
-)
+import "github.com/algorand/indexer/cmd/validator/core"
 
 func main() {
-	var (
-		config       core.Params
-		addr         string
-		threads      int
-		processorNum int
-		printCurl    bool
-	)
-
-	flag.StringVar(&config.AlgodURL, "algod-url", "", "Algod url.")
-	flag.StringVar(&config.AlgodToken, "algod-token", "", "Algod token.")
-	flag.StringVar(&config.IndexerURL, "indexer-url", "", "Indexer url.")
-	flag.StringVar(&config.IndexerToken, "indexer-token", "", "Indexer toke.n")
-	flag.StringVar(&addr, "addr", "", "If provided validate a single address instead of reading Stdin.")
-	flag.IntVar(&config.Retries, "retries", 5, "Number of retry attempts when a difference is detected.")
-	flag.IntVar(&config.RetryDelayMS, "retry-delay", 1000, "Time in milliseconds to sleep between retries.")
-	flag.IntVar(&threads, "threads", 4, "Number of worker threads to initialize.")
-	flag.IntVar(&processorNum, "processor", 0, "Choose compare algorithm [0 = Struct, 1 = Reflection]")
-	flag.BoolVar(&printCurl, "print-commands", false, "Print curl commands, including tokens, to query algod and indexer.")
-	flag.Parse()
-
-	if len(config.AlgodURL) == 0 {
-		core.ErrorLog.Fatalf("algod-url parameter is required.")
-	}
-	if len(config.AlgodToken) == 0 {
-		core.ErrorLog.Fatalf("algod-token parameter is required.")
-	}
-	if len(config.IndexerURL) == 0 {
-		core.ErrorLog.Fatalf("indexer-url parameter is required.")
-	}
-
-	results := make(chan core.Result, 10)
-
-	go func() {
-		if len(addr) != 0 {
-			processor, err := core.MakeProcessor(core.ProcessorID(processorNum))
-			if err != nil {
-				core.ErrorLog.Fatalf("%s.\n", err)
-			}
-
-			// Process a single address
-			core.CallProcessor(processor, addr, config, results)
-			close(results)
-		} else {
-			// Process from stdin
-			start(core.ProcessorID(processorNum), threads, config, results)
-		}
-	}()
-
-	// This will keep going until the results channel is closed.
-	numErrors := resultsPrinter(config, printCurl, results)
-	if numErrors > 0 {
-		os.Exit(1)
-	}
-}
-
-// start kicks off a bunch of  go routines to compare addresses, it also creates a work channel to feed the workers and
-// fills the work channel by reading from os.Stdin. Results are returned to the results channel.
-func start(processorID core.ProcessorID, threads int, config core.Params, results chan<- core.Result) {
-	work := make(chan string, 100*threads)
-
-	// Read addresses from stdin and pass along to workers
-	go func() {
-		scanner := bufio.NewScanner(os.Stdin)
-		for scanner.Scan() {
-			work <- scanner.Text()
-		}
-		close(work)
-	}()
-
-	core.Start(work, processorID, threads, config, results)
-}
-
-// resultChar picks the appropriate status character for the output.
-func resultChar(success bool, retries int) string {
-	if success && retries == 0 {
-		return "."
-	}
-	if success && retries > 9 {
-		return fmt.Sprintf("(%d)", retries)
-	}
-	if success {
-		return fmt.Sprintf("%d", retries)
-	}
-	return "X"
-}
-
-// resultsPrinter reads the results channel and prints it to the error log. Returns the number of errors.
-func resultsPrinter(config core.Params, printCurl bool, results <-chan core.Result) int {
-	numResults := 0
-	numErrors := 0
-	numRetries := 0
-	startTime := time.Now()
-
-	stats := func() {
-		endTime := time.Now()
-		duration := endTime.Sub(startTime)
-		fmt.Printf("\n\nNumber of errors: [%d / %d]\n", numErrors, numResults)
-		fmt.Printf("Retry count: %d\n", numRetries)
-		fmt.Printf("Checks per second: %f\n", float64(numResults+numRetries)/duration.Seconds())
-		fmt.Printf("Test duration: %s\n", time.Time{}.Add(duration).Format("15:04:05"))
-	}
-
-	// Print stats at the end when things terminate naturally.
-	defer stats()
-
-	// Also print stats as the program exits after being interrupted.
-	quit := make(chan os.Signal, 1)
-	signal.Notify(quit, os.Interrupt, syscall.SIGTERM, syscall.SIGINT)
-	go func() {
-		<-quit
-		stats()
-		os.Exit(1)
-	}()
-
-	// Process results. Print progress to stdout and log errors to errorLog.
-	for r := range results {
-		if numResults%100 == 0 {
-			fmt.Printf("\n%-8d : ", numResults)
-		}
-		fmt.Printf("%s", resultChar(r.Equal, r.Retries))
-
-		numResults++
-		numRetries += r.Retries
-		if r.Error != nil || !r.Equal {
-			numErrors++
-			core.ErrorLog.Printf("===================================================================")
-			core.ErrorLog.Printf("%s", time.Now().Format("2006-01-02 3:4:5 PM"))
-			core.ErrorLog.Printf("Account: %s", r.Details.Address)
-			core.ErrorLog.Printf("Error #: %d", numErrors)
-			core.ErrorLog.Printf("Retries: %d", r.Retries)
-			core.ErrorLog.Printf("Rounds Match: %t", r.SameRound)
-
-			// Print error message if there is one.
-			if r.Error != nil {
-				core.ErrorLog.Printf("Processor error: %v\n", r.Error)
-			} else {
-				// Print error details if there are any.
-				if r.Details != nil {
-					core.ErrorLog.Printf("Algod Details:\n%s", r.Details.Algod)
-					core.ErrorLog.Printf("Indexer Details:\n%s", r.Details.Indexer)
-					core.ErrorLog.Printf("Differences:")
-					for _, diff := range r.Details.Diff {
-						core.ErrorLog.Printf("     - %s", diff)
-					}
-				}
-				// Optionally print curl command.
-				if printCurl {
-					core.ErrorLog.Printf("echo 'Algod:'")
-					core.ErrorLog.Printf("curl -q -s -H 'Authorization: Bearer %s' '%s/v2/accounts/%s?pretty'", config.AlgodToken, config.AlgodURL, r.Details.Address)
-					core.ErrorLog.Printf("echo 'Indexer:'")
-					core.ErrorLog.Printf("curl -q -s -H 'Authorization: Bearer %s' '%s/v2/accounts/%s?pretty'", config.IndexerToken, config.IndexerURL, r.Details.Address)
-				}
-			}
-		}
-	}
-
-	return numErrors
+	core.ValidatorCmd.Execute()
 }

From 8b58e4bf8fa512fab428cabaf94debda6991fb66 Mon Sep 17 00:00:00 2001
From: AlgoStephenAkiki <85183435+AlgoStephenAkiki@users.noreply.github.com>
Date: Tue, 1 Mar 2022 16:35:58 -0500
Subject: [PATCH 15/29] Allow Viewing of Disabled Params (#902)

* Allow Viewing of Disabled Params

Resolves #3583

Add a new subcommand "algorand-indexer api-config" to show current
config

* Mod file

* PR comments

* PR comments
---
 README.md                          | 44 ++++++++++++++
 api/disabled_parameters.go         | 95 ++++++++++++++++++++++++++++++
 api/server.go                      |  9 ++-
 cmd/algorand-indexer/api_config.go | 63 ++++++++++++++++++++
 cmd/algorand-indexer/daemon.go     |  6 ++
 cmd/algorand-indexer/main.go       |  1 +
 go.mod                             |  1 +
 7 files changed, 214 insertions(+), 5 deletions(-)
 create mode 100644 cmd/algorand-indexer/api_config.go

diff --git a/README.md b/README.md
index a58e6aafd..3ce5ee47e 100644
--- a/README.md
+++ b/README.md
@@ -112,6 +112,50 @@ When `--token your-token` is provided, an authentication header is required. For
 ~$ curl localhost:8980/transactions -H "X-Indexer-API-Token: your-token"
 ```
 
+## Disabling Parameters 
+
+The Indexer has the ability to selectively enable or disable parameters for endpoints.  Disabling a "required" parameter will result in the entire endpoint being disabled while disabling an "optional" parameter will cause an error to be returned only if the parameter is provided.
+
+### Viewing the Current Configuration
+
+The Indexer has a default set of disabled parameters.  To view the disabled parameters issue:
+```
+~$ algorand-indexer api-config
+```
+
+This will output ONLY the disabled parameters in a YAML configuration.  To view all parameters (both enabled and disabled) issue:
+
+```
+~$ algorand-indexer api-config --all
+```
+
+### Interpreting The Configuration
+
+Below is a snippet of the output from `algorand-indexer api-config`:
+
+```
+/v2/accounts:
+    optional:
+        - currency-greater-than: disabled
+        - currency-less-than: disabled
+/v2/assets/{asset-id}/transactions:
+    optional:
+        - note-prefix: disabled
+        - tx-type: disabled
+        - sig-type: disabled
+        - before-time: disabled
+        - after-time: disabled
+        - currency-greater-than: disabled
+        - currency-less-than: disabled
+        - address-role: disabled
+        - exclude-close-to: disabled
+        - rekey-to: disabled
+    required:
+        - asset-id: disabled
+```
+
+Seeing this we know that the `/v2/accounts` endpoint will return an error if either `currency-greater-than` or `currency-less-than` is provided.  Additionally, because a "required" parameter is provided for `/v2/assets/{asset-id}/transactions` then we know this entire endpoint is disabled.  The optional parameters are provided so that you can understand what else is disabled if you enable all "required" parameters.
+
 ## Metrics
 
 The `/metrics` endpoint is configured with the `--metrics-mode` option and configures if and how [Prometheus](https://prometheus.io/) formatted metrics are generated.
diff --git a/api/disabled_parameters.go b/api/disabled_parameters.go
index 33fd3eaed..33fbc8b6c 100644
--- a/api/disabled_parameters.go
+++ b/api/disabled_parameters.go
@@ -7,8 +7,103 @@ import (
 
 	"github.com/getkin/kin-openapi/openapi3"
 	"github.com/labstack/echo/v4"
+	"gopkg.in/yaml.v3"
 )
 
+// DisplayDisabledMap is a struct that contains the necessary information
+// to output the current config to the screen
+type DisplayDisabledMap struct {
+	// A complicated map but necessary to output the correct YAML.
+	// This is supposed to represent a data structure with a similar YAML
+	// representation:
+	//  /v2/accounts/{account-id}:
+	//    required:
+	//      - account-id : enabled
+	//  /v2/accounts:
+	//    optional:
+	//      - auth-addr : enabled
+	//      - next: disabled
+	Data map[string]map[string][]map[string]string
+}
+
+func (ddm *DisplayDisabledMap) String() (string, error) {
+
+	if len(ddm.Data) == 0 {
+		return "", nil
+	}
+
+	bytes, err := yaml.Marshal(ddm.Data)
+	if err != nil {
+		return "", err
+	}
+
+	return string(bytes), nil
+}
+
+func makeDisplayDisabledMap() *DisplayDisabledMap {
+	return &DisplayDisabledMap{
+		Data: make(map[string]map[string][]map[string]string),
+	}
+}
+
+func (ddm *DisplayDisabledMap) addEntry(restPath string, requiredOrOptional string, entryName string, status string) {
+	if ddm.Data == nil {
+		ddm.Data = make(map[string]map[string][]map[string]string)
+	}
+
+	if ddm.Data[restPath] == nil {
+		ddm.Data[restPath] = make(map[string][]map[string]string)
+	}
+
+	mapEntry := map[string]string{entryName: status}
+
+	ddm.Data[restPath][requiredOrOptional] = append(ddm.Data[restPath][requiredOrOptional], mapEntry)
+}
+
+// MakeDisplayDisabledMapFromConfig will make a DisplayDisabledMap that takes into account the DisabledMapConfig.
+// If limited is set to true, then only disabled parameters will be added to the DisplayDisabledMap
+func MakeDisplayDisabledMapFromConfig(swag *openapi3.Swagger, mapConfig *DisabledMapConfig, limited bool) *DisplayDisabledMap {
+
+	rval := makeDisplayDisabledMap()
+	for restPath, item := range swag.Paths {
+
+		for opName, opItem := range item.Operations() {
+
+			for _, pref := range opItem.Parameters {
+
+				paramName := pref.Value.Name
+
+				parameterIsDisabled := mapConfig.isDisabled(restPath, opName, paramName)
+				// If we are limited, then don't bother with enabled parameters
+				if !parameterIsDisabled && limited {
+					// If the parameter is not disabled, then we don't need
+					// to do anything
+					continue
+				}
+
+				var statusStr string
+
+				if parameterIsDisabled {
+					statusStr = "disabled"
+				} else {
+					statusStr = "enabled"
+				}
+
+				if pref.Value.Required {
+					rval.addEntry(restPath, "required", paramName, statusStr)
+				} else {
+					// If the optional parameter is disabled, add it to the map
+					rval.addEntry(restPath, "optional", paramName, statusStr)
+				}
+			}
+
+		}
+
+	}
+
+	return rval
+}
+
 // EndpointConfig is a data structure that contains whether the
 // endpoint is disabled (with a boolean) as well as a set that
 // contains disabled optional parameters.  The disabled optional parameter
diff --git a/api/server.go b/api/server.go
index b808cfdfd..74f5616ee 100644
--- a/api/server.go
+++ b/api/server.go
@@ -37,6 +37,9 @@ type ExtraOptions struct {
 
 	// ReadTimeout is the maximum duration for reading the entire request, including the body.
 	ReadTimeout time.Duration
+
+	// DisabledMapConfig is the disabled map configuration that is being used by the server
+	DisabledMapConfig *DisabledMapConfig
 }
 
 func (e ExtraOptions) handlerTimeout() time.Duration {
@@ -83,11 +86,7 @@ func Serve(ctx context.Context, serveAddr string, db idb.IndexerDb, fetcherError
 		log.Fatal(err)
 	}
 
-	// TODO enable this when command line options allows for disabling/enabling overrides
-	//disabledMapConfig := GetDefaultDisabledMapConfigForPostgres()
-	disabledMapConfig := MakeDisabledMapConfig()
-
-	disabledMap, err := MakeDisabledMapFromOA3(swag, disabledMapConfig)
+	disabledMap, err := MakeDisabledMapFromOA3(swag, options.DisabledMapConfig)
 	if err != nil {
 		log.Fatal(err)
 	}
diff --git a/cmd/algorand-indexer/api_config.go b/cmd/algorand-indexer/api_config.go
new file mode 100644
index 000000000..acdb6d1f6
--- /dev/null
+++ b/cmd/algorand-indexer/api_config.go
@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/algorand/indexer/api"
+	"github.com/algorand/indexer/api/generated/v2"
+	"github.com/algorand/indexer/config"
+)
+
+var (
+	showAllDisabled bool
+)
+
+var apiConfigCmd = &cobra.Command{
+	Use:   "api-config",
+	Short: "dump api configuration",
+	Long:  "dump api configuration",
+	//Args:
+	Run: func(cmd *cobra.Command, args []string) {
+		var err error
+		config.BindFlags(cmd)
+		err = configureLogger()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to configure logger: %v", err)
+			os.Exit(1)
+		}
+		swag, err := generated.GetSwagger()
+
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to get swagger: %v", err)
+			os.Exit(1)
+		}
+
+		options := makeOptions()
+
+		var displayDisabledMapConfig *api.DisplayDisabledMap
+		// Show a limited subset
+		if !showAllDisabled {
+			displayDisabledMapConfig = api.MakeDisplayDisabledMapFromConfig(swag, options.DisabledMapConfig, true)
+		} else {
+			displayDisabledMapConfig = api.MakeDisplayDisabledMapFromConfig(swag, options.DisabledMapConfig, false)
+		}
+
+		output, err := displayDisabledMapConfig.String()
+
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to output yaml: %v", err)
+			os.Exit(1)
+		}
+
+		fmt.Fprint(os.Stdout, output)
+		os.Exit(0)
+
+	},
+}
+
+func init() {
+	apiConfigCmd.Flags().BoolVar(&showAllDisabled, "all", false, "show all api config parameters, enabled and disabled")
+}
diff --git a/cmd/algorand-indexer/daemon.go b/cmd/algorand-indexer/daemon.go
index c587199f0..7f19634cc 100644
--- a/cmd/algorand-indexer/daemon.go
+++ b/cmd/algorand-indexer/daemon.go
@@ -175,6 +175,12 @@ func makeOptions() (options api.ExtraOptions) {
 	options.WriteTimeout = writeTimeout
 	options.ReadTimeout = readTimeout
 
+	// TODO enable this when command line options allows for disabling/enabling overrides
+	//disabledMapConfig := api.GetDefaultDisabledMapConfigForPostgres()
+	disabledMapConfig := api.MakeDisabledMapConfig()
+
+	options.DisabledMapConfig = disabledMapConfig
+
 	return
 }
 
diff --git a/cmd/algorand-indexer/main.go b/cmd/algorand-indexer/main.go
index 9243ced5a..7ca86e459 100644
--- a/cmd/algorand-indexer/main.go
+++ b/cmd/algorand-indexer/main.go
@@ -137,6 +137,7 @@ func init() {
 	rootCmd.AddCommand(importCmd)
 	importCmd.Hidden = true
 	rootCmd.AddCommand(daemonCmd)
+	rootCmd.AddCommand(apiConfigCmd)
 
 	// Not applied globally to avoid adding to utility commands.
 	addFlags := func(cmd *cobra.Command) {
diff --git a/go.mod b/go.mod
index ff6cc2bd9..fd43de5d5 100644
--- a/go.mod
+++ b/go.mod
@@ -27,4 +27,5 @@ require (
 	github.com/vektra/mockery v1.1.2 // indirect
 	golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 // indirect
 	golang.org/x/tools v0.1.9 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776
 )

From 1c0885c5cfe65913a9070af1a531336bcc081452 Mon Sep 17 00:00:00 2001
From: Michael Diamant <michaeldiamant@users.noreply.github.com>
Date: Wed, 2 Mar 2022 11:11:38 -0500
Subject: [PATCH 16/29] Document instructions for updating Indexer E2E test
 input (#906)

---
 misc/README.md | 12 ++++++++++++
 test/README.md | 16 +---------------
 2 files changed, 13 insertions(+), 15 deletions(-)
 create mode 100644 misc/README.md

diff --git a/misc/README.md b/misc/README.md
new file mode 100644
index 000000000..d1ee2f172
--- /dev/null
+++ b/misc/README.md
@@ -0,0 +1,12 @@
+# Indexer E2E tests
+
+`make e2e` runs tests with input generated by [go-algorand `e2e_subs` tests](https://github.com/algorand/go-algorand/blob/master/test/scripts/e2e_client_runner.py).  As of writing `make e2e` is the _only_ automated validation of indexer's consumption of algod output.
+
+The process for updating the `make e2e`'s input is manual.  Each time a go-algorand E2E test is modified, the test modifier _must_ generate new artifacts for `make e2e` consumption.  Here's the process:
+
+| Step                                                                                                                                                                                                                                                                           | Command/Action                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Run go-algorand `e2e_subs` tests to produce new Indexer E2E inputs.<br/>* See script comments for local environment setup.<br />* Expect tests to run for ~5-10min.                                                                                                            | `bash misc/buildtestdata.sh`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| Locally confirm Indexer E2E tests pass with new inputs.<br />* _Warning_:  Only use these commands locally because they're _not_ secure.<br />* The commands directly invoke `e2elive.py` to increase local iteration speed. `make e2e` spins up a Docker compose environment. | * `docker run -it --rm --name some-postgres -p 5432:5432 -e POSTGRES_HOST_AUTH_METHOD=trust -e POSTGRES_USER=$USER -e POSTGRES_DB=indexer_db_e2e postgres` <br/>* `python misc/e2elive.py --source-net $E2EDATA/net_done.tar.bz2 --connection-string "host=localhost port=5432 user=$USER dbname=indexer_db_e2e sslmode=disable"`<br /> * Look for `e2elive.py` output starting with: `indexer e2etest OK`.                                                                                                                                                            |
+| Upload test run artifacts to S3.<br/>* Publishing to S3 streamlines running the tests for other developers and CI.<br />* Request AWS account in #helpdesk and access key creation permission in #devops.                                                                      | Run the s3 copy command provided by `misc/buildtestdata.sh` output.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `make e2e` runs on every PR. Validate results on the next CI run.                                                                                                                                                                                                              | * Find the most recent workflow starting _after_ updating the S3 bucket:  [https://app.circleci.com/pipelines/github/algorand/indexer?branch=develop&filter=all](https://app.circleci.com/pipelines/github/algorand/indexer?branch=develop&filter=all).<br/>* If successful, confirm the test used the artifact you uploaded.  Click a job link, expand _make e2e_ and search for `INFO:util:s3://`.<br />* If unsuccessful, investigate source of error.  If additional help is needed, raise in #indexer.  It is _your_ responsibility to ensure the build is fixed. |
\ No newline at end of file
diff --git a/test/README.md b/test/README.md
index 05a61818d..f5944c4df 100644
--- a/test/README.md
+++ b/test/README.md
@@ -58,21 +58,7 @@ It may be useful to edit one of the entry point scripts to make sure the dataset
 
 When you have setup for an integration test, use the provided `rest_test` / `sql_test` functions to write your tests.
 
-This test loads an e2edata block archive + genesis dataset, you create one using the [buildtestdata.sh](../misc/buildtestdata.sh) script. You need to configure it with where to place the resulting archive, and your go-algorand directory. Here is an example script to setup everything:
-```bash
-#!/usr/bin/env bash
-
-rm -rf ve3
-export GOALGORAND="${GOPATH}/src/github.com/algorand/go-algorand"
-export E2EDATA="${HOME}/algorand/indexer/e2edata"
-export BUILD_BLOCK_ARCHIVE="yes please"
-rm -rf "$E2EDATA"
-mkdir -p "$E2EDATA"
-python3 -m venv ve3
-ve3/bin/pip install py-algorand-sdk
-. ve3/bin/activate
-./misc/buildtestdata.sh
-```
+This test loads an e2edata block archive + genesis dataset, you create one using the [buildtestdata.sh](../misc/buildtestdata.sh) script. See top-level comments in [buildtestdata.sh](../misc/buildtestdata.sh) for local environment setup instructions.
 
 The archive will be buried in the `E2EDATA` directory somewhere. That file is passed to start_indexer_with_blocks, then you just need to write the tests.
 

From 534f5a417658ce143f707a07fed8d03da670395d Mon Sep 17 00:00:00 2001
From: Michael Diamant <michaeldiamant@users.noreply.github.com>
Date: Mon, 7 Mar 2022 14:07:50 -0500
Subject: [PATCH 17/29] Update e2e_subs docs to revise artifact upload process
 (#910)

---
 misc/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/misc/README.md b/misc/README.md
index d1ee2f172..f692e104d 100644
--- a/misc/README.md
+++ b/misc/README.md
@@ -8,5 +8,5 @@ The process for updating the `make e2e`'s input is manual.  Each time a go-algor
 |--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | Run go-algorand `e2e_subs` tests to produce new Indexer E2E inputs.<br/>* See script comments for local environment setup.<br />* Expect tests to run for ~5-10min.                                                                                                            | `bash misc/buildtestdata.sh`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | Locally confirm Indexer E2E tests pass with new inputs.<br />* _Warning_:  Only use these commands locally because they're _not_ secure.<br />* The commands directly invoke `e2elive.py` to increase local iteration speed. `make e2e` spins up a Docker compose environment. | * `docker run -it --rm --name some-postgres -p 5432:5432 -e POSTGRES_HOST_AUTH_METHOD=trust -e POSTGRES_USER=$USER -e POSTGRES_DB=indexer_db_e2e postgres` <br/>* `python misc/e2elive.py --source-net $E2EDATA/net_done.tar.bz2 --connection-string "host=localhost port=5432 user=$USER dbname=indexer_db_e2e sslmode=disable"`<br /> * Look for `e2elive.py` output starting with: `indexer e2etest OK`.                                                                                                                                                            |
-| Upload test run artifacts to S3.<br/>* Publishing to S3 streamlines running the tests for other developers and CI.<br />* Request AWS account in #helpdesk and access key creation permission in #devops.                                                                      | Run the s3 copy command provided by `misc/buildtestdata.sh` output.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| Upload test run artifacts to S3.<br/>* Publishing to S3 streamlines running the tests for other developers and CI.<br />* If you don't have an AWS account, request artifact upload by pinging Will, Michael, or DevOps.                                                       | Run the s3 copy command provided by `misc/buildtestdata.sh` output.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `make e2e` runs on every PR. Validate results on the next CI run.                                                                                                                                                                                                              | * Find the most recent workflow starting _after_ updating the S3 bucket:  [https://app.circleci.com/pipelines/github/algorand/indexer?branch=develop&filter=all](https://app.circleci.com/pipelines/github/algorand/indexer?branch=develop&filter=all).<br/>* If successful, confirm the test used the artifact you uploaded.  Click a job link, expand _make e2e_ and search for `INFO:util:s3://`.<br />* If unsuccessful, investigate source of error.  If additional help is needed, raise in #indexer.  It is _your_ responsibility to ensure the build is fixed. |
\ No newline at end of file

From 4eaadebbfc650547f3dc7f6ad420fbd6b370c0eb Mon Sep 17 00:00:00 2001
From: shiqizng <80276844+shiqizng@users.noreply.github.com>
Date: Mon, 7 Mar 2022 14:14:02 -0500
Subject: [PATCH 18/29] Revert imported_tx_per_block change and add new
 imported_txns gauge. (#913)

---
 cmd/algorand-indexer/daemon.go |  3 ++-
 monitoring/dashboard.json      | 36 +++++++++++++++++-----------------
 util/metrics/metrics.go        | 14 +++++++++++--
 3 files changed, 32 insertions(+), 21 deletions(-)

diff --git a/cmd/algorand-indexer/daemon.go b/cmd/algorand-indexer/daemon.go
index 7f19634cc..aba744437 100644
--- a/cmd/algorand-indexer/daemon.go
+++ b/cmd/algorand-indexer/daemon.go
@@ -219,13 +219,14 @@ func handleBlock(block *rpcs.EncodedBlockCert, imp importer.Importer) error {
 	// Ignore round 0 (which is empty).
 	if block.Block.Round() > 0 {
 		metrics.BlockImportTimeSeconds.Observe(dt.Seconds())
+		metrics.ImportedTxnsPerBlock.Observe(float64(len(block.Block.Payset)))
 		metrics.ImportedRoundGauge.Set(float64(block.Block.Round()))
 		txnCountByType := make(map[string]int)
 		for _, txn := range block.Block.Payset {
 			txnCountByType[string(txn.Txn.Type)]++
 		}
 		for k, v := range txnCountByType {
-			metrics.ImportedTxnsPerBlock.WithLabelValues(k).Set(float64(v))
+			metrics.ImportedTxns.WithLabelValues(k).Set(float64(v))
 		}
 	}
 
diff --git a/monitoring/dashboard.json b/monitoring/dashboard.json
index 066c9668f..4b1e3b5cb 100644
--- a/monitoring/dashboard.json
+++ b/monitoring/dashboard.json
@@ -9,8 +9,8 @@
       "pluginName": "Prometheus"
     },
     {
-      "name": "DS_POSTGRESQL",
-      "label": "PostgreSQL",
+      "name": "DS_POSTGRESSQL",
+      "label": "PostgresSQL",
       "description": "",
       "type": "datasource",
       "pluginId": "postgres",
@@ -23,7 +23,7 @@
       "type": "grafana",
       "id": "grafana",
       "name": "Grafana",
-      "version": "8.3.6"
+      "version": "8.4.2"
     },
     {
       "type": "panel",
@@ -514,7 +514,7 @@
     {
       "datasource": {
         "type": "postgres",
-        "uid": "${DS_POSTGRESQL}"
+        "uid": "${DS_POSTGRESSQL}"
       },
       "fieldConfig": {
         "defaults": {
@@ -559,12 +559,12 @@
         },
         "showHeader": true
       },
-      "pluginVersion": "8.3.6",
+      "pluginVersion": "8.4.2",
       "targets": [
         {
           "datasource": {
             "type": "postgres",
-            "uid": "${DS_POSTGRESQL}"
+            "uid": "${DS_POSTGRESSQL}"
           },
           "format": "table",
           "group": [],
@@ -593,7 +593,7 @@
     {
       "datasource": {
         "type": "postgres",
-        "uid": "${DS_POSTGRESQL}"
+        "uid": "${DS_POSTGRESSQL}"
       },
       "fieldConfig": {
         "defaults": {
@@ -657,12 +657,12 @@
           }
         ]
       },
-      "pluginVersion": "8.3.6",
+      "pluginVersion": "8.4.2",
       "targets": [
         {
           "datasource": {
             "type": "postgres",
-            "uid": "${DS_POSTGRESQL}"
+            "uid": "${DS_POSTGRESSQL}"
           },
           "format": "table",
           "group": [],
@@ -781,7 +781,7 @@
             "uid": "${DS_INDEXERPROMETHEUS}"
           },
           "exemplar": true,
-          "expr": "sum(avg_over_time(indexer_daemon_imported_tx_per_block[10m])/4.3)",
+          "expr": "rate(indexer_daemon_imported_tx_per_block_sum{}[$__interval])/rate(indexer_daemon_imported_round[$__interval])",
           "interval": "",
           "legendFormat": "TPS",
           "refId": "A"
@@ -907,7 +907,7 @@
             "uid": "${DS_INDEXERPROMETHEUS}"
           },
           "exemplar": true,
-          "expr": "rate(indexer_daemon_get_algod_raw_block_time_sec_sum{}[1m])",
+          "expr": "rate(indexer_daemon_get_algod_raw_block_time_sec_sum{}[$__interval])",
           "format": "time_series",
           "instant": false,
           "interval": "",
@@ -920,7 +920,7 @@
             "uid": "${DS_INDEXERPROMETHEUS}"
           },
           "exemplar": true,
-          "expr": "sum(avg_over_time(indexer_daemon_imported_tx_per_block[1m]))",
+          "expr": "rate(indexer_daemon_imported_tx_per_block_sum{}[$__interval])",
           "hide": false,
           "interval": "",
           "legendFormat": "txns per block",
@@ -932,7 +932,7 @@
             "uid": "${DS_INDEXERPROMETHEUS}"
           },
           "exemplar": true,
-          "expr": "rate(indexer_daemon_import_time_sec_sum[1m])",
+          "expr": "rate(indexer_daemon_import_time_sec_sum[$__interval])",
           "hide": false,
           "interval": "",
           "legendFormat": "block import time (sec)",
@@ -1077,7 +1077,7 @@
             "uid": "${DS_INDEXERPROMETHEUS}"
           },
           "exemplar": true,
-          "expr": "delta(indexer_daemon_imported_round[$__interval])",
+          "expr": "rate(indexer_daemon_imported_round[$__interval])",
           "hide": false,
           "interval": "",
           "legendFormat": "rounds imported",
@@ -1168,7 +1168,7 @@
             "uid": "${DS_INDEXERPROMETHEUS}"
           },
           "exemplar": true,
-          "expr": "indexer_daemon_imported_tx_per_block",
+          "expr": "indexer_daemon_imported_txns",
           "interval": "",
           "legendFormat": "{{txn_type}}",
           "refId": "A"
@@ -1179,20 +1179,20 @@
     }
   ],
   "refresh": "",
-  "schemaVersion": 34,
+  "schemaVersion": 35,
   "style": "dark",
   "tags": [],
   "templating": {
     "list": []
   },
   "time": {
-    "from": "now-5m",
+    "from": "now-15m",
     "to": "now"
   },
   "timepicker": {},
   "timezone": "",
   "title": "Monitoring",
   "uid": "ArMgIZ-7z",
-  "version": 3,
+  "version": 9,
   "weekStart": ""
 }
\ No newline at end of file
diff --git a/util/metrics/metrics.go b/util/metrics/metrics.go
index bffdd452a..e9b9f1a09 100644
--- a/util/metrics/metrics.go
+++ b/util/metrics/metrics.go
@@ -11,6 +11,7 @@ func RegisterPrometheusMetrics() {
 	prometheus.Register(BlockUploadTimeSeconds)
 	prometheus.Register(PostgresEvalTimeSeconds)
 	prometheus.Register(GetAlgodRawBlockTimeSeconds)
+	prometheus.Register(ImportedTxns)
 }
 
 // Prometheus metric names broken out for reuse.
@@ -21,6 +22,7 @@ const (
 	ImportedRoundGaugeName   = "imported_round"
 	PostgresEvalName         = "postgres_eval_time_sec"
 	GetAlgodRawBlockTimeName = "get_algod_raw_block_time_sec"
+	ImportedTxnsName         = "imported_txns"
 )
 
 // AllMetricNames is a reference for all the custom metric names.
@@ -49,12 +51,20 @@ var (
 			Help:      "Block upload time in seconds.",
 		})
 
-	ImportedTxnsPerBlock = prometheus.NewGaugeVec(
-		prometheus.GaugeOpts{
+	ImportedTxnsPerBlock = prometheus.NewSummary(
+		prometheus.SummaryOpts{
 			Subsystem: "indexer_daemon",
 			Name:      ImportedTxnsPerBlockName,
 			Help:      "Transactions per block.",
 		},
+	)
+
+	ImportedTxns = prometheus.NewGaugeVec(
+		prometheus.GaugeOpts{
+			Subsystem: "indexer_daemon",
+			Name:      ImportedTxnsName,
+			Help:      "Imported transactions grouped by type",
+		},
 		[]string{"txn_type"},
 	)
 

From 5b88518ed6fefd5eea1ded89351710e924d140a3 Mon Sep 17 00:00:00 2001
From: AlgoStephenAkiki <85183435+AlgoStephenAkiki@users.noreply.github.com>
Date: Wed, 9 Mar 2022 09:32:03 -0500
Subject: [PATCH 19/29] Enable Validation and Acceptance of New Parameter
 Configuration (#912)

* Init

* Enable Validation and Acceptance of New Parameter Configuration

Resolves #3584

- Allows for the supplying of configuration files for the daemon and
api-config subcommands.
- Properly validates the schema and contents of the supplied config file
- Enables default parameters to be disabled, allows integration tests to
  run with all parameters enabled

* Removed reflect deep equal for unit test

* Changed expectError to a string from a boolean

* Added checking of supplied file with enable all params
---
 api/disabled_parameters.go                    | 143 +++++++++++++++-
 api/disabled_parameters_test.go               | 162 ++++++++++++++++++
 .../mock_disabled_map_config.yaml             |   6 +
 cmd/algorand-indexer/api_config.go            |  17 +-
 cmd/algorand-indexer/daemon.go                |  68 ++++++--
 test/common.sh                                |   1 +
 6 files changed, 366 insertions(+), 31 deletions(-)
 create mode 100644 api/test_resources/mock_disabled_map_config.yaml

diff --git a/api/disabled_parameters.go b/api/disabled_parameters.go
index 33fbc8b6c..3769e9708 100644
--- a/api/disabled_parameters.go
+++ b/api/disabled_parameters.go
@@ -2,6 +2,7 @@ package api
 
 import (
 	"fmt"
+	"io/ioutil"
 	"net/http"
 	"strings"
 
@@ -10,6 +11,13 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
+const (
+	disabledStatusStr    = "disabled"
+	enabledStatusStr     = "enabled"
+	requiredParameterStr = "required"
+	optionalParameterStr = "optional"
+)
+
 // DisplayDisabledMap is a struct that contains the necessary information
 // to output the current config to the screen
 type DisplayDisabledMap struct {
@@ -60,6 +68,125 @@ func (ddm *DisplayDisabledMap) addEntry(restPath string, requiredOrOptional stri
 	ddm.Data[restPath][requiredOrOptional] = append(ddm.Data[restPath][requiredOrOptional], mapEntry)
 }
 
+// validateSchema takes in a newly loaded DisplayDisabledMap and validates that all the
+// "strings" are the correct values.  For instance, it says that the sub-config is either
+// "required" or "optional" as well as making sure the string values for the parameters
+// are either "enabled" or "disabled".
+//
+// However, it does not validate whether the values actually exist.  That comes with the "Validate"
+// function on a DisabledMapConfig
+func (ddm *DisplayDisabledMap) validateSchema() error {
+	type innerStruct struct {
+		// IllegalParamTypes: list of the mis-spelled parameter types (i.e. not required or optional)
+		IllegalParamTypes []string
+		// IllegalParamStatus: list of parameter names with mis-spelled parameter status combined as a string
+		IllegalParamStatus []string
+	}
+
+	illegalSchema := make(map[string]innerStruct)
+
+	for restPath, entries := range ddm.Data {
+		tmp := innerStruct{}
+		for requiredOrOptional, paramList := range entries {
+
+			if requiredOrOptional != requiredParameterStr && requiredOrOptional != optionalParameterStr {
+				tmp.IllegalParamTypes = append(tmp.IllegalParamTypes, requiredOrOptional)
+			}
+
+			for _, paramDict := range paramList {
+				for paramName, paramStatus := range paramDict {
+					if paramStatus != disabledStatusStr && paramStatus != enabledStatusStr {
+						errorStr := fmt.Sprintf("%s : %s", paramName, paramStatus)
+						tmp.IllegalParamStatus = append(tmp.IllegalParamStatus, errorStr)
+					}
+				}
+			}
+
+			if len(tmp.IllegalParamTypes) != 0 || len(tmp.IllegalParamStatus) != 0 {
+				illegalSchema[restPath] = tmp
+			}
+		}
+	}
+
+	// No error if there are no entries
+	if len(illegalSchema) == 0 {
+		return nil
+	}
+
+	var sb strings.Builder
+
+	for restPath, iStruct := range illegalSchema {
+		_, _ = sb.WriteString(fmt.Sprintf("REST Path %s contained the following errors:\n", restPath))
+		if len(iStruct.IllegalParamTypes) != 0 {
+			_, _ = sb.WriteString(fmt.Sprintf("  -> Illegal Parameter Types: %v\n", iStruct.IllegalParamTypes))
+		}
+		if len(iStruct.IllegalParamStatus) != 0 {
+			_, _ = sb.WriteString(fmt.Sprintf("  -> Illegal Parameter Status: %v\n", iStruct.IllegalParamStatus))
+		}
+	}
+
+	return fmt.Errorf(sb.String())
+}
+
+// toDisabledMapConfig creates a disabled map config from a display disabled map.  If the swag pointer
+// is nil then no validation is performed on the disabled map config.  This is useful for unit tests
+func (ddm *DisplayDisabledMap) toDisabledMapConfig(swag *openapi3.Swagger) (*DisabledMapConfig, error) {
+	// Check that all the "strings" are valid
+	err := ddm.validateSchema()
+	if err != nil {
+		return nil, err
+	}
+
+	// We now should have a correctly formed DisplayDisabledMap.
+	// Let's turn that into a config
+	dmc := MakeDisabledMapConfig()
+
+	for restPath, entries := range ddm.Data {
+		var disabledParams []string
+		for _, paramList := range entries {
+			// We don't care if they are required or optional, only if the are disabled
+			for _, paramDict := range paramList {
+				for paramName, paramStatus := range paramDict {
+					if paramStatus != disabledStatusStr {
+						continue
+					}
+					disabledParams = append(disabledParams, paramName)
+				}
+			}
+		}
+
+		// Default to just get for now
+		dmc.addEntry(restPath, http.MethodGet, disabledParams)
+	}
+
+	if swag != nil {
+		err = dmc.validate(swag)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return dmc, nil
+}
+
+// MakeDisabledMapConfigFromFile loads a file containing a disabled map configuration.
+func MakeDisabledMapConfigFromFile(swag *openapi3.Swagger, filePath string) (*DisabledMapConfig, error) {
+	// First load the file...
+	f, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return nil, err
+	}
+
+	ddm := makeDisplayDisabledMap()
+
+	err = yaml.Unmarshal(f, &ddm.Data)
+	if err != nil {
+		return nil, err
+	}
+
+	return ddm.toDisabledMapConfig(swag)
+}
+
 // MakeDisplayDisabledMapFromConfig will make a DisplayDisabledMap that takes into account the DisabledMapConfig.
 // If limited is set to true, then only disabled parameters will be added to the DisplayDisabledMap
 func MakeDisplayDisabledMapFromConfig(swag *openapi3.Swagger, mapConfig *DisabledMapConfig, limited bool) *DisplayDisabledMap {
@@ -84,16 +211,16 @@ func MakeDisplayDisabledMapFromConfig(swag *openapi3.Swagger, mapConfig *Disable
 				var statusStr string
 
 				if parameterIsDisabled {
-					statusStr = "disabled"
+					statusStr = disabledStatusStr
 				} else {
-					statusStr = "enabled"
+					statusStr = enabledStatusStr
 				}
 
 				if pref.Value.Required {
-					rval.addEntry(restPath, "required", paramName, statusStr)
+					rval.addEntry(restPath, requiredParameterStr, paramName, statusStr)
 				} else {
 					// If the optional parameter is disabled, add it to the map
-					rval.addEntry(restPath, "optional", paramName, statusStr)
+					rval.addEntry(restPath, optionalParameterStr, paramName, statusStr)
 				}
 			}
 
@@ -173,7 +300,7 @@ func (dmc *DisabledMapConfig) addEntry(restPath string, operationName string, pa
 	dmc.Data[restPath][operationName] = parameterNames
 }
 
-// MakeDisabledMapConfig creates a new disabled map configuration
+// MakeDisabledMapConfig creates a new disabled map configuration with everything enabled
 func MakeDisabledMapConfig() *DisabledMapConfig {
 	return &DisabledMapConfig{
 		Data: make(map[string]map[string][]string),
@@ -211,14 +338,14 @@ func (edmc *ErrDisabledMapConfig) Error() string {
 	var sb strings.Builder
 	for k, v := range edmc.BadEntries {
 
-		// If the length of the list is zero then it is a mis-spelled REST path
+		// If the length of the list is zero then it is an unknown REST path
 		if len(v) == 0 {
-			_, _ = sb.WriteString(fmt.Sprintf("Mis-spelled REST Path: %s\n", k))
+			_, _ = sb.WriteString(fmt.Sprintf("Unknown REST Path: %s\n", k))
 			continue
 		}
 
 		for op, param := range v {
-			_, _ = sb.WriteString(fmt.Sprintf("REST Path %s (Operation: %s) contains mis-spelled parameters: %s\n", k, op, strings.Join(param, ",")))
+			_, _ = sb.WriteString(fmt.Sprintf("REST Path %s (Operation: %s) contains unknown parameters: %s\n", k, op, strings.Join(param, ",")))
 		}
 	}
 	return sb.String()
diff --git a/api/disabled_parameters_test.go b/api/disabled_parameters_test.go
index 95508a35f..4444b1b24 100644
--- a/api/disabled_parameters_test.go
+++ b/api/disabled_parameters_test.go
@@ -4,6 +4,8 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"net/url"
+	"path/filepath"
+	"reflect"
 	"strings"
 	"testing"
 
@@ -14,6 +16,166 @@ import (
 	"github.com/algorand/indexer/api/generated/v2"
 )
 
+func TestToDisabledMapConfigFromFile(t *testing.T) {
+	expectedValue := DisabledMapConfig{Data: map[string]map[string][]string{
+		"/sampleEndpoint": {http.MethodGet: {"p2"}},
+	}}
+
+	configFile := filepath.Join("test_resources", "mock_disabled_map_config.yaml")
+
+	// Nil pointer for openapi3.swagger because we don't want any validation
+	// to be run on the config (they are made up endpoints)
+	loadedConfig, err := MakeDisabledMapConfigFromFile(nil, configFile)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
+	require.Equal(t, expectedValue, *loadedConfig)
+}
+
+func TestToDisabledMapConfig(t *testing.T) {
+	type testingStruct struct {
+		name        string
+		ddm         *DisplayDisabledMap
+		dmc         *DisabledMapConfig
+		expectError string
+	}
+
+	tests := []testingStruct{
+		{"test 1",
+			&DisplayDisabledMap{Data: map[string]map[string][]map[string]string{
+				"/sampleEndpoint": {
+					"required": {{"p1": "enabled"}, {"p2": "disabled"}},
+					"optional": {{"p3": "enabled"}},
+				}}},
+			&DisabledMapConfig{Data: map[string]map[string][]string{
+				"/sampleEndpoint": {http.MethodGet: {"p2"}},
+			}},
+
+			"",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+
+			// Nil pointer for openapi3.swagger because we don't want any validation
+			// to be run on the config
+			dmc, err := test.ddm.toDisabledMapConfig(nil)
+
+			if test.expectError != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), test.expectError)
+			} else {
+				require.NoError(t, err)
+				require.True(t, reflect.DeepEqual(*dmc, *test.dmc))
+			}
+		})
+	}
+
+}
+
+func TestSchemaCheck(t *testing.T) {
+	type testingStruct struct {
+		name        string
+		ddm         *DisplayDisabledMap
+		expectError string
+	}
+	tests := []testingStruct{
+		{"test param types - good",
+			&DisplayDisabledMap{Data: map[string]map[string][]map[string]string{
+				"/sampleEndpoint": {
+					"required": {{"p1": "enabled"}, {"p2": "disabled"}},
+					"optional": {{"p3": "enabled"}},
+				}},
+			},
+			"",
+		},
+
+		{"test param types - bad required",
+			&DisplayDisabledMap{Data: map[string]map[string][]map[string]string{
+				"/sampleEndpoint": {
+					"required-FAKE": {{"p1": "enabled"}, {"p2": "disabled"}},
+					"optional":      {{"p3": "enabled"}},
+				}},
+			},
+			"required-FAKE",
+		},
+
+		{"test param types - bad optional",
+			&DisplayDisabledMap{Data: map[string]map[string][]map[string]string{
+				"/sampleEndpoint": {
+					"required":      {{"p1": "enabled"}, {"p2": "disabled"}},
+					"optional-FAKE": {{"p3": "enabled"}},
+				}},
+			},
+			"optional-FAKE",
+		},
+
+		{"test param types - bad both",
+			&DisplayDisabledMap{Data: map[string]map[string][]map[string]string{
+				"/sampleEndpoint": {
+					"required-FAKE": {{"p1": "enabled"}, {"p2": "disabled"}},
+					"optional-FAKE": {{"p3": "enabled"}},
+				}},
+			},
+			"required-FAKE optional-FAKE",
+		},
+
+		{"test param status - good",
+			&DisplayDisabledMap{Data: map[string]map[string][]map[string]string{
+				"/sampleEndpoint": {
+					"required": {{"p1": "enabled"}, {"p2": "disabled"}},
+					"optional": {{"p3": "enabled"}},
+				}},
+			},
+			"",
+		},
+
+		{"test param status - bad required",
+			&DisplayDisabledMap{Data: map[string]map[string][]map[string]string{
+				"/sampleEndpoint": {
+					"required": {{"p1": "enabled"}, {"p2": "disabled-FAKE"}},
+					"optional": {{"p3": "enabled"}},
+				}},
+			},
+			"p2",
+		},
+
+		{"test param status - bad optional",
+			&DisplayDisabledMap{Data: map[string]map[string][]map[string]string{
+				"/sampleEndpoint": {
+					"required": {{"p1": "enabled"}, {"p2": "disabled"}},
+					"optional": {{"p3": "enabled-FAKE"}},
+				}},
+			},
+			"p3",
+		},
+
+		{"test param status - bad both",
+			&DisplayDisabledMap{Data: map[string]map[string][]map[string]string{
+				"/sampleEndpoint": {
+					"required": {{"p1": "enabled-FAKE"}, {"p2": "disabled"}},
+					"optional": {{"p3": "enabled-FAKE"}},
+				}},
+			},
+			"p1",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := test.ddm.validateSchema()
+
+			if test.expectError != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), test.expectError)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+
+}
+
 func TestValidate(t *testing.T) {
 	// Validates that the default config is correctly spelled
 	dmc := GetDefaultDisabledMapConfigForPostgres()
diff --git a/api/test_resources/mock_disabled_map_config.yaml b/api/test_resources/mock_disabled_map_config.yaml
new file mode 100644
index 000000000..6d501aadb
--- /dev/null
+++ b/api/test_resources/mock_disabled_map_config.yaml
@@ -0,0 +1,6 @@
+/sampleEndpoint:
+  required:
+    - p1 : enabled
+    - p2 : disabled
+  optional:
+    - p3 : enabled
\ No newline at end of file
diff --git a/cmd/algorand-indexer/api_config.go b/cmd/algorand-indexer/api_config.go
index acdb6d1f6..bdb45ddb3 100644
--- a/cmd/algorand-indexer/api_config.go
+++ b/cmd/algorand-indexer/api_config.go
@@ -12,14 +12,14 @@ import (
 )
 
 var (
-	showAllDisabled bool
+	suppliedAPIConfigFile string
+	showAllDisabled       bool
 )
 
 var apiConfigCmd = &cobra.Command{
 	Use:   "api-config",
-	Short: "dump api configuration",
-	Long:  "dump api configuration",
-	//Args:
+	Short: "api configuration",
+	Long:  "api configuration",
 	Run: func(cmd *cobra.Command, args []string) {
 		var err error
 		config.BindFlags(cmd)
@@ -36,6 +36,14 @@ var apiConfigCmd = &cobra.Command{
 		}
 
 		options := makeOptions()
+		if suppliedAPIConfigFile != "" {
+			potentialDisabledMapConfig, err := api.MakeDisabledMapConfigFromFile(swag, suppliedAPIConfigFile)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "failed to created disabled map config from file: %v", err)
+				os.Exit(1)
+			}
+			options.DisabledMapConfig = potentialDisabledMapConfig
+		}
 
 		var displayDisabledMapConfig *api.DisplayDisabledMap
 		// Show a limited subset
@@ -60,4 +68,5 @@ var apiConfigCmd = &cobra.Command{
 
 func init() {
 	apiConfigCmd.Flags().BoolVar(&showAllDisabled, "all", false, "show all api config parameters, enabled and disabled")
+	apiConfigCmd.Flags().StringVar(&suppliedAPIConfigFile, "api-config-file", "", "supply an API config file to enable/disable parameters")
 }
diff --git a/cmd/algorand-indexer/daemon.go b/cmd/algorand-indexer/daemon.go
index aba744437..611e2bc3a 100644
--- a/cmd/algorand-indexer/daemon.go
+++ b/cmd/algorand-indexer/daemon.go
@@ -10,11 +10,12 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/algorand/go-algorand/rpcs"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
+	"github.com/algorand/go-algorand/rpcs"
 	"github.com/algorand/indexer/api"
+	"github.com/algorand/indexer/api/generated/v2"
 	"github.com/algorand/indexer/config"
 	"github.com/algorand/indexer/fetcher"
 	"github.com/algorand/indexer/idb"
@@ -23,18 +24,19 @@ import (
 )
 
 var (
-	algodDataDir     string
-	algodAddr        string
-	algodToken       string
-	daemonServerAddr string
-	noAlgod          bool
-	developerMode    bool
-	allowMigration   bool
-	metricsMode      string
-	tokenString      string
-	writeTimeout     time.Duration
-	readTimeout      time.Duration
-	maxConn          uint32
+	algodDataDir        string
+	algodAddr           string
+	algodToken          string
+	daemonServerAddr    string
+	noAlgod             bool
+	developerMode       bool
+	allowMigration      bool
+	metricsMode         string
+	tokenString         string
+	writeTimeout        time.Duration
+	readTimeout         time.Duration
+	maxConn             uint32
+	enableAllParameters bool
 )
 
 var daemonCmd = &cobra.Command{
@@ -51,6 +53,13 @@ var daemonCmd = &cobra.Command{
 			os.Exit(1)
 		}
 
+		// If someone supplied a configuration file but also said to enable all parameters,
+		// that's an error
+		if suppliedAPIConfigFile != "" && enableAllParameters {
+			fmt.Fprint(os.Stderr, "not allowed to supply an api config file and enable all parameters")
+			os.Exit(1)
+		}
+
 		if algodDataDir == "" {
 			algodDataDir = os.Getenv("ALGORAND_DATA")
 		}
@@ -128,7 +137,26 @@ var daemonCmd = &cobra.Command{
 
 		fmt.Printf("serving on %s\n", daemonServerAddr)
 		logger.Infof("serving on %s", daemonServerAddr)
-		api.Serve(ctx, daemonServerAddr, db, bot, logger, makeOptions())
+
+		options := makeOptions()
+
+		swag, err := generated.GetSwagger()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "failed to get swagger: %v", err)
+			os.Exit(1)
+		}
+
+		if suppliedAPIConfigFile != "" {
+			logger.Infof("supplied api configuration file located at: %s", suppliedAPIConfigFile)
+			potentialDisabledMapConfig, err := api.MakeDisabledMapConfigFromFile(swag, suppliedAPIConfigFile)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "failed to created disabled map config from file: %v", err)
+				os.Exit(1)
+			}
+			options.DisabledMapConfig = potentialDisabledMapConfig
+		}
+
+		api.Serve(ctx, daemonServerAddr, db, bot, logger, options)
 		wg.Wait()
 	},
 }
@@ -147,6 +175,8 @@ func init() {
 	daemonCmd.Flags().DurationVarP(&writeTimeout, "write-timeout", "", 30*time.Second, "set the maximum duration to wait before timing out writes to a http response, breaking connection")
 	daemonCmd.Flags().DurationVarP(&readTimeout, "read-timeout", "", 5*time.Second, "set the maximum duration for reading the entire request")
 	daemonCmd.Flags().Uint32VarP(&maxConn, "max-conn", "", 0, "set the maximum connections allowed in the connection pool, if the maximum is reached subsequent connections will wait until a connection becomes available, or timeout according to the read-timeout setting")
+	daemonCmd.Flags().StringVar(&suppliedAPIConfigFile, "api-config-file", "", "supply an API config file to enable/disable parameters")
+	daemonCmd.Flags().BoolVar(&enableAllParameters, "enable-all-parameters", false, "override default configuration and enable all parameters. Can't be used with --api-config-file")
 
 	viper.RegisterAlias("algod", "algod-data-dir")
 	viper.RegisterAlias("algod-net", "algod-address")
@@ -175,11 +205,11 @@ func makeOptions() (options api.ExtraOptions) {
 	options.WriteTimeout = writeTimeout
 	options.ReadTimeout = readTimeout
 
-	// TODO enable this when command line options allows for disabling/enabling overrides
-	//disabledMapConfig := api.GetDefaultDisabledMapConfigForPostgres()
-	disabledMapConfig := api.MakeDisabledMapConfig()
-
-	options.DisabledMapConfig = disabledMapConfig
+	if enableAllParameters {
+		options.DisabledMapConfig = api.MakeDisabledMapConfig()
+	} else {
+		options.DisabledMapConfig = api.GetDefaultDisabledMapConfigForPostgres()
+	}
 
 	return
 }
diff --git a/test/common.sh b/test/common.sh
index ecb1554aa..d72f09423 100755
--- a/test/common.sh
+++ b/test/common.sh
@@ -200,6 +200,7 @@ function start_indexer_with_connection_string() {
   ALGORAND_DATA= ../cmd/algorand-indexer/algorand-indexer daemon \
     -S $NET "$RO" \
     -P "$1" \
+    --enable-all-parameters \
     "$RO" \
     --pidfile $PIDFILE 2>&1 > /dev/null &
 }

From 82b9fe3e8e0cd5599e219a5adff79d30119099ea Mon Sep 17 00:00:00 2001
From: algochoi <86622919+algochoi@users.noreply.github.com>
Date: Wed, 9 Mar 2022 16:30:16 -0500
Subject: [PATCH 20/29] Return all inner transactions are returned for logs
 endpoint. (#915)

---
 api/handlers.go               |   4 +-
 api/handlers_e2e_test.go      | 103 +++++++++++++++++++++++++++++++++
 util/test/account_testutil.go | 105 +++++++++++++++++++++++++++++-----
 3 files changed, 197 insertions(+), 15 deletions(-)

diff --git a/api/handlers.go b/api/handlers.go
index ad2d07903..481a78ef8 100644
--- a/api/handlers.go
+++ b/api/handlers.go
@@ -949,7 +949,9 @@ func (si *ServerImplementation) fetchTransactions(ctx context.Context, filter id
 			}
 
 			// The root txn has already been added.
-			if _, ok := rootTxnDedupeMap[*tx.Id]; ok {
+			// If we also want to return inner txns, we cannot deduplicate the
+			// results as inner txns all share the same txn ID as its root txn.
+			if _, ok := rootTxnDedupeMap[*tx.Id]; ok && !filter.ReturnInnerTxnOnly {
 				continue
 			}
 
diff --git a/api/handlers_e2e_test.go b/api/handlers_e2e_test.go
index 96ca6ba8c..753ddb822 100644
--- a/api/handlers_e2e_test.go
+++ b/api/handlers_e2e_test.go
@@ -649,3 +649,106 @@ func TestLookupInnerLogs(t *testing.T) {
 		})
 	}
 }
+
+// TestLookupInnerLogs runs queries for logs given application ids,
+// and checks that logs in inner transactions match properly.
+func TestLookupMultiInnerLogs(t *testing.T) {
+	var appAddr basics.Address
+	appAddr[1] = 99
+
+	params := generated.LookupApplicationLogsByIDParams{}
+
+	testcases := []struct {
+		name            string
+		appID           uint64
+		numTxnsWithLogs int
+		logs            []string
+	}{
+		{
+			name:            "match on root with appId 123",
+			appID:           123,
+			numTxnsWithLogs: 1,
+			logs: []string{
+				"testing outer appl log",
+				"appId 123 log",
+			},
+		},
+		{
+			name:            "match on inner with appId 789",
+			appID:           789,
+			numTxnsWithLogs: 1,
+			logs: []string{
+				"testing inner log",
+				"appId 789 log",
+			},
+		},
+		{
+			name:            "match on inner with appId 222",
+			appID:           222,
+			numTxnsWithLogs: 3, // There are 6 logs over 3 transactions
+			logs: []string{
+				"testing multiple logs 1",
+				"appId 222 log 1",
+				"testing multiple logs 2",
+				"appId 222 log 2",
+				"testing multiple logs 3",
+				"appId 222 log 3",
+			},
+		},
+	}
+
+	db, shutdownFunc := setupIdb(t, test.MakeGenesis(), test.MakeGenesisBlock())
+	defer shutdownFunc()
+
+	///////////
+	// Given // a DB with some inner txns in it.
+	///////////
+	appCall := test.MakeAppCallWithMultiLogs(test.AccountA)
+
+	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 queries logs based on appID
+			//////////
+			e := echo.New()
+			req := httptest.NewRequest(http.MethodGet, "/", nil)
+			rec := httptest.NewRecorder()
+			c := e.NewContext(req, rec)
+			c.SetPath("/v2/applications/:appIdx/logs")
+			c.SetParamNames("appIdx")
+			c.SetParamValues(fmt.Sprintf("%d", tc.appID))
+
+			api := &ServerImplementation{db: db, timeout: 30 * time.Second}
+			err = api.LookupApplicationLogsByID(c, tc.appID, params)
+			require.NoError(t, err)
+
+			//////////
+			// Then // The result is the log from the app
+			//////////
+			var response generated.ApplicationLogsResponse
+			require.Equal(t, http.StatusOK, rec.Code)
+			json.Decode(rec.Body.Bytes(), &response)
+			require.NoError(t, err)
+
+			require.Equal(t, uint64(tc.appID), response.ApplicationId)
+			require.NotNil(t, response.LogData)
+			ld := *response.LogData
+			require.Equal(t, tc.numTxnsWithLogs, len(ld))
+
+			logCount := 0
+			for txnIndex, result := range ld {
+				for logIndex, log := range result.Logs {
+					require.Equal(t, []byte(tc.logs[txnIndex*2+logIndex]), log)
+					logCount++
+				}
+			}
+			require.Equal(t, logCount, len(tc.logs))
+		})
+	}
+}
diff --git a/util/test/account_testutil.go b/util/test/account_testutil.go
index 942417af4..1142eb3c0 100644
--- a/util/test/account_testutil.go
+++ b/util/test/account_testutil.go
@@ -263,6 +263,33 @@ func MakeAppOptOutTxn(appid uint64, sender basics.Address) transactions.SignedTx
 	}
 }
 
+// MakeAppCallTxn makes an appl transaction with a NoOp upon completion.
+func MakeAppCallTxn(appid uint64, sender basics.Address) transactions.SignedTxnWithAD {
+	return transactions.SignedTxnWithAD{
+		SignedTxn: transactions.SignedTxn{
+			Txn: transactions.Transaction{
+				Type: "appl",
+				Header: transactions.Header{
+					Sender:      sender,
+					GenesisHash: GenesisHash,
+				},
+				ApplicationCallTxnFields: transactions.ApplicationCallTxnFields{
+					ApplicationID: basics.AppIndex(appid),
+					OnCompletion:  transactions.NoOpOC,
+				},
+			},
+			Sig: Signature,
+		},
+	}
+}
+
+// MakeAppCallTxnWithLogs makes an appl NoOp transaction with initialized logs.
+func MakeAppCallTxnWithLogs(appid uint64, sender basics.Address, logs []string) (txn transactions.SignedTxnWithAD) {
+	txn = MakeAppCallTxn(appid, sender)
+	txn.ApplyData.EvalDelta.Logs = logs
+	return
+}
+
 // MakeAppCallWithInnerTxn creates an app call with 3 levels of transactions:
 // application create
 // |- payment
@@ -324,24 +351,74 @@ func MakeAppCallWithInnerTxn(appSender, paymentSender, paymentReceiver, assetSen
 							},
 						},
 						// Inner application call
-						{
-							SignedTxn: transactions.SignedTxn{
-								Txn: transactions.Transaction{
-									Type: protocol.ApplicationCallTx,
-									Header: transactions.Header{
-										Sender: assetSender,
-									},
-									ApplicationCallTxnFields: transactions.ApplicationCallTxnFields{
-										ApplicationID: 789,
-										OnCompletion:  transactions.NoOpOC,
-									},
-								},
-							},
-						},
+						MakeAppCallTxn(789, assetSender),
+					},
+				},
+			},
+		},
+	}
+
+	return createApp
+}
+
+// MakeAppCallWithMultiLogs creates an app call that creates multiple logs
+// at the same level.
+// application create
+//   |- application call
+//     |- application call
+//   |- application call
+//   |- application call
+//   |- application call
+func MakeAppCallWithMultiLogs(appSender basics.Address) transactions.SignedTxnWithAD {
+	createApp := MakeCreateAppTxn(appSender)
+
+	// Add a log to the outer appl call
+	createApp.ApplicationID = 123
+	createApp.ApplyData.EvalDelta.Logs = []string{
+		"testing outer appl log",
+		"appId 123 log",
+	}
+
+	createApp.ApplyData.EvalDelta.InnerTxns = []transactions.SignedTxnWithAD{
+		{
+			SignedTxn: transactions.SignedTxn{
+				Txn: transactions.Transaction{
+					Type: protocol.ApplicationCallTx,
+					Header: transactions.Header{
+						Sender: appSender,
+					},
+					ApplicationCallTxnFields: transactions.ApplicationCallTxnFields{
+						ApplicationID: 789,
+						OnCompletion:  transactions.NoOpOC,
+					},
+				},
+			},
+			// also add a fake second-level ApplyData to ensure the recursive part works
+			ApplyData: transactions.ApplyData{
+				EvalDelta: transactions.EvalDelta{
+					InnerTxns: []transactions.SignedTxnWithAD{
+						// Inner application call
+						MakeAppCallTxn(789, appSender),
+					},
+					Logs: []string{
+						"testing inner log",
+						"appId 789 log",
 					},
 				},
 			},
 		},
+		MakeAppCallTxnWithLogs(222, appSender, []string{
+			"testing multiple logs 1",
+			"appId 222 log 1",
+		}),
+		MakeAppCallTxnWithLogs(222, appSender, []string{
+			"testing multiple logs 2",
+			"appId 222 log 2",
+		}),
+		MakeAppCallTxnWithLogs(222, appSender, []string{
+			"testing multiple logs 3",
+			"appId 222 log 3",
+		}),
 	}
 
 	return createApp

From def35439d22a7c997128532b87ea4067d4115b72 Mon Sep 17 00:00:00 2001
From: Will Winder <wwinder.unh@gmail.com>
Date: Thu, 10 Mar 2022 09:43:36 -0500
Subject: [PATCH 21/29] Feature flag to disable configurable api parameters.
 (#917)

---
 api/disabled_parameters.go      |  3 +++
 api/disabled_parameters_test.go | 24 +++++++++--------
 cmd/algorand-indexer/daemon.go  | 48 +++++++++++++++++++--------------
 cmd/algorand-indexer/main.go    |  4 ++-
 4 files changed, 47 insertions(+), 32 deletions(-)

diff --git a/api/disabled_parameters.go b/api/disabled_parameters.go
index 3769e9708..42fb31426 100644
--- a/api/disabled_parameters.go
+++ b/api/disabled_parameters.go
@@ -411,6 +411,9 @@ func (dmc *DisabledMapConfig) validate(swag *openapi3.Swagger) error {
 
 // MakeDisabledMapFromOA3 Creates a new disabled map from an openapi3 definition
 func MakeDisabledMapFromOA3(swag *openapi3.Swagger, config *DisabledMapConfig) (*DisabledMap, error) {
+	if config == nil {
+		return nil, nil
+	}
 
 	err := config.validate(swag)
 
diff --git a/api/disabled_parameters_test.go b/api/disabled_parameters_test.go
index 4444b1b24..984ca52d1 100644
--- a/api/disabled_parameters_test.go
+++ b/api/disabled_parameters_test.go
@@ -77,7 +77,7 @@ func TestSchemaCheck(t *testing.T) {
 	type testingStruct struct {
 		name        string
 		ddm         *DisplayDisabledMap
-		expectError string
+		expectError []string
 	}
 	tests := []testingStruct{
 		{"test param types - good",
@@ -87,7 +87,7 @@ func TestSchemaCheck(t *testing.T) {
 					"optional": {{"p3": "enabled"}},
 				}},
 			},
-			"",
+			nil,
 		},
 
 		{"test param types - bad required",
@@ -97,7 +97,7 @@ func TestSchemaCheck(t *testing.T) {
 					"optional":      {{"p3": "enabled"}},
 				}},
 			},
-			"required-FAKE",
+			[]string{"required-FAKE"},
 		},
 
 		{"test param types - bad optional",
@@ -107,7 +107,7 @@ func TestSchemaCheck(t *testing.T) {
 					"optional-FAKE": {{"p3": "enabled"}},
 				}},
 			},
-			"optional-FAKE",
+			[]string{"optional-FAKE"},
 		},
 
 		{"test param types - bad both",
@@ -117,7 +117,7 @@ func TestSchemaCheck(t *testing.T) {
 					"optional-FAKE": {{"p3": "enabled"}},
 				}},
 			},
-			"required-FAKE optional-FAKE",
+			[]string{"required-FAKE", "optional-FAKE"},
 		},
 
 		{"test param status - good",
@@ -127,7 +127,7 @@ func TestSchemaCheck(t *testing.T) {
 					"optional": {{"p3": "enabled"}},
 				}},
 			},
-			"",
+			nil,
 		},
 
 		{"test param status - bad required",
@@ -137,7 +137,7 @@ func TestSchemaCheck(t *testing.T) {
 					"optional": {{"p3": "enabled"}},
 				}},
 			},
-			"p2",
+			[]string{"p2"},
 		},
 
 		{"test param status - bad optional",
@@ -147,7 +147,7 @@ func TestSchemaCheck(t *testing.T) {
 					"optional": {{"p3": "enabled-FAKE"}},
 				}},
 			},
-			"p3",
+			[]string{"p3"},
 		},
 
 		{"test param status - bad both",
@@ -157,7 +157,7 @@ func TestSchemaCheck(t *testing.T) {
 					"optional": {{"p3": "enabled-FAKE"}},
 				}},
 			},
-			"p1",
+			[]string{"p1"},
 		},
 	}
 
@@ -165,9 +165,11 @@ func TestSchemaCheck(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			err := test.ddm.validateSchema()
 
-			if test.expectError != "" {
+			if len(test.expectError) != 0 {
 				require.Error(t, err)
-				require.Contains(t, err.Error(), test.expectError)
+				for _, str := range test.expectError {
+					require.Contains(t, err.Error(), str)
+				}
 			} else {
 				require.NoError(t, err)
 			}
diff --git a/cmd/algorand-indexer/daemon.go b/cmd/algorand-indexer/daemon.go
index 611e2bc3a..c0d63efbd 100644
--- a/cmd/algorand-indexer/daemon.go
+++ b/cmd/algorand-indexer/daemon.go
@@ -39,6 +39,8 @@ var (
 	enableAllParameters bool
 )
 
+const paramConfigEnableFlag = false
+
 var daemonCmd = &cobra.Command{
 	Use:   "daemon",
 	Short: "run indexer daemon",
@@ -140,22 +142,6 @@ var daemonCmd = &cobra.Command{
 
 		options := makeOptions()
 
-		swag, err := generated.GetSwagger()
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "failed to get swagger: %v", err)
-			os.Exit(1)
-		}
-
-		if suppliedAPIConfigFile != "" {
-			logger.Infof("supplied api configuration file located at: %s", suppliedAPIConfigFile)
-			potentialDisabledMapConfig, err := api.MakeDisabledMapConfigFromFile(swag, suppliedAPIConfigFile)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "failed to created disabled map config from file: %v", err)
-				os.Exit(1)
-			}
-			options.DisabledMapConfig = potentialDisabledMapConfig
-		}
-
 		api.Serve(ctx, daemonServerAddr, db, bot, logger, options)
 		wg.Wait()
 	},
@@ -177,6 +163,10 @@ func init() {
 	daemonCmd.Flags().Uint32VarP(&maxConn, "max-conn", "", 0, "set the maximum connections allowed in the connection pool, if the maximum is reached subsequent connections will wait until a connection becomes available, or timeout according to the read-timeout setting")
 	daemonCmd.Flags().StringVar(&suppliedAPIConfigFile, "api-config-file", "", "supply an API config file to enable/disable parameters")
 	daemonCmd.Flags().BoolVar(&enableAllParameters, "enable-all-parameters", false, "override default configuration and enable all parameters. Can't be used with --api-config-file")
+	if !paramConfigEnableFlag {
+		daemonCmd.Flags().MarkHidden("api-config-file")
+		daemonCmd.Flags().MarkHidden("enable-all-parameters")
+	}
 
 	viper.RegisterAlias("algod", "algod-data-dir")
 	viper.RegisterAlias("algod-net", "algod-address")
@@ -205,10 +195,28 @@ func makeOptions() (options api.ExtraOptions) {
 	options.WriteTimeout = writeTimeout
 	options.ReadTimeout = readTimeout
 
-	if enableAllParameters {
-		options.DisabledMapConfig = api.MakeDisabledMapConfig()
-	} else {
-		options.DisabledMapConfig = api.GetDefaultDisabledMapConfigForPostgres()
+	if paramConfigEnableFlag {
+		if enableAllParameters {
+			options.DisabledMapConfig = api.MakeDisabledMapConfig()
+		} else {
+			options.DisabledMapConfig = api.GetDefaultDisabledMapConfigForPostgres()
+		}
+
+		if suppliedAPIConfigFile != "" {
+			swag, err := generated.GetSwagger()
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "failed to get swagger: %v", err)
+				os.Exit(1)
+			}
+
+			logger.Infof("supplied api configuration file located at: %s", suppliedAPIConfigFile)
+			potentialDisabledMapConfig, err := api.MakeDisabledMapConfigFromFile(swag, suppliedAPIConfigFile)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "failed to created disabled map config from file: %v", err)
+				os.Exit(1)
+			}
+			options.DisabledMapConfig = potentialDisabledMapConfig
+		}
 	}
 
 	return
diff --git a/cmd/algorand-indexer/main.go b/cmd/algorand-indexer/main.go
index 7ca86e459..3dda5591e 100644
--- a/cmd/algorand-indexer/main.go
+++ b/cmd/algorand-indexer/main.go
@@ -137,7 +137,9 @@ func init() {
 	rootCmd.AddCommand(importCmd)
 	importCmd.Hidden = true
 	rootCmd.AddCommand(daemonCmd)
-	rootCmd.AddCommand(apiConfigCmd)
+	if paramConfigEnableFlag {
+		rootCmd.AddCommand(apiConfigCmd)
+	}
 
 	// Not applied globally to avoid adding to utility commands.
 	addFlags := func(cmd *cobra.Command) {

From ef46a1ac9d2b7bd673bc04602ae97c115c602ec9 Mon Sep 17 00:00:00 2001
From: AlgoStephenAkiki <85183435+AlgoStephenAkiki@users.noreply.github.com>
Date: Thu, 10 Mar 2022 11:55:00 -0500
Subject: [PATCH 22/29] Add CLI doc generation command. (#919)

---
 cmd/algorand-indexer/main.go | 16 ++++++++++++++--
 go.sum                       |  2 ++
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/cmd/algorand-indexer/main.go b/cmd/algorand-indexer/main.go
index 3dda5591e..ca4dd9bbe 100644
--- a/cmd/algorand-indexer/main.go
+++ b/cmd/algorand-indexer/main.go
@@ -7,9 +7,9 @@ import (
 	"runtime/pprof"
 	"strings"
 
-	"github.com/spf13/cobra"
-	//"github.com/spf13/cobra/doc" // TODO: enable cobra doc generation
 	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+	"github.com/spf13/cobra/doc"
 	"github.com/spf13/viper"
 
 	bg "github.com/algorand/indexer/cmd/block-generator/core"
@@ -206,6 +206,18 @@ func configureLogger() error {
 }
 
 func main() {
+
+	// Hidden command to generate docs in a given directory
+	// algorand-indexer generate-docs [path]
+	if len(os.Args) == 3 && os.Args[1] == "generate-docs" {
+		err := doc.GenMarkdownTree(rootCmd, os.Args[2])
+		if err != nil {
+			fmt.Println(err)
+			os.Exit(1)
+		}
+		os.Exit(0)
+	}
+
 	if err := rootCmd.Execute(); err != nil {
 		logger.WithError(err).Error("an error occurred running indexer")
 		os.Exit(1)
diff --git a/go.sum b/go.sum
index efe5e77d7..1d3384e6d 100644
--- a/go.sum
+++ b/go.sum
@@ -143,6 +143,7 @@ github.com/coreos/go-systemd v0.0.0-20190719114852-fd7a80b32e1f/go.mod h1:F5haX7
 github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
 github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
 github.com/cpuguy83/go-md2man v1.0.8/go.mod h1:N6JayAiVKtlHSnuTCeuLSQVs75hb8q+dYQLjr7cDsKY=
+github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk=
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
@@ -633,6 +634,7 @@ github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFR
 github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
 github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU=
 github.com/rs/zerolog v1.15.0/go.mod h1:xYTKnLHcpfU2225ny5qZjxnj9NvkumZYjJHlAThCjNc=
+github.com/russross/blackfriday v1.5.2 h1:HyvC0ARfnZBqnXwABFeSZHpKvJHJJfPz81GNueLj0oo=
 github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=

From b303af10156402521a0c78b9ffb482fd41ed950a Mon Sep 17 00:00:00 2001
From: Will Winder <wwinder.unh@gmail.com>
Date: Thu, 10 Mar 2022 12:50:47 -0500
Subject: [PATCH 23/29] Fix dev mode by addressing off by one error. (#920)

---
 fetcher/fetcher.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fetcher/fetcher.go b/fetcher/fetcher.go
index b7da57690..d1e2c7a0d 100644
--- a/fetcher/fetcher.go
+++ b/fetcher/fetcher.go
@@ -147,7 +147,8 @@ func (bot *fetcherImpl) followLoop(ctx context.Context) error {
 	aclient := bot.Algod()
 	for {
 		for retries := 0; retries < 3; retries++ {
-			_, err = aclient.StatusAfterBlock(bot.nextRound).Do(ctx)
+			// nextRound - 1 because the endpoint waits until "StatusAfterBlock"
+			_, err = aclient.StatusAfterBlock(bot.nextRound - 1).Do(ctx)
 			if err != nil {
 				// If context has expired.
 				if ctx.Err() != nil {

From 31eec101eb41137e45c582a9375201df85caa4ba Mon Sep 17 00:00:00 2001
From: chris erway <51567+cce@users.noreply.github.com>
Date: Thu, 10 Mar 2022 12:54:47 -0500
Subject: [PATCH 24/29] Add support for unlimited assets. (#900)

Co-authored-by: John Lee <john.lee@algorand.com>
Co-authored-by: Brice Rising <brice@algorand.com>
Co-authored-by: Tolik Zinovyev <tolik@algorand.com>
Co-authored-by: Barbara Poon <barbara.poon@algorand.com>
Co-authored-by: Will Winder <wwinder.unh@gmail.com>
---
 .circleci/config.yml                          |    2 +-
 Makefile                                      |    4 +-
 README.md                                     |   41 +-
 accounting/eval_preload.go                    |  202 ++++
 api/converter_utils.go                        |   49 +-
 api/disabled_parameters.go                    |    2 +-
 api/generated/common/routes.go                |  300 ++---
 api/generated/common/types.go                 |   40 +-
 api/generated/v2/routes.go                    |  716 ++++++++---
 api/generated/v2/types.go                     |  116 +-
 api/handlers.go                               |  317 ++++-
 api/handlers_e2e_test.go                      |  697 ++++++++++-
 api/handlers_test.go                          |   90 +-
 api/indexer.oas2.json                         |  295 ++++-
 api/indexer.oas3.yml                          | 1068 ++++++++++++++---
 api/server.go                                 |   30 +
 cmd/algorand-indexer/daemon.go                |   62 +-
 cmd/block-generator/generator/generate.go     |    1 -
 cmd/idbtest/idbtest.go                        |    8 +-
 cmd/import-validator/README.md                |   12 +-
 cmd/import-validator/core/service.go          |  163 ++-
 idb/dummy/dummy.go                            |    8 +-
 idb/idb.go                                    |   47 +-
 idb/mocks/IndexerDb.go                        |   31 +-
 idb/postgres/internal/encoding/encoding.go    |   83 +-
 .../internal/encoding/encoding_test.go        |   64 +-
 idb/postgres/internal/encoding/types.go       |   27 +
 .../ledger_for_evaluator.go                   |  434 ++++---
 .../ledger_for_evaluator_test.go              |  615 ++++++----
 .../migrations/convert_account_data/m.go      |  188 +++
 .../migrations/convert_account_data/m_test.go |  270 +++++
 .../internal/schema/setup_postgres.sql        |    2 +-
 .../internal/schema/setup_postgres_sql.go     |    2 +-
 idb/postgres/internal/testing/testing.go      |   13 +
 idb/postgres/internal/writer/writer.go        |  129 +-
 idb/postgres/internal/writer/writer_test.go   |  241 ++--
 idb/postgres/postgres.go                      |  567 ++++++---
 idb/postgres/postgres_integration_test.go     |   49 +-
 idb/postgres/postgres_migrations.go           |   53 +-
 idb/postgres/postgres_migrations_test.go      |   34 +
 idb/postgres/postgres_rand_test.go            |  248 +++-
 misc/Dockerfile                               |    2 +-
 misc/parity/reports/algod2indexer_dropped.yml |    3 +
 misc/parity/reports/algod2indexer_full.yml    |    3 +
 test/common.sh                                |    1 -
 third_party/go-algorand                       |    2 +-
 46 files changed, 5648 insertions(+), 1683 deletions(-)
 create mode 100644 accounting/eval_preload.go
 create mode 100644 idb/postgres/internal/migrations/convert_account_data/m.go
 create mode 100644 idb/postgres/internal/migrations/convert_account_data/m_test.go
 create mode 100644 idb/postgres/postgres_migrations_test.go

diff --git a/.circleci/config.yml b/.circleci/config.yml
index c4a692dfa..47b2a93d3 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -83,7 +83,7 @@ commands:
           name: Install python and other python dependencies
           command: |
             sudo apt update
-            sudo apt -y install python3 python3-pip python3-setuptools python3-wheel libboost-all-dev libffi-dev
+            sudo apt -y install python3 python3-pip python3-setuptools python3-wheel libboost-math-dev libffi-dev
             pip3 install -r misc/requirements.txt
 
       - run:
diff --git a/Makefile b/Makefile
index 92585f6e9..88d0e6aa3 100644
--- a/Makefile
+++ b/Makefile
@@ -11,6 +11,8 @@ GOLDFLAGS += -X github.com/algorand/indexer/version.CompileTime=$(shell date -u
 GOLDFLAGS += -X github.com/algorand/indexer/version.GitDecorateBase64=$(shell git log -n 1 --pretty="%D"|base64|tr -d ' \n')
 GOLDFLAGS += -X github.com/algorand/indexer/version.ReleaseVersion=$(shell cat .version)
 
+COVERPKG := $(shell go list ./...  | grep -v '/cmd/' | egrep -v '(testing|test|mocks)$$' |  paste -s -d, - )
+
 # Used for e2e test
 export GO_IMAGE = golang:$(shell go version | cut -d ' ' -f 3 | tail -c +3 )
 
@@ -45,7 +47,7 @@ fakepackage: go-algorand
 	misc/release.py --host-only --outdir $(PKG_DIR) --fake-release
 
 test: idb/mocks/IndexerDb.go cmd/algorand-indexer/algorand-indexer
-	go test ./... -coverprofile=coverage.txt -covermode=atomic
+	go test -coverpkg=$(COVERPKG) ./... -coverprofile=coverage.txt -covermode=atomic
 
 lint: go-algorand
 	golint -set_exit_status ./...
diff --git a/README.md b/README.md
index 3ce5ee47e..76ad1941a 100644
--- a/README.md
+++ b/README.md
@@ -178,20 +178,33 @@ If the maximum number of connections/active queries is reached, subsequent conne
 
 Settings can be provided from the command line, a configuration file, or an environment variable
 
-| Command Line Flag (long) | (short) | Config File                | Environment Variable               |
-| ------------------------ | ------- | -------------------------- | ---------------------------------- |
-| postgres                 | P       | postgres-connection-string | INDEXER_POSTGRES_CONNECTION_STRING |
-| pidfile                  |         | pidfile                    | INDEXER_PIDFILE                    |
-| algod                    | d       | algod-data-dir             | INDEXER_ALGOD_DATA_DIR             |
-| algod-net                |         | algod-address              | INDEXER_ALGOD_ADDRESS              |
-| algod-token              |         | algod-token                | INDEXER_ALGOD_TOKEN                |
-| genesis                  | g       | genesis                    | INDEXER_GENESIS                    |
-| server                   | S       | server-address             | INDEXER_SERVER_ADDRESS             |
-| no-algod                 |         | no-algod                   | INDEXER_NO_ALGOD                   |
-| token                    | t       | api-token                  | INDEXER_API_TOKEN                  |
-| dev-mode                 |         | dev-mode                   | INDEXER_DEV_MODE                   |
-| metrics-mode             |         | metrics-mode               | INDEXER_METRICS_MODE               |
-| max-conn                 |         | max-conn                   | INDEXER_MAX_CONN                   |
+| Command Line Flag (long)      | (short) | Config File                   | Environment Variable                  |
+|-------------------------------|---------|-------------------------------|---------------------------------------|
+| postgres                      | P       | postgres-connection-string    | INDEXER_POSTGRES_CONNECTION_STRING    |
+| pidfile                       |         | pidfile                       | INDEXER_PIDFILE                       |
+| algod                         | d       | algod-data-dir                | INDEXER_ALGOD_DATA_DIR                |
+| algod-net                     |         | algod-address                 | INDEXER_ALGOD_ADDRESS                 |
+| algod-token                   |         | algod-token                   | INDEXER_ALGOD_TOKEN                   |
+| genesis                       | g       | genesis                       | INDEXER_GENESIS                       |
+| server                        | S       | server-address                | INDEXER_SERVER_ADDRESS                |
+| no-algod                      |         | no-algod                      | INDEXER_NO_ALGOD                      |
+| token                         | t       | api-token                     | INDEXER_API_TOKEN                     |
+| dev-mode                      |         | dev-mode                      | INDEXER_DEV_MODE                      |
+| metrics-mode                  |         | metrics-mode                  | INDEXER_METRICS_MODE                  |
+| max-conn                      |         | max-conn                      | INDEXER_MAX_CONN                      |
+| write-timeout                 |         | write-timeout                 | INDEXER_WRITE_TIMEOUT                 |
+| read-timeout                  |         | read-timeout                  | INDEXER_READ_TIMEOUT                  |
+| max-api-resources-per-account |         | max-api-resources-per-account | INDEXER_MAX_API_RESOURCES_PER_ACCOUNT |
+| max-transactions-limit        |         | max-transactions-limit        | INDEXER_MAX_TRANSACTIONS_LIMIT        |
+| default-transactions-limit    |         | default-transactions-limit    | INDEXER_DEFAULT_TRANSACTIONS_LIMIT    |
+| max-accounts-limit            |         | max-accounts-limit            | INDEXER_MAX_ACCOUNTS_LIMIT            |
+| default-accounts-limit        |         | default-accounts-limit        | INDEXER_DEFAULT_ACCOUNTS_LIMIT        |
+| max-assets-limit              |         | max-assets-limit              | INDEXER_MAX_ASSETS_LIMIT              |
+| default-assets-limit          |         | default-assets-limit          | INDEXER_DEFAULT_ASSETS_LIMIT          |
+| max-balances-limit            |         | max-balances-limit            | INDEXER_MAX_BALANCES_LIMIT            |
+| default-balances-limit        |         | default-balances-limit        | INDEXER_DEFAULT_BALANCES_LIMIT        |
+| max-applications-limit        |         | max-applications-limit        | INDEXER_MAX_APPLICATIONS_LIMIT        |
+| default-applications-limit    |         | default-applications-limit    | INDEXER_DEFAULT_APPLICATIONS_LIMIT    |
 
 ## Command line
 
diff --git a/accounting/eval_preload.go b/accounting/eval_preload.go
new file mode 100644
index 000000000..72b5269a4
--- /dev/null
+++ b/accounting/eval_preload.go
@@ -0,0 +1,202 @@
+package accounting
+
+import (
+	"github.com/algorand/go-algorand/data/basics"
+	"github.com/algorand/go-algorand/data/transactions"
+	"github.com/algorand/go-algorand/ledger"
+	"github.com/algorand/go-algorand/protocol"
+)
+
+// Add requests for asset and app creators to `assetsReq` and `appsReq` for the given
+// transaction.
+func addToCreatorsRequest(stxnad *transactions.SignedTxnWithAD, assetsReq map[basics.AssetIndex]struct{}, appsReq map[basics.AppIndex]struct{}) {
+	txn := &stxnad.Txn
+
+	switch txn.Type {
+	case protocol.AssetConfigTx:
+		fields := &txn.AssetConfigTxnFields
+		if fields.ConfigAsset != 0 {
+			assetsReq[fields.ConfigAsset] = struct{}{}
+		}
+	case protocol.AssetTransferTx:
+		fields := &txn.AssetTransferTxnFields
+		if fields.XferAsset != 0 {
+			assetsReq[fields.XferAsset] = struct{}{}
+		}
+	case protocol.AssetFreezeTx:
+		fields := &txn.AssetFreezeTxnFields
+		if fields.FreezeAsset != 0 {
+			assetsReq[fields.FreezeAsset] = struct{}{}
+		}
+	case protocol.ApplicationCallTx:
+		fields := &txn.ApplicationCallTxnFields
+		if fields.ApplicationID != 0 {
+			appsReq[fields.ApplicationID] = struct{}{}
+		}
+		for _, index := range fields.ForeignApps {
+			appsReq[index] = struct{}{}
+		}
+		for _, index := range fields.ForeignAssets {
+			assetsReq[index] = struct{}{}
+		}
+	}
+
+	for i := range stxnad.ApplyData.EvalDelta.InnerTxns {
+		addToCreatorsRequest(&stxnad.ApplyData.EvalDelta.InnerTxns[i], assetsReq, appsReq)
+	}
+}
+
+// MakePreloadCreatorsRequest makes a request for preloading creators in the batch mode.
+func MakePreloadCreatorsRequest(payset transactions.Payset) (map[basics.AssetIndex]struct{}, map[basics.AppIndex]struct{}) {
+	assetsReq := make(map[basics.AssetIndex]struct{}, len(payset))
+	appsReq := make(map[basics.AppIndex]struct{}, len(payset))
+
+	for i := range payset {
+		addToCreatorsRequest(&payset[i].SignedTxnWithAD, assetsReq, appsReq)
+	}
+
+	return assetsReq, appsReq
+}
+
+// Add requests for account data and account resources to `addressesReq` and
+// `resourcesReq` respectively for the given transaction.
+func addToAccountsResourcesRequest(stxnad *transactions.SignedTxnWithAD, assetCreators map[basics.AssetIndex]ledger.FoundAddress, appCreators map[basics.AppIndex]ledger.FoundAddress, addressesReq map[basics.Address]struct{}, resourcesReq map[basics.Address]map[ledger.Creatable]struct{}) {
+	setResourcesReq := func(addr basics.Address, creatable ledger.Creatable) {
+		c, ok := resourcesReq[addr]
+		if !ok {
+			c = make(map[ledger.Creatable]struct{})
+			resourcesReq[addr] = c
+		}
+		c[creatable] = struct{}{}
+	}
+
+	txn := &stxnad.Txn
+
+	addressesReq[txn.Sender] = struct{}{}
+
+	switch txn.Type {
+	case protocol.PaymentTx:
+		fields := &txn.PaymentTxnFields
+		addressesReq[fields.Receiver] = struct{}{}
+		// Close address is optional.
+		if !fields.CloseRemainderTo.IsZero() {
+			addressesReq[fields.CloseRemainderTo] = struct{}{}
+		}
+	case protocol.AssetConfigTx:
+		fields := &txn.AssetConfigTxnFields
+		if fields.ConfigAsset == 0 {
+			if stxnad.ApplyData.ConfigAsset != 0 {
+				creatable := ledger.Creatable{
+					Index: basics.CreatableIndex(stxnad.ApplyData.ConfigAsset),
+					Type:  basics.AssetCreatable,
+				}
+				setResourcesReq(txn.Sender, creatable)
+			}
+		} else {
+			if creator := assetCreators[fields.ConfigAsset]; creator.Exists {
+				creatable := ledger.Creatable{
+					Index: basics.CreatableIndex(fields.ConfigAsset),
+					Type:  basics.AssetCreatable,
+				}
+				addressesReq[creator.Address] = struct{}{}
+				setResourcesReq(creator.Address, creatable)
+			}
+		}
+	case protocol.AssetTransferTx:
+		fields := &txn.AssetTransferTxnFields
+		creatable := ledger.Creatable{
+			Index: basics.CreatableIndex(fields.XferAsset),
+			Type:  basics.AssetCreatable,
+		}
+		if creator := assetCreators[fields.XferAsset]; creator.Exists {
+			setResourcesReq(creator.Address, creatable)
+		}
+		source := txn.Sender
+		// If asset sender is non-zero, it is a clawback transaction. Otherwise,
+		// the transaction sender address is used.
+		if !fields.AssetSender.IsZero() {
+			source = fields.AssetSender
+		}
+		addressesReq[source] = struct{}{}
+		setResourcesReq(source, creatable)
+		addressesReq[fields.AssetReceiver] = struct{}{}
+		setResourcesReq(fields.AssetReceiver, creatable)
+		// Asset close address is optional.
+		if !fields.AssetCloseTo.IsZero() {
+			addressesReq[fields.AssetCloseTo] = struct{}{}
+			setResourcesReq(fields.AssetCloseTo, creatable)
+		}
+	case protocol.AssetFreezeTx:
+		fields := &txn.AssetFreezeTxnFields
+		creatable := ledger.Creatable{
+			Index: basics.CreatableIndex(fields.FreezeAsset),
+			Type:  basics.AssetCreatable,
+		}
+		if creator := assetCreators[fields.FreezeAsset]; creator.Exists {
+			setResourcesReq(creator.Address, creatable)
+		}
+		setResourcesReq(fields.FreezeAccount, creatable)
+	case protocol.ApplicationCallTx:
+		fields := &txn.ApplicationCallTxnFields
+		if fields.ApplicationID == 0 {
+			if stxnad.ApplyData.ApplicationID != 0 {
+				creatable := ledger.Creatable{
+					Index: basics.CreatableIndex(stxnad.ApplyData.ApplicationID),
+					Type:  basics.AppCreatable,
+				}
+				setResourcesReq(txn.Sender, creatable)
+			}
+		} else {
+			creatable := ledger.Creatable{
+				Index: basics.CreatableIndex(fields.ApplicationID),
+				Type:  basics.AppCreatable,
+			}
+			if creator := appCreators[fields.ApplicationID]; creator.Exists {
+				addressesReq[creator.Address] = struct{}{}
+				setResourcesReq(creator.Address, creatable)
+			}
+			setResourcesReq(txn.Sender, creatable)
+		}
+		for _, address := range fields.Accounts {
+			addressesReq[address] = struct{}{}
+		}
+		for _, index := range fields.ForeignApps {
+			if creator := appCreators[index]; creator.Exists {
+				creatable := ledger.Creatable{
+					Index: basics.CreatableIndex(index),
+					Type:  basics.AppCreatable,
+				}
+				setResourcesReq(creator.Address, creatable)
+			}
+		}
+		for _, index := range fields.ForeignAssets {
+			if creator := assetCreators[index]; creator.Exists {
+				creatable := ledger.Creatable{
+					Index: basics.CreatableIndex(index),
+					Type:  basics.AssetCreatable,
+				}
+				setResourcesReq(creator.Address, creatable)
+			}
+		}
+	}
+
+	for i := range stxnad.ApplyData.EvalDelta.InnerTxns {
+		addToAccountsResourcesRequest(
+			&stxnad.ApplyData.EvalDelta.InnerTxns[i], assetCreators, appCreators,
+			addressesReq, resourcesReq)
+	}
+}
+
+// MakePreloadAccountsResourcesRequest makes a request for preloading account data and
+// account resources in the batch mode.
+func MakePreloadAccountsResourcesRequest(payset transactions.Payset, assetCreators map[basics.AssetIndex]ledger.FoundAddress, appCreators map[basics.AppIndex]ledger.FoundAddress) (map[basics.Address]struct{}, map[basics.Address]map[ledger.Creatable]struct{}) {
+	addressesReq := make(map[basics.Address]struct{}, len(payset))
+	resourcesReq := make(map[basics.Address]map[ledger.Creatable]struct{}, len(payset))
+
+	for i := range payset {
+		addToAccountsResourcesRequest(
+			&payset[i].SignedTxnWithAD, assetCreators, appCreators, addressesReq, resourcesReq)
+	}
+
+	return addressesReq, resourcesReq
+}
diff --git a/api/converter_utils.go b/api/converter_utils.go
index 29bef855e..27451b191 100644
--- a/api/converter_utils.go
+++ b/api/converter_utils.go
@@ -525,7 +525,7 @@ func signedTxnWithAdToTransaction(stxn *transactions.SignedTxnWithAD, extra rowD
 	return txn, nil
 }
 
-func assetParamsToAssetQuery(params generated.SearchForAssetsParams) (idb.AssetsQuery, error) {
+func (si *ServerImplementation) assetParamsToAssetQuery(params generated.SearchForAssetsParams) (idb.AssetsQuery, error) {
 	creator, errorArr := decodeAddress(params.Creator, "creator", make([]string, 0))
 	if len(errorArr) != 0 {
 		return idb.AssetsQuery{}, errors.New(errUnableToParseAddress)
@@ -548,13 +548,37 @@ func assetParamsToAssetQuery(params generated.SearchForAssetsParams) (idb.Assets
 		Unit:               strOrDefault(params.Unit),
 		Query:              "",
 		IncludeDeleted:     boolOrDefault(params.IncludeAll),
-		Limit:              min(uintOrDefaultValue(params.Limit, defaultAssetsLimit), maxAssetsLimit),
+		Limit:              min(uintOrDefaultValue(params.Limit, si.opts.DefaultAssetsLimit), si.opts.MaxAssetsLimit),
 	}
 
 	return query, nil
 }
 
-func transactionParamsToTransactionFilter(params generated.SearchForTransactionsParams) (filter idb.TransactionFilter, err error) {
+func (si *ServerImplementation) appParamsToApplicationQuery(params generated.SearchForApplicationsParams) (idb.ApplicationQuery, error) {
+	addr, errorArr := decodeAddress(params.Creator, "creator", make([]string, 0))
+	if len(errorArr) != 0 {
+		return idb.ApplicationQuery{}, errors.New(errUnableToParseAddress)
+	}
+
+	var appGreaterThan uint64 = 0
+	if params.Next != nil {
+		agt, err := strconv.ParseUint(*params.Next, 10, 64)
+		if err != nil {
+			return idb.ApplicationQuery{}, fmt.Errorf("%s: %v", errUnableToParseNext, err)
+		}
+		appGreaterThan = agt
+	}
+
+	return idb.ApplicationQuery{
+		ApplicationID:            uintOrDefault(params.ApplicationId),
+		ApplicationIDGreaterThan: appGreaterThan,
+		Address:                  addr,
+		IncludeDeleted:           boolOrDefault(params.IncludeAll),
+		Limit:                    min(uintOrDefaultValue(params.Limit, si.opts.DefaultApplicationsLimit), si.opts.MaxApplicationsLimit),
+	}, nil
+}
+
+func (si *ServerImplementation) transactionParamsToTransactionFilter(params generated.SearchForTransactionsParams) (filter idb.TransactionFilter, err error) {
 	var errorArr = make([]string, 0)
 
 	// Integer
@@ -562,7 +586,7 @@ func transactionParamsToTransactionFilter(params generated.SearchForTransactions
 	filter.MinRound = uintOrDefault(params.MinRound)
 	filter.AssetID = uintOrDefault(params.AssetId)
 	filter.ApplicationID = uintOrDefault(params.ApplicationId)
-	filter.Limit = min(uintOrDefaultValue(params.Limit, defaultTransactionsLimit), maxTransactionsLimit)
+	filter.Limit = min(uintOrDefaultValue(params.Limit, si.opts.DefaultTransactionsLimit), si.opts.MaxTransactionsLimit)
 
 	// filter Algos or Asset but not both.
 	if filter.AssetID != 0 {
@@ -610,3 +634,20 @@ func transactionParamsToTransactionFilter(params generated.SearchForTransactions
 
 	return
 }
+
+func (si *ServerImplementation) maxAccountsErrorToAccountsErrorResponse(maxErr idb.MaxAPIResourcesPerAccountError) generated.ErrorResponse {
+	addr := maxErr.Address.String()
+	max := uint64(si.opts.MaxAPIResourcesPerAccount)
+	extraData := map[string]interface{}{
+		"max-results":           max,
+		"address":               addr,
+		"total-assets-opted-in": maxErr.TotalAssets,
+		"total-created-assets":  maxErr.TotalAssetParams,
+		"total-apps-opted-in":   maxErr.TotalAppLocalStates,
+		"total-created-apps":    maxErr.TotalAppParams,
+	}
+	return generated.ErrorResponse{
+		Message: "Result limit exceeded",
+		Data:    &extraData,
+	}
+}
diff --git a/api/disabled_parameters.go b/api/disabled_parameters.go
index 42fb31426..a5a385560 100644
--- a/api/disabled_parameters.go
+++ b/api/disabled_parameters.go
@@ -320,7 +320,7 @@ func GetDefaultDisabledMapConfigForPostgres() *DisabledMapConfig {
 	get("/v2/accounts", []string{"currency-greater-than", "currency-less-than"})
 	get("/v2/accounts/{account-id}/transactions", []string{"note-prefix", "tx-type", "sig-type", "asset-id", "before-time", "after-time", "rekey-to"})
 	get("/v2/assets", []string{"name", "unit"})
-	get("/v2/assets/{asset-id}/balances", []string{"round", "currency-greater-than", "currency-less-than"})
+	get("/v2/assets/{asset-id}/balances", []string{"currency-greater-than", "currency-less-than"})
 	get("/v2/transactions", []string{"note-prefix", "tx-type", "sig-type", "asset-id", "before-time", "after-time", "currency-greater-than", "currency-less-than", "address-role", "exclude-close-to", "rekey-to", "application-id"})
 	get("/v2/assets/{asset-id}/transactions", []string{"note-prefix", "tx-type", "sig-type", "asset-id", "before-time", "after-time", "currency-greater-than", "currency-less-than", "address-role", "exclude-close-to", "rekey-to"})
 
diff --git a/api/generated/common/routes.go b/api/generated/common/routes.go
index 68471ddfc..f5a02a12e 100644
--- a/api/generated/common/routes.go
+++ b/api/generated/common/routes.go
@@ -71,154 +71,158 @@ func RegisterHandlers(router interface {
 // Base64 encoded, gzipped, json marshaled Swagger object
 var swaggerSpec = []string{
 
-	"H4sIAAAAAAAC/+x9+2/cONLgv0L0fcAkuZadyewubgIsPmSTCTbYzGwQe2aBi3MYtlTdzbFEaknK7Z6c",
-	"//cPrCIlSqL6YTtOBtifErf4KLKKxXrz0yxXVa0kSGtmzz/Naq55BRY0/sXzXDXSZqJwfxVgci1qK5Sc",
-	"PQ/fmLFayNVsPhPu15rb9Ww+k7yCro3rP59p+HcjNBSz51Y3MJ+ZfA0VdwPbbe1a+5FubuYzXhQajBnP",
-	"+k9ZbpmQedkUwKzm0vDcfTJsI+ya2bUwzHdmQjIlgakls+teY7YUUBbmJAD97wb0NoLaTz4N4nx2nfFy",
-	"pTSXRbZUuuJ29nz2wve72fvZz5BpVcJ4jS9VtRASwoqgXVCLHGYVK2CJjdbcMgedW2doaBUzwHW+Zkul",
-	"9yyTgIjXCrKpZs8/zAzIAjRiLgdxhf9daoDfIbNcr8DOPs5TuFta0JkVVWJpbzzmNJimtIZhW1zjSlyB",
-	"ZK7XCfuxMZYtgHHJ3r9+yb777rvvGW2jhcIT3OSqutnjNbVYKLiF8PkQpL5//RLnP/MLPLQVr+tS5Nyt",
-	"O3l8XnTf2ZtXU4vpD5IgSCEtrEDTxhsD6bP6wn3ZMU3ouG+Cxq4zRzbTiPUn3rBcyaVYNRoKR42NATqb",
-	"pgZZCLlil7CdRGE7zec7gQtYKg0HUik1vlcyjef/onSaN1qDzLfZSgPHo7Pmcrwl7/1WmLVqyoKt+RWu",
-	"m1d4B/i+zPUlPF/xsnFbJHKtXpQrZRj3O1jAkjelZWFi1sjS8Sw3mqdDJgyrtboSBRRzx8Y3a5GvWc4N",
-	"DYHt2EaUpdv+xkAxtc3p1e0h87aTg+tW+4EL+no3o1vXnp2AazwIWV4qA5lVe+6qcP1wWbD4dukuLnPc",
-	"zcXO18BwcveBbm3cO+kIuiy3zCJeC8YN4yzcU3MmlmyrGrZB5JTiEvv71bhdq5jbNERO71J1ksnU9o02",
-	"I7F5C6VK4BI3z0spGS/LHfyyLJmwUBkv1DjWiBMULSudswJKwEV21wH+aqxWW1y8AddO1RaKTDXWE8Va",
-	"lW5AM0eM0LD0Obp8SpXz0lhuYVIgileyZ9GlqIQdL/dHfi2qpmKyqRagHcIDb7WKabCNlohsDSxHnC1Q",
-	"6hGuOy9ZzVdgGDjWK0iaw3nc0ZDKMg08X0/TPcG0h9Qrfp1p1cjiAKHFMqXjS8HUkIulgIK1o0zB0k2z",
-	"Dx4hj4OnE6UicMIgk+C0s+wBR8J1Aq3ueLoviKAIqyfsZ8+d8KtVlyBbJsYWW/xUa7gSqjFtpwkYcerd",
-	"6oJUFrJaw1Jcj4E889vhOAS18Sy08vd3rqTlQkLhuCsCrSwQt5mEKZrwWCFlwQ385U9TN3T3VcMlbJNM",
-	"d0gAtJxWK1q7L9R39yraGfYc6gPpcKmG9LeT9g6iO2yUEdtI3MLuq2cqaQ201/8AHTSem/Sf7E66KI0R",
-	"rreprRjM9PnEXiNWGY04OiVide7u4qUo8Z7+zR2OgNnGuHupj9twcxuxktw2Gp5fyCfuL5axM8tlwXXh",
-	"fqnopx+b0oozsXI/lfTTW7US+ZlYTW1KgDWpm2K3iv5x46V1UXvdLjc1RficmqHmruElbDW4OXi+xH+u",
-	"l0hIfKl/n5GWNzVzShF7q9RlU8c7mfcME4ste/NqikpwyF2MEJmGqZU0gOT6giSI9/4395PjdSCRlUdC",
-	"wOlvRqGQ241da1WDtgJiQ5D7739pWM6ez/7XaWc4OqVu5tRP2OkVduoOo5PLreddxLM8NyMpoKobS3d6",
-	"ii205/hDC9twzg4tavEb5JY2qA/GI6hqu33sAPawm/vbLfw/CndH7JsHmWvNt595H+lWz/B2Ho/8s5NB",
-	"HUuv+UpIXPicbdYgWcUvHTvgUtk1aOZwAcaG+534Hl35rQXLCwle0j6ZpU5MAqfmzkjtsPZWre4Ft3vs",
-	"OhcXH3hdi+L64uJjT84WsoDrNBo+K45LtcoKbvnhxNjbs1eua4Iuv17SGdrM7ouA7pd4jsDCw7LT+9qu",
-	"ez5s5jb0+x+GmjgVd2eqxoD9Gy+5zOE+sLzwQx2M4R+FFAjE38nA8R80BzS3W3kfKL6PA+zG2XtgsdHD",
-	"yow45X1skrmvXTqCwYX9+g/Nt7i8M8X/rVT55a1wuQtVOOqemX/QWul7oKIg5A1WPZ9VYAxfQdp0Fu9k",
-	"aHjI1gWAEe3gloAGhr8DL+365Ro+w2ZGY+/Z0vNOpb6Hjf2sxyrS/vetP1rVHqmtP+yRJyGaxnztu/f1",
-	"MKXelh/Oy3s4HXL0w3FsjkPyTbAixWaiRNiAD/ERkmyJTo3llnHvBSfr7oW8kK9gKSQ6a55fSMeHThfc",
-	"iNycNga0lxRPVoo9Z35Ip1VeyNl8eBFOmVrR0emhqZtFKXJ2CdsUFsgDm9bLy5VyWrlVlpeRKyryy3oH",
-	"QGdSGpMcTZA5ylCNzXw8Q6Zhw3WRAN207gccmRzEu2adMz82eUl8vIQfP30MeF2bDB15GXrypswS5cAo",
-	"Ycj7xxzKmLFKBx+IMAEaxO9Pynq/At8woi/WGDDs14rXH4S0H1l20Tx9+h2wF3X91o155uD41fsE3Hna",
-	"1uRZPdoEEQZLSTy4cMRnBtdW8ww9hcnlW+A1Yn8NzDQVOp3LkmG3nqGm1mqleeWdju0Cwn5MI4DgOOwu",
-	"i1aIizujXiGKJ70E/IQoxDZsDaX3pt0BX5EedWt07dHFdsQNXVx8wJCggJk2hGDFhTThVjBiJd0h8NEW",
-	"C2C5kwKgOGFvlgy52rzX3cf8eY7Zsg5hKECCnbs1om+M5Vxi4ERdYCCBkIzL7dAob8Da4AJ5D5ewPY9c",
-	"a0e6aLwfnu+5EovGDddeix2G2YYbVil0z+Qgbbn1rv0EaaaBaYS05GPMKXwic/Q7xTTw1EQRHO7gxCzE",
-	"jzEkxCiggdc1W5Vq4TlNS6LPWxoNfaaZyjsHgLkHhpJUnMI27Dh7NdeJjaCDOLEFt1ioG+9Ox3Dn8m5N",
-	"ckuhDYaNAPd3BI+PyC0oz8e0jEH51xpQKlMaYzv6JGXCkU4Rfeuyns9qrq3IRX2YqZVGf9fr4wbZd7Un",
-	"L3O1HN7Zoys1eYVQ42zBTfr6BvfFUWBjKN7JrTEwujATScu4ghOG/ml/VBclhkC14ZmEY64xNissm8IV",
-	"p0BLnwvQspOpAhj9HYmFtzU3IUwLo9kCizhIzJkg3nO3AUjA7txE1BvLrcLNW8IVn9r/adf4G1k43gGm",
-	"H7LWOr7DtTI8/vM2woTC0IODPHjFgyvc/euovSlLJpaskZdSbZxwfIyzez5zkl+TRpKSKPm5M7ei7aDG",
-	"gXw8wN+YCG0Oqn8ul6WQwDIm2j2wuAcUeKhyQdF33fn0c4BTDJ4wR4NugINHSBF3BHatVEkDs59UfGLl",
-	"6hggJQjkMTyMjcwm+hsOMDu1wRpe5dirGow5Sne05l04DKFxrM+1Lup3Q+aW1Np6rRg1WXgtJLrEUoTr",
-	"GFbu1H5pGgw+tSpX5clIXTNQAvL/rMdvM6eaJSU9QDI8C90iVY49EksneD2OGLyGlTAWtFfjEcI2oqgL",
-	"mNpacJBxa0G7if7fo/9+/uFF9n959vvT7Pv/ffrx059uHj8Z/fjs5q9//f/9n767+evj//6v2cTZgqzW",
-	"Si2nV2drvXTre69US7vYkWHH3jIffAVXykKG13h2xcsJz7Vr9NqgivEab/wkW+0hm1F8s5gw0OC0l7DN",
-	"ClE2aXr18/7jlZv2p1YrN83iErZ4eQLP12zBbb7G27U3vWuzY+qS713wW1rwW35v6z3sNLimbmLtyKU/",
-	"xx/kXAw44i52kCDAFHGMsTa5pTsYJGrUr6Ake/h03g0dzsI1PNllixodpiKMvUusjKCYvjtopORa+rEC",
-	"06vAwBKM8BY2Cmc3oxUdqgagjZTug2gap3X6ET67uB+vLhb5/Shpmd9/vMPyxsMfurz7igRC7B2jzZJa",
-	"PCIwPDh+sD3EFRnYxkGhVmkIRkI6LZFARTkfMl7b+Bh1WQeHISaIID4JQjXtVTqY5rMRIIzTI/zaU7TI",
-	"llpVePLG2l1EnGJCb+mRYHflDGb1WZxjenHME7OL9voZgJf/gO0vri1i1fWmfBEhDz0ynRqHPZmQVt0D",
-	"au5mMU1Rvh9xL+VTdNsU2WO+H5mteh6QI09AqVZpraxcodyhVl3ofEwOC3BaDVxD3tgua2JgdWkNQw8r",
-	"TQ4tTOlo58i5Rcmnu+UH3Cg/1h7UvWv55OfEHK9rra54mXmXwBSP1+rK83hsHjwIDyyOpY/Z+Q8v3r7z",
-	"4KPxGbjOWnVmclXYrv7DrMrJJUpPsNiQWrjmtrXUDu9/7xIQpudG2GBG2kBjdpKWJy5i0J2LKDq93q2w",
-	"DHL5kU4C782iJe7wakHdOrU6ayT5tPp+LH7FRRnMgAHa9KVCi+s8iUffK/EAd/aHRW7N7F5vitHpTp+O",
-	"PZwonmFH6llFCZCGKZ9i1uq5qNyiTREJtOJbRzfkjB2zJNlUmTt0mSlFnjYUy4VxJCHJx+kaM2w8oSa7",
-	"Ed1dnB6rEdFYrpk5ILpuAGQ0R3IzQ4zg1N4tlA/CaKT4dwNMFCCt+6TxLA6OpzuNIX361ipQwhNCadYP",
-	"qAThhMeoPz4d+E6La0e5jRLk9JrxpB5rfj0t7u6i/7ihpjQfBGK38hO7q0fgvmotpYGKWj87lz3P3hFR",
-	"L/GMIyljR8SKP3yeVTRSeK//LbCzvzpIULR82vhErsrUVfti+pp14x9xwXb3KQIW36SUyc5LoxLDNHLD",
-	"pQ358H63fG8DZNZ2vTZKG4sFFJJxXEdpinGe/Z30Q5Mttfod0vZRNCtvxtNHE1Pv9OAH63kDzjCh77WY",
-	"mSaUfcTYViq4K0itfeDOQA2lg9ap0xXHCbQfo2uSwUypKNFH1o8Nm7jEkNdEEQiojAf/GJfEXF5iuZ2e",
-	"dphmUXHQ4CmN37EoD/PYhsM3C55fpjUFB9OLLu6m58mzioXObTWKPr5OWBTC07b1hR1q0JWw/SuvO6i3",
-	"lfr/aOwoFxUv0+J/gbt/3hMoC7ESVFijMRCVhfADsVoJaYmKCmHqkm8psqnbmjdL9nQe8TePjUJcCSMW",
-	"JWCLb6nFghsUzDozXejilgfSrg02f3ZA83UjCw2FXfuKJUaxVjNDK1frUF+A3QBI9hTbffs9e4ShBEZc",
-	"wWO3i17cnj3/9nsspUF/PE1daL4Ezy72WyD/Dew/TccYS0FjOFHBj5rmx1REbZrT7zhN1PWQs4Qt/eWw",
-	"/yxVXPIVpAP0qj0wUV/EJnrsBvsiCyr6g4IlEzY9P1ju+FO25madloUIDJarqhK2cgfIKmZU5eipK0tA",
-	"k4bhqIIQ8foWrvAR4zZqlrZhPqw9jTL8U6vG6JqfeAX9bZ0zbphpHMydbdAzxBPmK3MUTMlyG1lvcW/c",
-	"XCiqOMEabexLVmshLVoHGrvM/g/L11zz3LG/kylws8Vf/jQG+W9YvoSBzJWbXx4H+IPvuwYD+iq99XqC",
-	"7IPQ5fuyR1LJrHIcpXjsuXz/VCYNqMryMh2nHDj6MEx999CHSl5ulGyS3JoeufGIU9+J8OSOAe9Iiu16",
-	"jqLHo1f24JTZ6DR58MZh6Of3b72UUSkNfSP3IqQO9OQVDVYLuMKQ6TSS3Jh3xIUuD8LCXaD/siEOnQbQ",
-	"imXhLKcUAUr/G2+H+zle9pQ5QanLS4BayNXpwvUhUZ1GHQrpK5BghJm+QFdrRznus7vyIusPDs0WUCq5",
-	"Mg9P6QHwCR/6CpAnvXm1D+rRwKHAWIZNpzfGtXNTvAsFyWho1/5L3EhtrO3exNL3vu10aKy7xii54qVP",
-	"haAIp763mda74egTAFmQWIfsb82FnIiXBSgmovwAZzxT2gqKswH4AjF7VlRgLK/q9DWLRnI6iXiqHaBt",
-	"F6eNGMiVLAwzQubAoFZmvS+DcyLz6FriZKUwdOXEpcJypalmE8oUVg2y6w6N/d+ZR9iHMdNK2SlAUfiI",
-	"E0CVsow3dg3StrG1gNUzhyuh7ADUOOhCIZbFfnQ8PlS74mW5nTNhv6FxtA+V5KwCfVkCsxqAbdbKACuB",
-	"X0FXKhVH+8aw82tRGCyEWsK1yNVK83otcqZ0AfqEvfaedNSCqJOf7+kJ83lRPjb4/Fri8goFpCLF66Rl",
-	"hhDv1m8Tr3hOF+jwZ6wvaqC8AnPCzjeKgDBdLqlxQkivx6KxlFNRiOUS8JziclB5wn7dhwgmLPqKpWfb",
-	"Yf2avsBpu5YZyscTSqQlS8W1fEmNmE9E6DvDBkejIo01EFQJxQr0nEyquO2igi532MluStvOYLMEis93",
-	"nE1Iq1XR5EAZq2c9eozAEiOQ2iqWUTQD0lCoudvBGYwtgac6hRwF3KckZknVXyHiDq5AswWAjAZ6REwn",
-	"gstYrjEMBKNC/FKheJxmzk290ryAw3y4yAR/ph5tpmUY4UodN8Avrv1QbOrJJr0bP31LR9Hw7paJeXmK",
-	"l02KXu+nEldeUylhDSXlDmAVWmw7HwlWS4DMCJm2fi4BkLfzPIfakXP8ygCAY1QkxCKrwFTHcLc6DEsr",
-	"roCyGnYIA1nOy7wpKfZ1x02/yXmp+y6jEpZWOQKLi093JkHh5lpg7C2Vb6X5tGOAUQ+s8XAFeutbkPYU",
-	"qqW6w6EHcQ7j7KGshCtI6zTAKYno72rDKi63LS7cFB0YczoveFRayElWQSc6Yftnr9hF4NNh8lS3G0iH",
-	"ionNLWI816CFKkTOhPwN/Glu2VKgGCq7rKQVssFq1Ro6uOmeYJgPNcx5GlOAnsrqdh/6gfMSNj1sF5E8",
-	"1w8zN5ZfAoEdMrf81XgoTjUYUTQTpkzN8z5kxxGjP7zvuYVT3aLW3BNdDjhUe8h3HbohLQ/IZoCt8S5N",
-	"8qke8z2EWfE2K4d5Rp2IvPXlIkLLCd1HWRUsTiFduh37CrTpx3RGNkC43jO2a9Ebn4poaEX2heNnyULI",
-	"jpmcb0vsuKO5IHxRviP2Bx8zktjBiQojLQBmI2y+zibSWFxbakFpQANNazwliRB4CmG5hNweAgPmQ1D1",
-	"8Uko6LOD4hXwAlPwutQWSmoZgvLoJ8Xc0CaSa6QRKIV2Yg2O8viIMoIthewj/l/UgbR/pfB/6CI94BgE",
-	"QcbjPm32pDaeeLp8T862YHBX2gjd6IzUyvAy7eEJkxZQ8u2uKbFBf9JWsA1OLrpzuLvD3IVCEcHpUOto",
-	"an/Odk3umgwX3B7P8amIqxsPMfnDFS8nMm7eQ63BOIGRcXb+w4u33pc3lXeTT6aJceuzWC1nk4nnN3NU",
-	"eNIsgkLj8Lt/lSNpx5wKh6NoOPd51Pt2QQZTBZqiDQ3RlWOA/hGC/1nNhXdUd0lH4531iWjj1MBDEgg6",
-	"BA8X4dO7cJDUSuKyXeNoCLbGz1TQg4Xy1WPgJ6ubFYusjW1N1a+fz3x1srgk096AdmGySqw0Mp30qNNV",
-	"1SJrXCJBkC67xEsqnrFM34aDfe8tfABxB16nSoWZUzgaVdRMIMqIqi7JyeqHcvdr3IsdlUTXxb19/jDK",
-	"+47Q+uwxVnBrB9/9h1bdFpb9CfO7w6j+KV+qqi5h+j6oyT1ODwrRzYklGqKnY4KpReV5ozsb3DBQ6hde",
-	"CnrTwGCZBqlUjXUZaiuk+w/mo6nG0v+Ba/cfKhrU/x9RVVS9wQ01Q7wIOfPlf1RjQ7j5zF3ZBSkMvm+q",
-	"usMtc1oPMh6P75oER9wZ6N674xEzJZm8u+B9dyrxywq/xDkCjADBYA0T/jKsAAu6crLrWm1Y1eRrDIvn",
-	"KwhR8hiBgobTwUS90UMwXT/bwzsfTc1zGogClEquV6CZjxlivqBuG3hUcTF4LGYYFoCqLE/dv/ti98eP",
-	"JKG0FEXwJ1IEAhiXsD0lYQB/vwXjmE4EmAAM0wE+I0h3yiqIE1P20OtlT46iCmC9XJ4W/HuUpxx8/qwd",
-	"KU+NU24OXR6uA49DY2C8zsOdTfHeJlhFt7ZDlYHx5k7L8HZxiAyfLuXjuqMSQRuC5bUYgsp+/fZXpmHp",
-	"36h78gQnePJk7pv++qz/2RHekydpDeyh1AfaIz+GnzdJMf0as8MX/JChGayG6J/Yy1VVKYmGprIcePlk",
-	"wTDuyeCbe5KBvIJS1ZBsTRscIR1zeTSsmpKTd0tICbrX6ZDAZSNWEgp7LSki4gz/PL+WqbbxVY+to+1I",
-	"1SCN3o+4XXHeQbE5CiCn91BvO2IX4t2NGJ7ivf2IrykOtR0Rh1qCvsuY536MA+o+rqSm3EUKxBYhLAmF",
-	"NMLw4FmtEKoU6kGGgOvWgwv/bnjpPdQS/cHnGHScX4KkUo/tS7RWMZCm0d4h7GDF8RwofhgVX/Cma3Lb",
-	"oo/ZrkJqGo3lrR3eh6FhAD11daJH4ZCjdheSc+2FXGU78opyTCzyDUPiKFq4dtb0c4M7ItQVFAcWDIj9",
-	"YZg8F/rvyC6iepTdIy7ptLLoWT85Lq/BHr159Zhh7ZypKibRK237lx0XiDwMIoptHMEyTCM8BoolwJQT",
-	"chC3wZYwYc/eVwJqedVVf8JWQ8PxXigPDET7OzdYzsk39w7zrzT6rAekf6JtPFSc9nx0iaD5bKVVkw5W",
-	"WlEq/iCMEhUDFLoohMas+Z+/fXb67M9/YYVYgbEn7F+YK0SX77g8Xh+bTHRl93rVPRkC1ubakjzk4ySi",
-	"OdceoaN4GOHjJXCYh8fwbSpTzGcol2T2OhXT9WYks7DaB5dgmmjEb3rG+vuI5BLSak7MN1PLZTJ1+p/4",
-	"e2dK0oEnaxhj/QCuTI8g3lIq+Ae9oHgzn+2pxVZetWXYbsd4SpiqnVpeJ47Pd8+y7gSdsLeuNwO5VNpp",
-	"2lVjnQyAjz4HW2dPSsVcG9vVkcY0G/k7aIWGBMmUzGF0B4poszE2hOcozxsf4ORgaHOk2yj0R2cozcwJ",
-	"yMekp46PGmukFST+uG38JdrF2l08Duh/rUWZoIJaue8mhmPOpGL0QkLckiL5upwxgtnHafcI6WGPeVwn",
-	"okjbyRwlFFRzpyuv1Fkp8jWXXcn3/cV4xjR5zGOPfd4/POb3WTRoB5xftmqQVBNBLdKXRnQKCmZvtRa1",
-	"hwW45tsKpL0l53tHvSlehl6m360B6AkNIPTeV0B66r1oN7b72GYPt6oW2k6J20ZrnE/oPW1kQCiW38mu",
-	"dIKciLBsMOYyClMNtlOv0rU2+EvYMh1MA3EV2u6x5CO1LLoWrUhlN52LCjq9hAS5lAgkDroSSb1M67UU",
-	"cE8s+5sdy+memN5JFWaCKsLT0rtoosXCEWR71vbpP6A8tqRta+iHD/TqY/fjZVHHP2Gv2jhm9LVQRF8X",
-	"3Ez2p6FHhrKB2+RsoYOdiutgc0anzcXFh5qiKRIH1zcgWca1GUs1vgnPl6v2lY2E4SY0u16C7tqljCeh",
-	"5VL/3jUc221Cs/EDLT3OM7+Pt6nTZ8ijOcMJErFxs77i2JPl2sPQUcseI+TO0qY+4gedNtHFdqyFMLZr",
-	"U4GD7oeXvCzPryXNlAhA6V5vTrkcqVqwz+VomaTjpN7rGAxH/oDGDhKe507KKrpY0QjObwwb1qSiCNJx",
-	"VareJX4kk0y8odOSG9eryXWjzWgsCYqccb1qKrLpf/717VnBZCVWUfg0snE5US810UlvNBRMaZ9AIpY+",
-	"O2iqHs6BNQLp7SF88b6Tzrrw1QlKnzv9A2pfrUHJLG8d4u6qckqeVeyCHMkXsxP2hoLNNfCCeKYWFlLV",
-	"6nrrx8zXDZQlmvSJorMWu1Et0hN3inrVAA1StgZ8YihRn/KPWv+Q16aZwNgUVyLBpo+kL4Chl26mru48",
-	"ISnnUir7B8LTkfUPB4+sReEfdd0WQixBhrf+SPTFYSfMpEqDWMldDyMtebgIzBBdyeugz6V8kluMeDO6",
-	"JVqJ+HZMFJ0fNBi9f8KLTMlym+KucULjgL22e7HzdaQ2xdF0IUPGrzKqpnPYEgObeRetEAkbteZ397u+",
-	"W5SrvHONysEAPa6xr28vLmrv8/f9ofdJZpGjcadkRqVdSrdw4k8asnB/Bo4lC6r60nRhVhfyBfsdtPL6",
-	"YjuUOxCdedqn/vus3JNEp7ZEkxl1G055ZAksWvwO6XCyjN7FxYdrPpIyEKY7yBe3q4i4F8evJ0oQxTgO",
-	"3ipfc+iOtcVoxh0bO/X258XFhyUvikE1ljj0iphMW02EdtvXYkJi4ZuJskc7sbncic0d4/dSNzZB4dvx",
-	"PlNQEClJZhN2nHqkwlGnQyu7anXjqQ85/K3//iDSCErvXYkjzLqDPHZUyeQV6mQv2gLIHjjVwnfCPAvx",
-	"vu7wuw6mlHIZuFlwjwUH7uCBLHr0nVW8vtcanHuZRwTxtNsfJp3+XUKUv5jDeFGtBxygiy4YPsN1t/f+",
-	"wuhpDOLXYRoMjwvBdE9/aqgwh6tTMRPI8QXkWrGwq+xHgRQY9xCHhptohnivGXvjRublhm9NMJV2hDU9",
-	"XNhVqhiTMNPFSZ5k303vjc7RMfYeclELfM20zwVbGp82ME68JkuGSsd0KPtMXLVGCx8bzruSjH3nV/B9",
-	"+eJyPLqg536bedm3FtDAwRjs2rwMY4cVtSiN7rMDXmJLlOpst3QPz/PeyZ3MzlsKj+Vx1IuYHE0zzd3k",
-	"8NGkCbeIdI0c0n7k+rJ3B3LTf8mRkiB6o/ZEjCh14RbPuHlnwrvunSoMxW5N+7+AJgfmey4LVbHXjSQq",
-	"ePTL+9eP/QvvgchC2QNHfB6Sr/SFt1ov/crPBu+6hUh08mmshLE6Ybf8el99W45ffUu8feZWd1/vvV0W",
-	"X+i9t3L03tvtV3r4S2/hxEy98/ZVEtAeTSI4OHdzT++LOZZ9+m7EP/1MtxMPSTqceO/ftvWuBhf/nYSs",
-	"3uu33LKNkz6Mr1naCVv9oM6uerBsYzMjP8LeoM/+eBPPung5CyfBooeJR1ONf4w33C3Rs+v0KhdVPS4j",
-	"4WfZyMIMtrB7aWSHB3Sn7ONFn9BmpzN1Sig4VBI4i12lfUjQFelTQdpHf4ePCWElWqo5iw8v05u/wzJS",
-	"3VbWWl2JIvXGR6lWIjdkgTnWZ/s29L2Zz6qmtOKW4/wY+pITOX0dipW/CmXBdcGgePbnP3/7fbfcr4xd",
-	"jTcpGWDjl+WNjNyKvC/Htqs7gIkFVJ6s1JhlTfra9KpzPbS+tTnWzu7i145zkSEg6fVGiw0hGost4xGp",
-	"Kye2l1Z0P83db2tu1h3rjOqfY116zjy/GsbdYdbPl3lMKjoU2Z1CIwbHY4pxdIfkazgbg7fWRH4wS/wx",
-	"4iTj8uB+iWR2dfQSUiFxr+sSnGzX8cDxucn1trbqNKCGrvww55kYP5kSj5fedWyA9U6Vk0SoQIITJjuJ",
-	"Cw0EHVS3iM8d7c9ZDFeqDONag3EQpeNp1vri4mNa2JyqGuCky3SnmyNxezbY0/6O075NSrj1JQHxwDrb",
-	"bhp4eJDGe36DIdtLlMZyJS3PUW6kAtyzF95gNvP1nmdra2vz/PR0s9mcBGvaSa6q0xWmnWRWNfn6NAxE",
-	"rz7FieC+i6+U6LhwubUiN+zFuzcoMwlbAkawF3CNVruWsmbPTp5S/QCQvBaz57PvTp6efEs7tkYiOKVa",
-	"HVRtGNfhSAQFozcF5glfQlztA+urYz0P7P7s6dOwDV5riJxVp78Zou/D/GfxNLjJ/Y14hN6Vx9H7DmMS",
-	"+VleSrWR7AetFZ0X01QV11tMU7WNloY9e/qUiaWvUYJ+Rcvdrf1hRimSs4+u3+nVs9Moamjwy+mn4LAX",
-	"xc2ez6eDYrKhbeRaTv96+qnv+Ls5sNmpDzQObYOLt/f36adgWbvZ8enU58rv6j6xPirSdfqJ4jdJU4um",
-	"SnfqCVqf7LWHDg1a2pH17PmHT4NzBde8qkvAIzW7+diisz2RHq038/aXUqnLpo5/McB1vp7dfLz5nwAA",
-	"AP//Ltl59z6zAAA=",
+	"H4sIAAAAAAAC/+x9+4/cNtLgv0L0fUBsX2vGcXYXFwOLD147xhrrZA2PkwXO40PYUnU3MxKpJamZ6fjm",
+	"f//AKlKiJErdPTN+LJCf7GnxUcUqFov14sdFrqpaSZDWLJ5+XNRc8wosaPyL57lqpM1E4f4qwORa1FYo",
+	"uXgavjFjtZCbxXIh3K81t9vFciF5BV0b13+50PDvRmgoFk+tbmC5MPkWKu4GtrvatfYj3dwsF7woNBgz",
+	"nvWfstwxIfOyKYBZzaXhuftk2JWwW2a3wjDfmQnJlASm1sxue43ZWkBZmJMA9L8b0LsIaj/5NIjLxXXG",
+	"y43SXBbZWumK28XTxTPf72bvZz9DplUJYxyfq2olJASMoEWoJQ6zihWwxkZbbpmDzuEZGlrFDHCdb9la",
+	"6T1oEhAxriCbavH0/cKALEAj5XIQl/jftQb4HTLL9Qbs4sMyRbu1BZ1ZUSVQe+Upp8E0pTUM2yKOG3EJ",
+	"krleJ+zHxli2AsYle/vyOfvuu+++Z7SMFgrPcJNYdbPHOLVUKLiF8PkQor59+RznP/MIHtqK13Upcu7w",
+	"Tm6fZ9139urFFDL9QRIMKaSFDWhaeGMgvVefuS8z04SO+yZo7DZzbDNNWL/jDcuVXItNo6Fw3NgYoL1p",
+	"apCFkBt2AbtJErbTfLoduIK10nAgl1Lje2XTeP4vyqd5ozXIfJdtNHDcOlsux0vy1i+F2aqmLNiWXyLe",
+	"vMIzwPdlri/R+ZKXjVsikWv1rNwow7hfwQLWvCktCxOzRpZOZrnRPB8yYVit1aUooFg6MX61FfmW5dzQ",
+	"ENiOXYmydMvfGCimljmN3R42bzs5uG61HojQ17sYHV57VgKucSOM0f/h2m/3ohDuJ14yYaEyzDT5lnHj",
+	"odqq0m12s2SRJGOlynnJCm45M1Y5CbFW2h/dJD6Wvn+njbAcCViw1W7YUha90ff3cesD13WpHGZrXhpI",
+	"r1fAPl4kxDI+JHlZLrzodRqDnzJrf+B1bTLEODOWW4jb1LVrIZWExEna/sC15jv3t7E7py6gjFh01Mny",
+	"UhnIrNqjSQTlABcsOvvjFTtKr2DvtsBwcveBdCrkbOnETVnumPUEcAzBghaxZGLNdqphV7h1SnGB/T02",
+	"jqcr5oiPJOupPE5vnGLu0WIkWHulVAlcImt7HTJz9Js+zcrA19TcHVw4QdEedEtWQAmIZMeE+KuxWu0Q",
+	"eccKS6ZqR3TV2PHmkIUflj4P9woyzqS6GmOyB+lSVMKO0f2RX4uqqZhsqhVoR/Bw8lnFNNhGSyS2BpYj",
+	"zVa9nV/zDRgG7mAUpGvjPE5wSWWZBp5vp6USwbRHEFX8OtOqkcUBKqVlSsdHtqkhF2sBBWtHmYKlm2Yf",
+	"PEIeB0+n6EbghEEmwWln2QOOhOsEWd32dF+QQBFVT9jP/uzAr1ZdgGyPGBKWwGoNl0I1pu00ASNOPX+Z",
+	"k8pCVmtYi+sxkGd+OZyEoDb+gKu8dpUrabmQULizD4FWFkjaTMIUTXisCrniBv7ypyn9qfuq4QJ2SaE7",
+	"ZABCp72zbt0X6juPRTvDnk19IB/SGRvz3yzvHcR32CgjsZHQkdxXL1TS9oFe/wMsBPHcdDvN7mQpoDHC",
+	"8Ta1FIOZPt2lxIhNRiOOdonYvHNn8VqUeE7/5jZHoGxj3LnUp204uY3YSG4bDU/P5SP3F8vYmeWy4Lpw",
+	"v1T0049NacWZ2LifSvrptdqI/ExsphYlwJq0HGC3iv5x46UtBfa6RTc1RficmqHmruEF7DS4OXi+xn+u",
+	"18hIfK1/J92rnJo5dU1+rdRFU8crmffMRqsde/ViiktwyDlBiELD1EoaQHZ9RhrEW/+b+8nJOpAoyiMl",
+	"4PQ3o/AK0o1da1WDtgJiM537739pWC+eLv7XaWfWO6Vu5tRP2N367NQZRjuXWy+7SGZ5aUZaQFU3ls70",
+	"lFho9/H7FrbhnB1Z1Oo3yC0tUB+MB1DVdvfQAexhN/e3Wqanzh+4bkOV/BOuI53qGZ7O45F/Nv7aVPON",
+	"kIj4kl1tQbKKXzhxwKWyW9DM0QKMDec7yT068lv7olcSvKZ9skjtmARNzZ2J2lHttdNzz1DPvQ8SDy5d",
+	"R9A6BdIflG8pP1rY+2SBzT3Rftbwen7+nte1KK7Pzz/0rlpCFnCdpscnJXapNlnBLb8dj25euK4JBv2a",
+	"eahv1L4vBrpf5jmCCp/3RL2v5brnzXYrGfuHZE3sirsLVWPA/o2XXOb3cpyu/FAHU/hHIQUC8Xeycf1B",
+	"5kDmdinvg8R+de9lI5O9+uAt/AdxU3u49QLcmbT3RdKDCPmZb4Q45X0s0pdi/D84/n45/m+lyi9uRcs5",
+	"UuGoe2b+QWul74GLgv4+wHq5qMAYvoG0YTxeydDwkKULACPZwaGA5sO/Ay/t9vkWPsFiRmPvWdJ3ncHs",
+	"Hhb2k26ryLa3D/8Iqz0KeX/YI3dCNI352lfv6xFKvSU/XJb3aDqU6IfT2BxH5JtgI46NwImQLR9eKSR5",
+	"CoSSjlLcRyCR7+ZcnssXsBYSXbFPz6WTQ6crbkRuThsD2l8CTjaKPWV+yBfc8nO5WA4PwilHCgaZeGjq",
+	"ZlWKnF3ALkUFin5Jm1zKjTo//8CssryMHM1RTIx373UG4zHL0QSZ4wzV2MzHkmUarrguEqCb1rmII1Nw",
+	"ztysS+bHJh+oj1Xz46e3wSjAY8LiVA7sTSYRByNkP1DF0fcnZb3XkF8x4i/WGDDs14rX74W0H1h23jx+",
+	"/B2wZ3XdGS1/7aJqHNDotrhXCygijvTM4NpqnmEcQBJ9C7xG6m+BmabCkJKyZNitH7yj1UbzyocUDMOC",
+	"ZghAcBx2lkUYInJn1OtmGSmDYwq6T0hCbMO2UI4Di46lV3SLujW59tzEZmI2z8/fYzhmoEwbILThQppw",
+	"KhixkW4T+Ei3FbDcaQFQnLBXa4ZSbdnr7uOtvcRsRYcwFJzG3jkc0fPNci4xaK0uMExISMblbuhyM2Bt",
+	"cHC+hQvYvYsc50c6YH2UDd9zJBaNG649FjsKsytuWKXQ+ZqDtOXOB+4kWDMNTCOkpQiCXhjYhNDAXRPF",
+	"Z7mNE4uQiQi3KFyJ1zXblGrlJU3Lok9bHg19poXKGweAuQeBkrw49SPm0gvBdWIhaCNOBfkdj6gb707b",
+	"cBa9W7PcWmiDQWHA/RnB4y1yC87zEWtjUP61BdTKlMbIrT5LmbClU0zfBqQsFzXXVuSiPsyKTqO/6fVx",
+	"g+w72pOHuVoPz+zRkZo8QqhxtuImfXyD++I4sDEUzehwDIIuzETaMmJwwjD6xG/VVYkBjm1oPNGYa4y8",
+	"DGhTqPgUaOl9AVp2OlUAo78isfK25SYEYWIkcRARB6k5E8z7zi0AMrDbNxH3xnqrcPOWcMmn1n868OWV",
+	"LJzsANMPSG3DWsKxMo4LDvFjlAIUwl9CzEsIdHH/Om5vypKJNWvkhVRXTjk+JpRluXCaX5MmkpKo+bk9",
+	"t6HloMaBfTzA35iIbA6qf67XpZDAMibaNbC4BhT0rXJBsbXd/vRzgLsYPGKOB90AB4+QYu4I7FqpkgZm",
+	"P6l4x8rNMUBKEChjeBgbhU30N6RveKjgoa5HgbRCprkxD3LBaZi9wxIBw0j9FYCkeFwm5JK5e94lL522",
+	"YhUpL+0g6bj1Bz1V26t55uGUHp+2PhBGeIodhROde7fBJlYWA9BpTXYG4nm9JUUCg+tFWkS3VjPR+Xun",
+	"ntAVptbqASJ+BwCGZs82FNBfefdeTccnWifal12wJYmRNLdPcUySLhMrNrZUtKFVb4bHdtIe0WvFqMnK",
+	"368j9Swlkt2uyJU0IE2DKS1W5ao8GRkiDJSAmk3W0ySyC9il7zCAAvYsdIuMFOyBWLsrxcNIddGwEcZC",
+	"L+2kjYTtAn13mKpRc2tBu4n+34P/fvr+WfZ/efb74+z7/3364eOfbh4+Gv345Oavf/3//Z++u/nrw//+",
+	"r8XEqQFZrZVaT2Nna712+L1VqpXK2JFhxx6anx2DS2UhQwU1u+TlRLiNa/TS4OX5JeqySYWhR2xGWVNi",
+	"wvSI017ALitE2aT51c/7jxdu2p9ae5NpVhewQ7UQeL5lK27zLeqNveldm5mpS74X4deE8Gt+b/gethtc",
+	"UzexduzSn+M/ZF8MZO2cOEgwYIo5xlSbXNIZAYlH/QsoydMznc1Lm7NwDU/mrKyjzVSEsecuTBEU06cS",
+	"jZTEpR/gNI0FRsNhZpKwURqWGWF06AUXrf90HkTTXPH2Bv/JL7IxdvFl1o+Svs36j3dAbzz8oejdV/gi",
+	"Uu8YOw1pSiMGw43jB9vDXJHpeJzM4JTkYP6m3RJdFShXUca4jbdRly13GGGCCuKT91TTHqWDaT4ZA0Li",
+	"KkG4p3iRrbWqcOeNldKIOcXEjbzHgt2RM5jV14YY84sTnpizvNeDBrz8B+x+cW2Rqq53UEwP3TKdgSLc",
+	"Yfy15W6kuZsvIMX5fsS9nE8huVNsj1UEyCDb8+0duQNKtUnbG8oN6h1q06V8xeywAnf3g2vIG9tl+w3s",
+	"ia3J8/Nqk0PbaTpLJ3LbUkmLef0BF8qPtYd0b1o5+Skpx+taq0teZt7ZNSXjtbr0Mh6bB9/YZ1bH0tvs",
+	"3Q/PXr/x4KNbBbjO2uvMJFbYrv6PwcrpJUpPiNiQEr/ltrUkDM9/7+wSpucgu8JM6sGN2WlanrlIQHfO",
+	"z2j3eofZOujlR7q/vJ+WUJzx10Ldums7Ozt5a/seWn7JRRkM3AHa9KFCyHU+8qPPlXiAO3t6I4d9dq8n",
+	"xWh3p3fHHkkUzzCTMl1R4r5hyqdGt/dcvNyitRwZtOI7xzdknhyLJNlUmdt0mSlFnnaByJVxLCHJe+8a",
+	"M2w8cU12I7qzOD1WI6KxXDNzgNFtAGQ0R3IxQ/Tr1NqtlA8vaqT4dwNMFCCt+6RxLw62p9uNoSjLra9A",
+	"CR8fFW/5jJcgnPCY648vY3En5NpRbnMJcvea8aSeah6flnZ3uf90NuKx/odAzF9+4kCMEbgvWktp4KLW",
+	"7s5lz2d9RDxXPONIy5iJxfKbz4uKRgrvBbgFdfbXHAsXLV/uJC0ujrpHxdVT7nR7Mtlaq98hbT1Eo+vV",
+	"ePpoYuqdHvzgW9Bg30zchsSgpNItSNXWn7krSO3t+c5ADc/O1pnSFaTriDS56abU9tjp048EnBDsuP+i",
+	"eBO8oAZvKJe04Z5jYbvejSm9beMQ0VMav9u2HuaxXYNfrXh+kdaeHUzPuiirnt/WKhY6t5WF+lQ6YVHA",
+	"VtvWF+mpQVfC9o+B7mJ2W02Ypj1YB+5UXuSqWNn1db5KoxLDNPKKSxtKLXmB5nsbIM+T63WltLFYOS2J",
+	"ZQG5qHiZVokLXP13PSWrEBtBRZIaA1GJHz8Qq5WQlrioEKYu+Y7i2LqlebVmj5eRVPPUKMSlMGJVArb4",
+	"llqsuEFlpTNdhS4OPZB2a7D5kwOabxtZaCjs1lefMoq1txW0/LThEyuwVwCSPcZ2337PHmDgiBGX8NCt",
+	"oldBF0+//R7LItEfj9NCHovdzQndAqVuEPppPsbIGRrDHZ9+1LQUpnKl0/J9ZjdR10P2Erb0R8L+vVRx",
+	"yTeQDses9sBEfZGa6MUarIssqIAbKltM2PT8YLmTT9mWm21aPyAwWK6qStjKBxIYVTl+6krM0KRhOKoG",
+	"RxK+hSt8xCidmqXtep/XxkTVWlJYYyzVT7yC/rIuGTfMNA7mzl7mBeIJ81WWCqZkuYssmrg2bi5UUJyy",
+	"iXbnNau1kBZvzI1dZ/+H5Vuuee7E38kUuNnqL38ag/w3LEXFQObKzS+PA/yzr7sGA/oyvfR6gu2DquX7",
+	"sgdSyaxyEqV46KV8f1dOBg6lo9KDRB8mJcwPfai+5UbJJtmt6bEbjyT1nRhPzgx4R1Zs8TmKH4/G7LNz",
+	"ZqPT7MEbR6Gf3772WkalNPQNv6uQKNLTVzRYLeASA+TTRHJj3pEWujyICneB/su6/YPKGallYS+nLgKU",
+	"7DleDvdzjPbUFVupiwuAWsjN6cr1IVWdRh0q6RuQYISZPkA3W8c57rM78iKLCA7NVlAquTGfn9MD4BN+",
+	"5Q2gTHr1Yh/Uo4FDscgMm04vjGvnpngTikvS0K79lziR2sjqvWnEb33b6UBod4xRKs1zn/hCUT99Dyzh",
+	"e8XRTg6yILUOxd+WCzkRHQ1QTES+Ac54prQVFHsC8AXi2KyowFhe1eljFg3HtBNxVztA2y7uNmIgV7Iw",
+	"zAiZA4Name2+fN2JPLNriZOVwtCRE5d9zJWm+nuoU1g1yKU8NNNjNmu0D2OmlbJTgKLyEaf7KmUZb+wW",
+	"pG0jqQErIQ8xoVwQvHHQgUIii/3oZHyoXMjLcrdkwn5D42gfPshZBfqiBGY1ALvaKgOsBH4JXVFyHO0b",
+	"w95di8JgyfESrkWuNprXW5EzpQvQJ+yl9y7jLYg6+fkenzCfBecjwd9dS0SvUEBXpBhPQjME9Le+jBjj",
+	"JR2gw5+xVrSB8hLMCXt3pQgI02UOG6eE9HqsGksZNIVYrwH3KaKDlyfs132IYMLy6hhs3Q7rcfoCu+1a",
+	"ZqgfT1wiLVkqruVzasR82knfQTTYGhXdWANDlVBsQC/JkIrLLiroMsWd7qa07Qw2a6BsDCfZhLRaFU0O",
+	"lJ981uPHCCwxAqmtSBx5+JGHQnX7Ds5gbAky1V3IUcF9TGqWVH0MkXZwCZqi5buBHpDQieAylmsMjcBI",
+	"CY8qFA/TwrmpN5oXcJhfE4Xgz9SjzasNI1yq4wb4xbUfqk093aR34qdP6Sj23J0ysSxPybJJ1evtVJrS",
+	"SyoLr6GkTBGsKI5tlyPFag2QGSHT1s81AMp2nudQO3aO3/MBcIKKlFgUFZjYGs5WR2FpxSVQDsuMMpDl",
+	"vMybkuJBZ076q5yXuu9GKWFtlWOw+JmHziQo3FwrjEelUtw0n3YCMOqBFT0uQe98C7o9hcrXbnPoge9/",
+	"nCuWlXAJ6TsNcEoZ+7u6YhWXu5YWbooOjGWUWNJCTroKOpaJ2j/7i10EPm0mz3XzQDpSTCxuEdO5Bi1U",
+	"IXIm5G/gd3MrlgLHUAl9Ja2QDb48oKGDm84Jhtlvwwy3MQfoqRx+96EfTC7hqkftItLn+qHXxvILILBD",
+	"np4/Gg+lqQYjimbClKl53ofsOGb0m/ctt3CqW9Kae+LLgYRqN/ncphvy8oBtBtQar9KknOoJ30OEFW8z",
+	"VZgX1IloVF8cJLScuPsoq4LFKSTHt2Nfgjb9OMfIBgjXe8Z2LXrjU8kUrci+cPwsWQhjMZPz7UgcdzwX",
+	"lC/KbsX+4OMoEis4UU+mBcBcCZtvs4nUDteWWlBqzOCmNZ6SVAjchbBeQ24PgQFzBOgliUko6LOD4gXw",
+	"AhMuu3QPSvQYgvLgJ8Xc0CbSa6QRqIV2ag2O8vCIeqAth+xj/l/Ugbx/qfB/6CI9YBsERcbTPm32pDae",
+	"ebrsXs52YHBV2qjVaI/UyvAy7eEJkxZQ8t3clNigP2mr2AYnF5053J1h7kChKNl0+HE0td9nc5O7JkOE",
+	"2+053hVxpfohJX+45OVEFspbqDUYpzAyzt798Oy19+VN5aLkk6lT3PqcZcvZZJmBmyVeeNIigsLF8Lt/",
+	"/yppx5wKEaMIMfd51Pt2oQVT5biiBQ0Rh2OA/hEC4lnNhXdUd4k445X1yVnjdLlDguo7Ag+R8ClPOEgK",
+	"k7hI2zgagm3xM5VvYeEpgjHwk7XsilXWxnum3iJZLnwturgA194gb2GySmw0Cp30qNM19CJrXCJpjg67",
+	"xKtYXrBMn4aDde8hPoC4A6+7SoWZUzQalcZNEMqIqi7JyeqHGiVvH5VY1sWCffrQwvuOy/rkkVVwawff",
+	"/QdU3RaW/enp82FU/5TPVVWXMH0e1OQep8fh6OTEghzRM2DB1KLyvNGdDW4YKPULLwW9T2OwKIdUqsYq",
+	"HLUV0v0Hc7RUY+n/wLX7D5WI6v+PuCqq1eGGWiBdMC0+DBRCsBfuyC7owuD7pmp53DLP8yDj8fisSUjE",
+	"2eDv3hmPlCnJ5N0FtLtdiV82+CWOm2cECAZrmPCXYQVY0JXTXbfqilVNvsVQcb6BEDmOEShoOB1M1Bs9",
+	"BNP1MyC889HUPKeBKECp5HoDmvmYIeYrY7eBRxUXg4e/hmEBeJXlqfN3Xzz7+ME71JaiqPZE2HwA4wJ2",
+	"p6QM4O+3EBzTwfETgGGI/CcE6U6R9nGyxh5+vejpUVTvrZff0oJ/j/qUg8/vtSP1qXEayqHoIR64HRoD",
+	"YzwPdzbFa5sQFR1uh14Gxos7rcPb1SE6fLpwk+uOlwhaECymxhBU9uu3vzINa//e6KNHOMGjR0vf9Ncn",
+	"/c+O8R49St/APtf1gdbIj+HnTXJMv6Lw8DVWFGgGK9P451JzVVVKoqGpLAdePlkwjHsy+H6qZCAvoVQ1",
+	"JFvTAkdEx/wWDZum5OTdElKC7nU6JHDZiI2Ewl5Liog4wz/fXctU2/iox9bRcqQqzkYPwdyuFPOgtCCF",
+	"jdPL47cdsQvx7kYMj97ffsSXFIfajohDrUHfZcx3fowDqnxupKZ8PgrEFiEsCZU0ovDgicQQqhSqf4aA",
+	"69aDC/9ueOk91BL9we8w6Di/AEmFPds3361iIE2jvUPYwYrjOVD8MCo+4E3X5LYlPrO5snkajeWtHd6H",
+	"oWEAPXV1qkfhiKPmi1K59kJusplcmxyTbXzDkEyJFq7ZCo5ucMeEuoLiwCT62B+GCWWh/8TwXbWo7jWm",
+	"dKpV9ESrHJecYA9evXjIsJ7MVGWP6MXN/WjHBasOg4hiG0ewDFPrjoFiDTDlhBzEbbA1TNiz95VFWl92",
+	"FZGw1dBwvBfKAwPR/s4Nljjyzb3D/CuNPusB6Z/bHA8VpwIfXTZnudho1aSDlTaUnj4Io8SLASpdFEJj",
+	"tvzP3z45ffLnv7BCbMDYE/YvzBWiw3dcDLFPTSa6Iou9Wq4MAWvzT0kf8nES0ZxbT9BRPIzw8RI4zOen",
+	"8G2qNSwXqJdk9joV0/VqpLOw2geXYOpkJG96xvr7iOQS0mpOwjdT63Uynfif+HtnStJBJmsYU/0AqUwP",
+	"2t5SK/gHvYZ7s1zsqU9WXralyW4neEqYqpRbXie2z3dPsm4HnbDXrjcDuVba3bSrxjodAB/wD7bOnpaK",
+	"uTa2qxqOaTbyd9AKDQmSKZnD6AwU0WJjbAjPUZ83PsDJwdDmDbdR6A/OUJtZEpAP6Z463mqskVaQ+uOW",
+	"8ZdoFWt38Dig/7UVZYILauW+mxiOJZOK0XsYcUuK5OtyxghmH6fdY6TPu83j2glF2k7mOKGgOjRdyaHO",
+	"SpFvuewK/O8vUDPmyWMe7u3L/uE2v89COjNwftlKOlJNBLVIXy7QXVAwe6u1qH1egGu+q0DaW0q+N9Sb",
+	"4mWwwLWevwHoiRtA6L2vXPjU2/9ubPexzR5ur1poOyVpG+G4nLj3tJEB4WmETnelHeRUhHWDMZdRmGqw",
+	"nforXWuDv4Ad08E0EFdm7R6+P/KWRceiFanspneigu5eQopcSgUSBx2JdL1M32sp4J5E9jcz6LTDzHOF",
+	"meAK6jvPEy0VjmDbs7ZP/zH8sSVtV0M/fKBXDb0fL4t3/BP2oo1jRl8LRfR1wc1kfxp6ZCgbuE3OFjrY",
+	"qbgONmd02pyfv68pmiKxcX0D0mVcm7FW45vwfL1p31RJGG5Cs+s16K5dyngSWq71713Dsd0mNBs/x9OT",
+	"PJ1Lqea7RVDLFsuFA9j94wBy/6717wt8gaYcu5LSe8iTOcMJErFxi/7FsafLtZuh45Y9RsjZcp8+4ged",
+	"NtHBdqyFMLZrU4GD7ofnvCzfXUuaKRGA0r3En3I5UgVdn8vRCkknSb3XMRiO/AaNHSQ8z52WVXSxohGc",
+	"3xg2rNNEEaTjSk29Q/xIIZl4MallN643k3ijzWisCYqccb1pKrLpf3r89mAwWZ1UFD6NbFxi02tNtNMb",
+	"DQVT2ieQiLXPDpqqEXNg3Tx6aeq12oi808668NUJTl+6+wfUvlqDklneOsTdUeUueVaxc3Ikny9O2CsK",
+	"NtfAC5KZWlhIVXDr4Y+Zr1eAlekDR2ctdaP6nCduF/Uq5BnkbA34oFSiZuN/ak1AXptmgmJTUokUmz6R",
+	"vgCFnruZulrsRKScS6nsfxCdjqwJOHhSLwr/qOu2OGAJMrzsSKovDjthJlUaxEbOPYO15uEgMENyJY+D",
+	"vpTySW4x4c3olGg14tsJUXR+0GD02g0vMiXLXUq6xgmNA/HarsXsW1htiqPpQoaMxzKqpnMYikHMvIkw",
+	"RMbGW/Ob+8XvFiUc71y3cTBAT2rs69uLi5p5sZ/yq/pD79PMIkfjrGZGpV1KhzjJJw1ZOD+DxJIFVX1p",
+	"ujCrc/mM/Q5a+ftiO5TbEJ152qf++6zck0SntkSTGXUbTnlkCSxCfkY7nCwtd37+/pqPtAyE6Q76xe2q",
+	"BO6l8cuJEkQxjYO3ytccumNtMZpxZmGnXno9P3+/5kUxqMYSh16RkGmridBq+1pMyCz8aqLs0Sw117PU",
+	"nBm/l7pxFS58M69xhQsiJclchRWnHqlw1OnQyq5G3XjqQzZ/678/iDXCpfeuzBFmnWGPmcqRvMI72bO2",
+	"KLAHTrXwnTAvQryvO/yugymlXAdpFtxjwYE7eA6NnvhnFa/vtS7lXuERQTzt9odJp3+XEBUe6vLjRbUe",
+	"cIAuumD46NrdXncMo6cpiF+HaTA8LgTTPfSqocIcru6KmSCOLyDXqoVdZT8KpMC4hzg03EQzxGvN2Cs3",
+	"Mi+v+M4EU2nHWNPDhVWlijEJM12c5En23fTa6BwdY28hF7XAt2v7UrDl8WkD48TbwWSodEKHss/EZWu0",
+	"8LHhvCvJ2Hd+Bd+XLy7HowN66ZeZl31rAQ0cjMGuzfMwdsCoJWl0nu1PhEgV6GyXdI/M897JWWHnLYXH",
+	"yjjqRUKOppmWbnL4kNCEW0S6Ro5oP3J90TsDuem/20lJEL1ReypGlLpwi6fNvDPhTfd2E4Zit6b9X0CT",
+	"A/Mtl4Wq2MtGEhc8+OXty4f+Pf/AZKHsgWM+D8lX+upZrdce87PBW2chEp18GhthrE7YLb/el9DW45fQ",
+	"Eu+BOezu6w20i+ILvYFWjt5Auz2mh79+FnbM1NtnXyUD7blJBAfnvPT0vphjxafvRvLTz3Q79ZC0wy55",
+	"ISog4OgZ6l0NDv47KVm9t465ZVdO+zDx46eJoM6uerBsYzMjP8LeoM/+eBNPnXg9CyfBooeJJ3KNf3o5",
+	"nC3RI/v0UhVVPS4j5WfdyMIMlrB7fWPGAzqr+3jVJ7SZdaZOKQWHagJnsau0Dwm6In0qSPvE8/CBHaxE",
+	"SzVn8ZlteuF5WEaqW8paq0tRpN69KNVG5IYsMMf6bF+HvjfLRdWUVtxynB9DX3Iip49DsfFHoSy4LhgU",
+	"T/7852+/79D9ysTVeJGSATYeLW9k5FbkfT22xe4AIRZIebJRY5E16WvTm8710PrWllg7u4tfO85FhoCk",
+	"8Y2QDSEaqx3jEasrp7aXVnQ/Ld1vW262neiM6p9jXXrOvLwaxt1h1s+XeWAp2hTZnUIjBttjSnB0m+Rr",
+	"2BuD98dEfrBI/DGSJOPy4B5FMrs6fgmpkLjWdQlOt+tk4Hjf5HpXW3UaSENHfpjzTIyfEYnHS686NsB6",
+	"p8ppIlQgwSmTncaFBoIOqlvE547W5yyGK1WGcavBOIjS8TRbfX7+Ia1sTlUNcNplutPNkbQ9G6xpf8Vp",
+	"3SY13PqCgPjMd7Z5Hvj8II3X/AZDtteojeVKWp6j3kgFuBfPvMFs4es9L7bW1ubp6enV1dVJsKad5Ko6",
+	"3WDaSWZVk29Pw0D0ElKcCO67+EqJTgqXOytyw569eYU6k7AlYAR7AddotWs5a/Hk5DHVDwDJa7F4uvju",
+	"5PHJt7RiW2SCU6rVQdWGEQ/HIqgYvSowT/gC4mofWF8d63lg9yePH4dl8LeGyFl1+psh/j7MfxZPg4vc",
+	"X4gH6F15GL3vMGaRn+WFVFeS/aC1ov1imqrieodpqrbR0rAnjx8zsfY1StCvaLk7td8vKEVy8cH1O718",
+	"chpFDQ1+Of0YHPaiuNnz+RQf14/ciXvbB5/sbKtEWtXhfQ6aYVAEN7RNzxf9evqx77C8ObDZqQ+QDm2H",
+	"QOLfpx+DRfBm5tOpz/Gf6z6BHxUXO/1Icad0w4ymSnfqKYgf7bWHDg1x2m3HxdP3HwfyAK55VZeAomBx",
+	"86Flw1aSeHa8Wba/lEpdNHX8iwGu8+3i5sPN/wQAAP//Pao01mC7AAA=",
 }
 
 // GetSwagger returns the Swagger specification corresponding to the generated code
diff --git a/api/generated/common/types.go b/api/generated/common/types.go
index fa13b5bff..7216e86ac 100644
--- a/api/generated/common/types.go
+++ b/api/generated/common/types.go
@@ -84,6 +84,18 @@ type Account struct {
 	// *  Online  - indicates that the associated account used as part of the delegation pool.
 	// *   NotParticipating - indicates that the associated account is neither a delegator nor a delegate.
 	Status string `json:"status"`
+
+	// The count of all applications that have been opted in, equivalent to the count of application local data (AppLocalState objects) stored in this account.
+	TotalAppsOptedIn uint64 `json:"total-apps-opted-in"`
+
+	// The count of all assets that have been opted in, equivalent to the count of AssetHolding objects held by this account.
+	TotalAssetsOptedIn uint64 `json:"total-assets-opted-in"`
+
+	// The count of all apps (AppParams objects) created by this account.
+	TotalCreatedApps uint64 `json:"total-created-apps"`
+
+	// The count of all assets (AssetParams objects) created by this account.
+	TotalCreatedAssets uint64 `json:"total-created-assets"`
 }
 
 // AccountParticipation defines model for AccountParticipation.
@@ -235,9 +247,6 @@ type AssetHolding struct {
 	// Asset ID of the holding.
 	AssetId uint64 `json:"asset-id"`
 
-	// Address that created this asset. This is the address where the parameters for this asset can be found, and also the address where unwanted asset units can be sent in the worst case.
-	Creator string `json:"creator"`
-
 	// Whether or not the asset holding is currently deleted from its account.
 	Deleted *bool `json:"deleted,omitempty"`
 
@@ -847,6 +856,9 @@ type CurrencyGreaterThan uint64
 // CurrencyLessThan defines model for currency-less-than.
 type CurrencyLessThan uint64
 
+// Exclude defines model for exclude.
+type Exclude []string
+
 // ExcludeCloseTo defines model for exclude-close-to.
 type ExcludeCloseTo bool
 
@@ -913,6 +925,17 @@ type AccountsResponse struct {
 	NextToken *string `json:"next-token,omitempty"`
 }
 
+// ApplicationLocalStatesResponse defines model for ApplicationLocalStatesResponse.
+type ApplicationLocalStatesResponse struct {
+	AppsLocalStates []ApplicationLocalState `json:"apps-local-states"`
+
+	// Round at which the results were computed.
+	CurrentRound uint64 `json:"current-round"`
+
+	// Used for pagination, when making another request provide this token with the next parameter.
+	NextToken *string `json:"next-token,omitempty"`
+}
+
 // ApplicationLogsResponse defines model for ApplicationLogsResponse.
 type ApplicationLogsResponse struct {
 
@@ -959,6 +982,17 @@ type AssetBalancesResponse struct {
 	NextToken *string `json:"next-token,omitempty"`
 }
 
+// AssetHoldingsResponse defines model for AssetHoldingsResponse.
+type AssetHoldingsResponse struct {
+	Assets []AssetHolding `json:"assets"`
+
+	// Round at which the results were computed.
+	CurrentRound uint64 `json:"current-round"`
+
+	// Used for pagination, when making another request provide this token with the next parameter.
+	NextToken *string `json:"next-token,omitempty"`
+}
+
 // AssetResponse defines model for AssetResponse.
 type AssetResponse struct {
 
diff --git a/api/generated/v2/routes.go b/api/generated/v2/routes.go
index b8fa5c63e..86e16bfb0 100644
--- a/api/generated/v2/routes.go
+++ b/api/generated/v2/routes.go
@@ -24,6 +24,18 @@ type ServerInterface interface {
 	// (GET /v2/accounts/{account-id})
 	LookupAccountByID(ctx echo.Context, accountId string, params LookupAccountByIDParams) error
 
+	// (GET /v2/accounts/{account-id}/apps-local-state)
+	LookupAccountAppLocalStates(ctx echo.Context, accountId string, params LookupAccountAppLocalStatesParams) error
+
+	// (GET /v2/accounts/{account-id}/assets)
+	LookupAccountAssets(ctx echo.Context, accountId string, params LookupAccountAssetsParams) error
+
+	// (GET /v2/accounts/{account-id}/created-applications)
+	LookupAccountCreatedApplications(ctx echo.Context, accountId string, params LookupAccountCreatedApplicationsParams) error
+
+	// (GET /v2/accounts/{account-id}/created-assets)
+	LookupAccountCreatedAssets(ctx echo.Context, accountId string, params LookupAccountCreatedAssetsParams) error
+
 	// (GET /v2/accounts/{account-id}/transactions)
 	LookupAccountTransactions(ctx echo.Context, accountId string, params LookupAccountTransactionsParams) error
 
@@ -73,6 +85,7 @@ func (w *ServerInterfaceWrapper) SearchForAccounts(ctx echo.Context) error {
 		"next":                  true,
 		"currency-greater-than": true,
 		"include-all":           true,
+		"exclude":               true,
 		"currency-less-than":    true,
 		"auth-addr":             true,
 		"round":                 true,
@@ -140,6 +153,16 @@ func (w *ServerInterfaceWrapper) SearchForAccounts(ctx echo.Context) error {
 		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err))
 	}
 
+	// ------------- Optional query parameter "exclude" -------------
+	if paramValue := ctx.QueryParam("exclude"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", false, false, "exclude", ctx.QueryParams(), &params.Exclude)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter exclude: %s", err))
+	}
+
 	// ------------- Optional query parameter "currency-less-than" -------------
 	if paramValue := ctx.QueryParam("currency-less-than"); paramValue != "" {
 
@@ -192,6 +215,7 @@ func (w *ServerInterfaceWrapper) LookupAccountByID(ctx echo.Context) error {
 		"pretty":      true,
 		"round":       true,
 		"include-all": true,
+		"exclude":     true,
 	}
 
 	// Check for unknown query parameters.
@@ -232,11 +256,317 @@ func (w *ServerInterfaceWrapper) LookupAccountByID(ctx echo.Context) error {
 		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err))
 	}
 
+	// ------------- Optional query parameter "exclude" -------------
+	if paramValue := ctx.QueryParam("exclude"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", false, false, "exclude", ctx.QueryParams(), &params.Exclude)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter exclude: %s", err))
+	}
+
 	// Invoke the callback with all the unmarshalled arguments
 	err = w.Handler.LookupAccountByID(ctx, accountId, params)
 	return err
 }
 
+// LookupAccountAppLocalStates converts echo context to params.
+func (w *ServerInterfaceWrapper) LookupAccountAppLocalStates(ctx echo.Context) error {
+
+	validQueryParams := map[string]bool{
+		"pretty":         true,
+		"application-id": true,
+		"include-all":    true,
+		"limit":          true,
+		"next":           true,
+	}
+
+	// Check for unknown query parameters.
+	for name, _ := range ctx.QueryParams() {
+		if _, ok := validQueryParams[name]; !ok {
+			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Unknown parameter detected: %s", name))
+		}
+	}
+
+	var err error
+	// ------------- Path parameter "account-id" -------------
+	var accountId string
+
+	err = runtime.BindStyledParameter("simple", false, "account-id", ctx.Param("account-id"), &accountId)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err))
+	}
+
+	// Parameter object where we will unmarshal all parameters from the context
+	var params LookupAccountAppLocalStatesParams
+	// ------------- Optional query parameter "application-id" -------------
+	if paramValue := ctx.QueryParam("application-id"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), &params.ApplicationId)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err))
+	}
+
+	// ------------- Optional query parameter "include-all" -------------
+	if paramValue := ctx.QueryParam("include-all"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), &params.IncludeAll)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err))
+	}
+
+	// ------------- Optional query parameter "limit" -------------
+	if paramValue := ctx.QueryParam("limit"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), &params.Limit)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err))
+	}
+
+	// ------------- Optional query parameter "next" -------------
+	if paramValue := ctx.QueryParam("next"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), &params.Next)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err))
+	}
+
+	// Invoke the callback with all the unmarshalled arguments
+	err = w.Handler.LookupAccountAppLocalStates(ctx, accountId, params)
+	return err
+}
+
+// LookupAccountAssets converts echo context to params.
+func (w *ServerInterfaceWrapper) LookupAccountAssets(ctx echo.Context) error {
+
+	validQueryParams := map[string]bool{
+		"pretty":      true,
+		"asset-id":    true,
+		"include-all": true,
+		"limit":       true,
+		"next":        true,
+	}
+
+	// Check for unknown query parameters.
+	for name, _ := range ctx.QueryParams() {
+		if _, ok := validQueryParams[name]; !ok {
+			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Unknown parameter detected: %s", name))
+		}
+	}
+
+	var err error
+	// ------------- Path parameter "account-id" -------------
+	var accountId string
+
+	err = runtime.BindStyledParameter("simple", false, "account-id", ctx.Param("account-id"), &accountId)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err))
+	}
+
+	// Parameter object where we will unmarshal all parameters from the context
+	var params LookupAccountAssetsParams
+	// ------------- Optional query parameter "asset-id" -------------
+	if paramValue := ctx.QueryParam("asset-id"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), &params.AssetId)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err))
+	}
+
+	// ------------- Optional query parameter "include-all" -------------
+	if paramValue := ctx.QueryParam("include-all"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), &params.IncludeAll)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err))
+	}
+
+	// ------------- Optional query parameter "limit" -------------
+	if paramValue := ctx.QueryParam("limit"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), &params.Limit)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err))
+	}
+
+	// ------------- Optional query parameter "next" -------------
+	if paramValue := ctx.QueryParam("next"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), &params.Next)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err))
+	}
+
+	// Invoke the callback with all the unmarshalled arguments
+	err = w.Handler.LookupAccountAssets(ctx, accountId, params)
+	return err
+}
+
+// LookupAccountCreatedApplications converts echo context to params.
+func (w *ServerInterfaceWrapper) LookupAccountCreatedApplications(ctx echo.Context) error {
+
+	validQueryParams := map[string]bool{
+		"pretty":         true,
+		"application-id": true,
+		"include-all":    true,
+		"limit":          true,
+		"next":           true,
+	}
+
+	// Check for unknown query parameters.
+	for name, _ := range ctx.QueryParams() {
+		if _, ok := validQueryParams[name]; !ok {
+			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Unknown parameter detected: %s", name))
+		}
+	}
+
+	var err error
+	// ------------- Path parameter "account-id" -------------
+	var accountId string
+
+	err = runtime.BindStyledParameter("simple", false, "account-id", ctx.Param("account-id"), &accountId)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err))
+	}
+
+	// Parameter object where we will unmarshal all parameters from the context
+	var params LookupAccountCreatedApplicationsParams
+	// ------------- Optional query parameter "application-id" -------------
+	if paramValue := ctx.QueryParam("application-id"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "application-id", ctx.QueryParams(), &params.ApplicationId)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err))
+	}
+
+	// ------------- Optional query parameter "include-all" -------------
+	if paramValue := ctx.QueryParam("include-all"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), &params.IncludeAll)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err))
+	}
+
+	// ------------- Optional query parameter "limit" -------------
+	if paramValue := ctx.QueryParam("limit"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), &params.Limit)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err))
+	}
+
+	// ------------- Optional query parameter "next" -------------
+	if paramValue := ctx.QueryParam("next"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), &params.Next)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err))
+	}
+
+	// Invoke the callback with all the unmarshalled arguments
+	err = w.Handler.LookupAccountCreatedApplications(ctx, accountId, params)
+	return err
+}
+
+// LookupAccountCreatedAssets converts echo context to params.
+func (w *ServerInterfaceWrapper) LookupAccountCreatedAssets(ctx echo.Context) error {
+
+	validQueryParams := map[string]bool{
+		"pretty":      true,
+		"asset-id":    true,
+		"include-all": true,
+		"limit":       true,
+		"next":        true,
+	}
+
+	// Check for unknown query parameters.
+	for name, _ := range ctx.QueryParams() {
+		if _, ok := validQueryParams[name]; !ok {
+			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Unknown parameter detected: %s", name))
+		}
+	}
+
+	var err error
+	// ------------- Path parameter "account-id" -------------
+	var accountId string
+
+	err = runtime.BindStyledParameter("simple", false, "account-id", ctx.Param("account-id"), &accountId)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter account-id: %s", err))
+	}
+
+	// Parameter object where we will unmarshal all parameters from the context
+	var params LookupAccountCreatedAssetsParams
+	// ------------- Optional query parameter "asset-id" -------------
+	if paramValue := ctx.QueryParam("asset-id"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "asset-id", ctx.QueryParams(), &params.AssetId)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter asset-id: %s", err))
+	}
+
+	// ------------- Optional query parameter "include-all" -------------
+	if paramValue := ctx.QueryParam("include-all"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "include-all", ctx.QueryParams(), &params.IncludeAll)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter include-all: %s", err))
+	}
+
+	// ------------- Optional query parameter "limit" -------------
+	if paramValue := ctx.QueryParam("limit"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "limit", ctx.QueryParams(), &params.Limit)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter limit: %s", err))
+	}
+
+	// ------------- Optional query parameter "next" -------------
+	if paramValue := ctx.QueryParam("next"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "next", ctx.QueryParams(), &params.Next)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err))
+	}
+
+	// Invoke the callback with all the unmarshalled arguments
+	err = w.Handler.LookupAccountCreatedAssets(ctx, accountId, params)
+	return err
+}
+
 // LookupAccountTransactions converts echo context to params.
 func (w *ServerInterfaceWrapper) LookupAccountTransactions(ctx echo.Context) error {
 
@@ -438,6 +768,7 @@ func (w *ServerInterfaceWrapper) SearchForApplications(ctx echo.Context) error {
 	validQueryParams := map[string]bool{
 		"pretty":         true,
 		"application-id": true,
+		"creator":        true,
 		"include-all":    true,
 		"limit":          true,
 		"next":           true,
@@ -464,6 +795,16 @@ func (w *ServerInterfaceWrapper) SearchForApplications(ctx echo.Context) error {
 		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter application-id: %s", err))
 	}
 
+	// ------------- Optional query parameter "creator" -------------
+	if paramValue := ctx.QueryParam("creator"); paramValue != "" {
+
+	}
+
+	err = runtime.BindQueryParameter("form", true, false, "creator", ctx.QueryParams(), &params.Creator)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter creator: %s", err))
+	}
+
 	// ------------- Optional query parameter "include-all" -------------
 	if paramValue := ctx.QueryParam("include-all"); paramValue != "" {
 
@@ -785,7 +1126,6 @@ func (w *ServerInterfaceWrapper) LookupAssetBalances(ctx echo.Context) error {
 		"include-all":           true,
 		"limit":                 true,
 		"next":                  true,
-		"round":                 true,
 		"currency-greater-than": true,
 		"currency-less-than":    true,
 	}
@@ -838,16 +1178,6 @@ func (w *ServerInterfaceWrapper) LookupAssetBalances(ctx echo.Context) error {
 		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter next: %s", err))
 	}
 
-	// ------------- Optional query parameter "round" -------------
-	if paramValue := ctx.QueryParam("round"); paramValue != "" {
-
-	}
-
-	err = runtime.BindQueryParameter("form", true, false, "round", ctx.QueryParams(), &params.Round)
-	if err != nil {
-		return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter round: %s", err))
-	}
-
 	// ------------- Optional query parameter "currency-greater-than" -------------
 	if paramValue := ctx.QueryParam("currency-greater-than"); paramValue != "" {
 
@@ -1397,6 +1727,10 @@ func RegisterHandlers(router interface {
 
 	router.GET("/v2/accounts", wrapper.SearchForAccounts, m...)
 	router.GET("/v2/accounts/:account-id", wrapper.LookupAccountByID, m...)
+	router.GET("/v2/accounts/:account-id/apps-local-state", wrapper.LookupAccountAppLocalStates, m...)
+	router.GET("/v2/accounts/:account-id/assets", wrapper.LookupAccountAssets, m...)
+	router.GET("/v2/accounts/:account-id/created-applications", wrapper.LookupAccountCreatedApplications, m...)
+	router.GET("/v2/accounts/:account-id/created-assets", wrapper.LookupAccountCreatedAssets, m...)
 	router.GET("/v2/accounts/:account-id/transactions", wrapper.LookupAccountTransactions, m...)
 	router.GET("/v2/applications", wrapper.SearchForApplications, m...)
 	router.GET("/v2/applications/:application-id", wrapper.LookupApplicationByID, m...)
@@ -1414,181 +1748,191 @@ func RegisterHandlers(router interface {
 // Base64 encoded, gzipped, json marshaled Swagger object
 var swaggerSpec = []string{
 
-	"H4sIAAAAAAAC/+x9f2/cNrboVyHmXWCTvpGdJt3Fa4DFRTbZYINNdoM47QIv7kM5EmeGtUSqJGV7mpfv",
-	"fsFzSIqSqBmNPXaSdv5KPOKPQ/Lw8Pw+H2e5rGopmDB69vTjrKaKVswwBX/RPJeNMBkv7F8F07niteFS",
-	"zJ76b0QbxcVqNp9x+2tNzXo2nwlasbaN7T+fKfZrwxUrZk+Nath8pvM1q6gd2Gxq29qN9OnTfEaLQjGt",
-	"h7P+W5QbwkVeNgUjRlGhaW4/aXLFzZqYNdfEdSZcECkYkUti1p3GZMlZWegTD/SvDVObCGo3+TiI89l1",
-	"RsuVVFQU2VKqiprZ09kz1+/Tzs9uhkzJkg3X+FxWCy6YXxELCwqHQ4wkBVtCozU1xEJn1+kbGkk0oypf",
-	"k6VUO5aJQMRrZaKpZk8/zDQTBVNwcjnjl/DfpWLsN5YZqlbMzH6ap85uaZjKDK8SS3vlTk4x3ZRGE2gL",
-	"a1zxSyaI7XVC3jTakAUjVJB3L5+TJ0+efE9wGw0rHMKNrqqdPV5TOIWCGuY/TznUdy+fw/xnboFTW9G6",
-	"LnlO7bqT1+dZ+528ejG2mO4gCYTkwrAVU7jxWrP0XX1mv2yZxnfcNUFj1plFm/GDdTdek1yKJV81ihUW",
-	"GxvN8G7qmomCixW5YJvRIwzT3N0NXLClVGwilmLjg6JpPP9nxdO8UYqJfJOtFKNwddZUDLfkndsKvZZN",
-	"WZA1vYR10wreANeX2L54zpe0bOwW8VzJZ+VKakLdDhZsSZvSED8xaURpaZYdzeEh4ZrUSl7yghVzS8av",
-	"1jxfk5xqHALakStelnb7G82KsW1Or24HmodOFq4b7Qcs6MvdjHZdO3aCXcNFyPJSapYZueOt8s8PFQWJ",
-	"X5f24dL7vVzk/ZoRmNx+wFcb9k5YhC7LDTFwrgWhmlDi36k54UuykQ25gsMp+QX0d6uxu1YRu2lwOJ1H",
-	"1XImY9s32IzE5i2kLBkVsHmOS8loWW6hl2VJuGGVdkyNJY0wQRFI6ZwUrGSwyPY5gF+1UXIDi9fMtpO1",
-	"YUUmG+OQYi1LO6Cew4ngsPg5enxKmdNSG2rYKEMUr2THoktecTNc7ht6zaumIqKpFkzZA/e01UiimGmU",
-	"gMNWjORwZgvgerjtTktS0xXThFnSy5Gbg3ns1RDSEMVovh7He4RpB6pX9DpTshHFBKbFEKniR0HXLOdL",
-	"zgoSRhmDpZ1mFzxc7AdPy0pF4PhBRsEJs+wAR7DrxLHa62m/wAFFp3pCfnDUCb4aecFEIGJksYFPtWKX",
-	"XDY6dBqBEabeLi4IaVhWK7bk10Mgz9x2WAqBbRwJrdz7nUthKBessNQVgJaGIbUZhSmacF8mZUE1+8t3",
-	"Yy90+1WxC7ZJEt0+AuByglS0tl+w7/ZVhBl2XOqJeLiUffzbinuT8A4aZUg2Eq+w/eqISloC7fSfIIPG",
-	"c6P8k91KFsUx/PM2thW9me6O7dV8leGIg1vCV+/tW7zkJbzTv9jL4U+20fZd6p6tf7k1XwlqGsWenotv",
-	"7F8kI2eGioKqwv5S4U9vmtLwM76yP5X402u54vkZX41tioc1KZtCtwr/seOlZVFzHZabmsJ/Ts1QU9vw",
-	"gm0Us3PQfAn/XC8BkehS/TZDKW9s5pQg9lrKi6aOdzLvKCYWG/LqxRiWwJDbCCEQDV1LoRmg6zPkIN65",
-	"3+xPltYxAaQ8YgJOf9ESmNx27FrJminDWawIsv/9L8WWs6ez/3XaKo5OsZs+dRO2coUZe8Pw5lLjaBfS",
-	"LEfNkAuo6sbgm54iC+Eefwiw9edsj0UufmG5wQ3qgvGAVbXZPLQAO9j14XYL/g/M3R775kCmStHNHe8j",
-	"vuoZvM7DkX+wPKgl6TVdcQELn5OrNROkoheWHFAhzZopYs+CaePfd6R7+OQHDZZjEhynfTJL3ZjEmepb",
-	"H2p7aq/l6iBnu0Ovc37+gdY1L67Pz3/q8NlcFOw6fQx3esalXGUFNXQ6Mnb27IXtmsDLLxd1+jqzQyHQ",
-	"YZFnj1O4X3J6qO068GXTN8HfI0FN3IrbE1WtmfkbLanI2SFOeeGGmnzCb7jgAMQ/UMFxPGZ/zGErD3HE",
-	"h7jAdpydFxYa3S/PCFMeYpP0oXZpDwLn9+uI8+Esb43xfytlfnGjs9x2VDDqjpn/rpRUB8Aiz+T1Vj2f",
-	"VUxrumJp1Vm8k77hlK3zAMOxM7sEUDD8g9HSrJ+v2R1sZjT2ji1934rUB9jYO71WkfS/a/3RqnZwbd1h",
-	"97wJ0TT6S9+9L4codbZ8Oi3vnGmfok8/Y73fIX/yWqRYTZRwG3AuPlygLtGKsdQQ6qzgqN09F+fiBVty",
-	"Acaap+fC0qHTBdU816eNZspxiicrSZ4SN6SVKs/FbN5/CMdUrWDodNDUzaLkOblgm9QpoAU2LZeXK2ml",
-	"ciMNLSNTVGSXdQaAVqU0RDmcILOYIRuTOX+GTLErqooE6DqYH2BkNBBvm3VO3NhoJXH+Em789DWgda0z",
-	"MORlYMkbU0uUPaWERusfsUdGtJHK20C49tDA+f5LGmdXoFcE8Ys0mmnyc0XrD1yYn0h23jx69ISRZ3X9",
-	"2o55ZuH42dkE7H3a1GhZ3VsF4QdLcTywcDjPjF0bRTOwFCaXbxit4fTXjOimAqNzWRLo1lHU1EquFK2c",
-	"0TEswO/H+AEgHNPesmiFsLgz7OW9eNJLgE9whNCGrFnprGm3OK9Ijrrxce2Qxbb4DZ2ffwCXIH8ywYVg",
-	"RbnQ/lXQfCXsJXDeFgtGcssFsOKEvFoSoGrzTnfn8+coZiAdXKODBHlv1wi2MZJTAY4TdQGOBFwQKjZ9",
-	"pbxmxngTyDt2wTbvI9PaniYaZ4enO57EorHDhWexPWFyRTWpJJhnciZMuXGm/QRqpoFpuDBoY8zRfSKz",
-	"+DtGNODWRB4c9uLEJMSN0UfEyKGB1jVZlXLhKE1A0acBR32fcaLy1gKgD0BQkoKT34Ytd6+mKrEReBFH",
-	"tuAGC7Xj3eoabl3ejVFuyZUGtxFG3RtB4ytyA8xzPi1DUP6zZsCVSQW+HV2U0v5Kp5A+mKzns5oqw3Ne",
-	"T1O14uhvO33sILue9uRjLpf9N3vwpCafEGycLahOP9/MfrEY2Gj0d7Jr9ITOz4TcMqzghIB92l3VRQku",
-	"UME9E8+YKvDN8stGd8Ux0NL3ginR8lQejO6OxMzbmmrvpgXebJ5ETGJzRpD3vd0AQGB7byLsjflWbuct",
-	"2SUd2/9x0/grUVjawXTXZS0Yvv2z0r/+8+Bhgm7o3kDureLeFG7/tdjelCXhS9KICyGvLHO8j7F7PrOc",
-	"X5M+JCmA87N3boXbgY09+jiA/6SjY7NQ/Xu5LLlgJCM87IGBPUDHQ5lz9L5r76ebg1nB4BticdAOMHmE",
-	"FHJHYNdSljgw+ZeMb6xY7QOkYBxoDPVjA7GJ/mYT1E7BWcOJHDtFgyFFaa/WvHWHwWMcynPBRP22T9yS",
-	"UlunFcEmCyeFRI9YCnEtwcqt2C90A86nRuayPBmIa5qVDOh/1qG3mRXNkpweAzQ8890iUY484EvLeD2M",
-	"CLxiK64NU06MBwiDR1HrMLUxzEJGjWHKTvT/Hvz30w/Psv9Ls98eZd//79OfPn736eE3gx8ff/rrX/9/",
-	"96cnn/768L//azZyt1hWKymX46sztVra9b2TMuAudCTQsbPMe1/BpTQsg2c8u6TliOXaNnqpQcR4CS9+",
-	"kqx2DpugfzMfUdDAtBdskxW8bNL46ub95ws77b+CVK6bxQXbwOPJaL4mC2ryNbyuneltmy1Tl3Tngl/j",
-	"gl/Tg6132m2wTe3EyqJLd46v5F70KOI2cpBAwBRyDE9tdEu3EEiQqF+wEvXh43E3eDkL2/Bkmy5qcJkK",
-	"P/Y2tjKCYvztwJGSa+n6CoyvAhxLwMObm8idXQ9WNFUMAB0pvgfRNFbqdCPcObsfry5m+d0oaZ7ffbzF",
-	"8obDT13eoTyB4PT2kWZRLB4gGFwcN9gO5IoUbEOnUCMV80pCvC0RQ4UxHyJe2/AatVEH0w7GsyAuCEI2",
-	"4SntTXNnCMiG4RFu7SlcJEslK7h5Q+kuQk4+Ird0ULB9cnqzuijOIb5Y4gnRRTvtDIyW/2SbH21bOFXb",
-	"G+NFuJh6ZVoxDnoSLow8wNHcTmOawnw34k7MR++2MbSHeD9UW3UsIHvegFKu0lJZuQK+Q65a1/kYHRbM",
-	"SjXsmuWNaaMmelqXoBi6X26yr2FKeztHxi0MPt3OP8BGubF2HN3bQCfv8uRoXSt5ScvMmQTGaLySl47G",
-	"Q3NvQbhndix9zd7//dnrtw58UD4zqrIgzoyuCtrVX82qLF8i1QiJ9aGFa2qCprb//juTANcdM8IVRKT1",
-	"JGbLaTnkQgLdmoii2+vMCkvPl+9pJHDWLFziFqsWq4NRq9VGok2ra8eil5SXXg3ooU0/Kri41pK497sS",
-	"D3Bre1hk1swO+lIMbnf6duygRPEMW0LPKgyA1ES6ELMg54JwCzpFQNCKbizeoDF2SJJEU2X20mW65Hla",
-	"USwW2qKEQBunbUyg8YiYbEe0b3F6rIZHY9lmeoJ3XQ/IaI7kZnofwbG9W0jnhNEI/mvDCC+YMPaTgrvY",
-	"u572Nvrw6RuLQAlLCIZZ36MQBBPuI/64cOBbLS6MchMhyMo1w0ndqbn1hLO7jfxjhxqTfACI7cJPbK4e",
-	"gPsiaEo9FgU7OxUdy94eXi/xjAMuY4vHirt8jlQ0gjur/w1OZ3d2EC9oubDxkViVsaf22fgza8ff44Ft",
-	"31MALH5JMZKdllomhmnEFRXGx8O73XK9NUO1tu11JZU2kEAh6ce1l6QYx9nfSj7U2VLJ31haPwpq5avh",
-	"9NHE2Ds9+GQ5r0cZRuS9cDLjiLILGUOmgtuCFPQDtwaqzx0Eo06bHMfjfnxcowRmTESJPpKub9jIIwa0",
-	"JvJAAGHc28eoQOLyHNLtdKTDNImKnQZPcfyWRDmYhzocerWg+UVaUrAwPWv9bjqWPCOJ7xyyUXTP64RE",
-	"LjyhrUvsUDNVcdN98tqLelOu/2sjRzmvaJlm/wvY/fcdhrLgK46JNRrNorQQbiBSSy4MYlHBdV3SDXo2",
-	"tVvzakkezSP65k6j4Jdc80XJoMW32GJBNTBmrZrOd7HLY8KsNTR/PKH5uhGFYoVZu4wlWpIgmYGWKxjU",
-	"F8xcMSbII2j37ffkAbgSaH7JHtpddOz27Om330MqDfzjUepBcyl4tpHfAuivJ/9pPAZfChzDsgpu1DQ9",
-	"xiRq45R+y23CrlPuErR0j8Puu1RRQVcs7aBX7YAJ+8JpgsWuty+iwKQ/wFgSbtLzM0MtfcrWVK/TvBCC",
-	"QXJZVdxU9gIZSbSsLD61aQlwUj8cZhBCWh/g8h/Bb6MmaR3m/erTMMI/tWrwrvkXrVh3W+eEaqIbC3Or",
-	"G3QE8YS4zBwFkaLcRNpb2Bs7F7AqlrEGHfuS1IoLA9qBxiyz/0PyNVU0t+TvZAzcbPGX74Yg/w3SlxAm",
-	"cmnnF/sBfu/7rphm6jK99WoE7T3T5fqSB0KKrLIUpXjoqHz3ViYVqNLQMu2n7Cl63019+9BTOS87SjaK",
-	"bk0H3WhEqW+FeGLLgLdExbCevfBx75XdO2Y2Ko0etLEn9MO7147LqKRiXSX3wocOdPgVxYzi7BJcptOH",
-	"ZMe85VmoctIp3Ab6z+vi0EoAgS3zdzklCGD433A77M/xssfUCVJeXDBWc7E6Xdg+yKrjqH0mfcUE01yP",
-	"P6CrtcUc+9k+eZH2B4YmC1ZKsdL3j+ke8BEb+ooBTXr1YhfUg4F9grEMmo5vjG1np3jrE5Lh0Lb953iR",
-	"gq/tzsDSd67tuGusfcYwuOK5C4VAD6eutRnXe0XBJsBEgWwdkL815WLEX5axYsTLj8GMZ1IZjn42jH0G",
-	"nz3DK6YNrer0MwtKcryJcKstoKGLlUY0y6UoNNFc5IywWur1rgjOkcijawGTlVzjkxOnCsulwpxNwFMY",
-	"2Yuum+r7vzWOsAtjpqQ0Y4AC8xEHgEppCG3MmgkTfGsZZM/srwSjA0DiwAcFSRZ5Y2m8z3ZFy3IzJ9z8",
-	"CcdRzlWSkoqpi5IRoxgjV2upGSkZvWRtqlQY7U+avL/mhYZEqCW75rlcKVqveU6kKpg6IS+dJR2kIOzk",
-	"5nt0QlxclPMNfn8tYHmFZCgixevEZXoX72C3iVc8xwe0/zPkF9WsvGT6hLy/kgiEbmNJtWVCOj0WjcGY",
-	"ioIvlwzuKSwHhCfo136IYIKkr5B6Ngzr1vQZbtu1yIA/HhEiDWoqrsVzbERcIELXGNa7GhVKrB6hSlas",
-	"mJqjShW2nVesjR22vJtUplXYLBn651vKxoVRsmhyhhGrZx18jMDiA5BCFsvImwFwyOfcbeH0yhZPU61A",
-	"DgzuI2SzhOyuEM6OXTJFFoyJaKAHSHQiuLShCtxAwCvELZUVD9PEualXihZsmg0XiOAP2CNEWvoRLuV+",
-	"A/xo2/fZpg5v0nnx06905A1vX5mYlqdo2Sjr9W4scOUlphJWrMTYAchCC23nA8ZqyVimuUhrP5eMAW2n",
-	"ec5qi85xlQHGLKFCJhZIBYQ6+rfVnrAw/JJhVMMWZiDLaZk3Jfq+bnnpr3Jaqq7JqGRLIy2CxcmnW5Ug",
-	"t3MtwPcW07fifMoSwKgH5Hi4ZGrjWqD05LOl2suhen4Ow+ihrGSXLC3TMIpBRP+QV6SiYhPOwk7RgjHH",
-	"+wJXJUCOvAoY0fG0f3CCXQQ+XiaHdduBtEcxsrlFfM41U1wWPCdc/MLcbQ5kyWMMpl2WwnDRQLZqxVq4",
-	"8Z0gEA/Vj3kaYoAai+q2H7qO84JddU67iPi5rpu5NvSCIdg+css9jVPPVDHNi2ZElalo3oVsP2R0l/cd",
-	"NexUhaPVB8LLHoUKl3zbpevjcg9teqc13KVROtUhvlOIFQ1ROcQR6oTnrUsX4VuOyD7SSK9x8uHSYexL",
-	"pnTXpzPSAbLrHWPbFp3xMYmGkqhf2H+WzLvs6NH5NkiOW5zzzBfGO0J/5nxGEjs4kmEkAKCvuMnX2UgY",
-	"i22LLTAMqCdpDadEFgJuIVsuWW6mwADxEJh9fBQK/GyheMFoASF4bWgLBrX0QXnwL0ns0Dria4TmwIW2",
-	"bA2M8nCPNIIBQ3Yh/49yIu5fSvgfmEgnXAPPyLizT6s9sY1Dnjbek5IN07ArwUM3uiO11LRMW3j8pAUr",
-	"6WbblNCgO2lgbL2RC98cat8w+6CgR3Da1Tqa2t2zbZPbJv0Fh+s5vBVxduP+Sf79kpYjETfvWK2Ytgwj",
-	"oeT935+9dra8sbibfDRMjBoXxWooGQ08/zQHgSdNItA1Dr67qhxJPeaYOxx6w9nPg943czIYS9AUbaj3",
-	"rhwC9E/v/E9qyp2hug06Gu6sC0QbhgZOCSBoD7i/CBfeBYOkVhKn7Rp6Q5A1fMaEHsSnrx4CP5rdrFhk",
-	"wbc1lb9+PnPZyeKUTDsd2rnOKr5SQHTSo45nVYu0cYkAQXzsEpVUHGEZfw17+95ZeA/iFrxWlPIzp85o",
-	"kFEzcVCaV3WJRlY3lH1f415kryC61u/t7t0oD+2hdec+VuzGBr7Du1bdFJbdAfPb3aj+LZ7Lqi7Z+HtQ",
-	"o3kcCwrhywkpGqLSMV7VIvO8Ua0Oru8o9SMtOdY00JCmQUhZQ16G2nBh/wPxaLIx+H9Glf0PJg3q/g+x",
-	"KsreYIeawblwMXPpf2RjvLv5zD7ZBQoMrm8qu8MNY1onKY+Hb02CIm51dO+88XAyJaq8W+d9eyvhywq+",
-	"xDECBAEBZw3t/9KkYIapyvKua3lFqiZfg1s8XTHvJQ8eKKA47U3UGd0703WjPZzxUdc0x4HQQamkasUU",
-	"cT5DxCXUDY5HFeW9YjF9twAQZWnq/d3luz8skgTcUuTBnwgR8GBcsM0pMgPw+w0Ix3ggwAhgEA5whyDd",
-	"KqogDkzZga8XHT4KM4B1YnkC+Afkpyx87q7tyU8NQ26mLg/WAdeh0Wy4zunGpnhvE6SiXdtUYWC4ueM8",
-	"vFlM4eHTqXxsdxAicEMgvRYBUMnP3/5MFFu6GnXffAMTfPPN3DX9+XH3s0W8b75JS2D3JT7gHrkx3LxJ",
-	"jOnmmO1X8AOCpiEboiuxl8uqkgIUTWXZs/KJgoDfk4aae4IwcclKWbNka9zg6NAhlkexVVNStG5xIZjq",
-	"dJriuKz5SrDCXAv0iDiDP99fi1Tb+KmH1tF2pHKQRvUjbpact5dsDh3IsR7qTUdsXbzbEX0p3puP+BL9",
-	"UMOIMNSSqduM+d6NMSHv40oojF1ER2zu3ZKAScMT7pXV8q5KPh+kd7gOFlz2a0NLZ6EWYA9+D07H+QUT",
-	"mOoxVKI1kjChG+UMwhZWGM+C4oaR8QOv2yY3TfqYbUukpkBZHvTwzg0NHOixq2U9Cns4cnsiOduei1W2",
-	"Ja4oh8Ai19AHjoKGa2tOPzu4RUJVsWJiwoDYHgbBc77/lugizEfZFnFJh5VFZf3EML0GefDqxUMCuXPG",
-	"sphEVdp2LztOEDkNIvRtHMDSDyPcB4olY2NGyJ7fBlmyEX32rhRQy8s2+xO06iuOd0I50RHtH1RDOifX",
-	"3BnMv1Dvsw6QrkTbcKg47HnvFEHz2UrJJu2stMJQ/J4bJQgGwHShC41e0z9/+/j08Z//Qgq+YtqckP9A",
-	"rBA+vsP0eN3TJLxNu9fJ7kkAsBBri/yQ85OI5ly7Ax34w3DnLwHD3P8J3yQzxXwGfElmrlM+Xa8GPAup",
-	"nXMJhIlG9KajrD+EJxcXRlEkvplcLpOh0/+G31tVkvI0WbHhqU+gylgE8YZcwT+xguKn+WxHLrbyMqRh",
-	"uxnhKdlY7tTyOnF9njzO2ht0Ql7b3oSJpVRW0q4aY3kAKPrsdZ0dLhVibUybRxrCbMRvTElQJAgiRc4G",
-	"byCPNht8Q2gO/Lx2Dk4WhhAjHbzQH5wBNzNHIB+inDq8aqQRhiP7Y7fxx2gXa/vwWKD/s+ZlAgtqab/r",
-	"GI45EZJghYS4JXrytTFjCLPz0+4g0v1e8zhPRJHWk1lMKDDnTpteqdVS5Gsq2pTvu5PxDHFyn2KPXdrf",
-	"v+aHTBq0Bc7PmzVIyBGnFuFSI1oBBaK3gkbtfgGu6aZiwtyQ8r3F3ugvg5Xpt0sAakQC8L13JZAeqxdt",
-	"x7YfQ/RwELVAd4rUNlrjfETuCZ4BPll+y7viDbIswrIBn8vITdXrTp1IF3TwF2xDlFcNxFlo22LJe0pZ",
-	"+Cwanopues8r1solyMilWCA+6UlE8TIt16LDPZLsP21ZTltieitW6BGs8KWlt+FEOIU90PYs9OkWUB5q",
-	"0jY167oPdPJjd/1lQcY/IS+CHzPYWtCjr3VuRv1T3yKD0cAhOJsrr6eiyuucwWhzfv6hRm+KxMV1DZCX",
-	"sW2GXI1rQvPlKlTZSChufLPrJVNtu5TyxLdcqt/ahkO9jW82LNDSoTzzQ9SmTt8hd8wZTJDwjZt1BccO",
-	"LxcuQ4stO5SQW1ObOo8fMNpED9u+GsJYr40JDtofntOyfH8tcKaEA0pbvTllcsRswS6WIxBJS0md1dEr",
-	"jtwFjQ0kNM8tl1W0vqIRnH/SpJ+TCj1Ih1mpOo/4nkQyUUMnoBtVq9F1g85oyAnynFC1airU6d/9+nas",
-	"YDQTKy9cGNkwnajjmvCmN4oVRCoXQMKXLjpoLB/OxByBWHsIKt633FnrvjqC6XMrf7DaZWuQIsuDQdw+",
-	"VVbIM5KcoyH5fHZCXqGzuWK0QJqpuGGpbHWd9UPk6xUrS1DpI0Zn4XSjXKQn9hZ1sgFqwGzFoMRQIj/l",
-	"15r/kNa6GTmxMaqEjE33kD7DCT23M7V55/GQciqENF/ROe2Z/7BXZC1y/6jrkAixZMLX+kPWF4YdUZNK",
-	"xfhKbCuMtKT+IdD940o+B10q5YLc4oPXg1cicMQ3I6Jg/MDBsP4JLTIpyk2KusYBjT3yGvZia3WkEOKo",
-	"W5ch7VYZZdOZtkRPZt5GKwTEBqn57WHXd4N0lbfOUdkboEM1dvXt+EXtLH/fHXoXZxYZGrdyZpjapbQL",
-	"R/qkWObfT0+xRIFZX5rWzepcPCO/MSWdvBiGsheiVU+70H8XlXuS6BRSNOlBt/6Ue6bAwsVv4Q5H0+id",
-	"n3+4pgMuA2C6BX9xs4yIO8/45UgKoviMvbXK5Ry6ZW4xnHHLxo7V/jw//7CkRdHLxhK7XiGRCdlEcLdd",
-	"LiZAFno1kvZo62kut57mlvE7oRtXXuDbUp/JC4gYJHPldxx7pNxRx10r22x1w6mnXP5gv5+EGl7ovS1y",
-	"+Fm3oMeWLJm0ApnsWUiA7ICTAb4T4kiIs3X735VXpZRLT828ecwbcHsFsrDoO6lofdAcnDuJRwTxuNmf",
-	"jRr924Ao9zD78aJcDzBA613QL8N1u3p/fvT0CcLXfhgMjRPBtKU/FasghqsVMROH4xLIBbawzeyHjhTg",
-	"9xC7hutohnivCXllR6blFd1oryptEWt8OL+rmDEmoaaLgzxRv5veG5WDYewdy3nNoZpplwoGHB9XMI5U",
-	"k0VFpSU6GH3GL4PSwvmG0zYlY9f45W1fLrkcjR7oudtmWna1BTiwVwbbNs/92H5F4Uij92xCJbZEqs6w",
-	"pTtonrNObiV2TlO4L43DXkjkcJpx6ib6RZNGzCLCNrKH9oaqi84bSHW3kiMGQXRG7bAYUejCDcq4OWPC",
-	"27ZOFbhiB9X+j0yhAfMdFYWsyMtGIBY8+PHdy4euwrtHMp/2wCKfg+QLrfBWq6Vb+Vmvrpv3REebxopr",
-	"oxJ6yy+36ttyWPUtUfvMru5Q9d4uis9U760c1Hu7+UqnV3rzN2asztsXiUA7JAlv4NxOPZ0tZl/y6boh",
-	"/XQz3Yw9RO5wpN6/Cfmueg//rZisTvVbasiV5T60y1naMltdp842e7AIvpmRHWGn02d3vJGyLo7Pgkkg",
-	"6WGiaKp2xXj92xKVXceqXJj1uIyYn2UjCt3bwrbSyBYL6Fbex7E+vs1WY+oYUzCVEziLTaVdSMAU6UJB",
-	"QtHffjEhyESLOWeh8DLW/O2nkWq3slbykhepGh+lXPFcowZmX5vta9/303xWNaXhNxznje+LRuT0c8hX",
-	"7ikUBVUFYcXjP//52+/b5X5h5Gq4SUkHG7csp2SkhuddPjasbgIR80d5spJDkjVqa1Or1vQQbGtzyJ3d",
-	"+q/tZyIDQNLrjRbrXTQWG0IjVJeWbS8Nb3+a29/WVK9b0hnlP4e89JQ4etX3u4Oon89TTCq6FNmtXCN6",
-	"12OMcLSX5Eu4G71aazyfTBLfRJRkmB7cLRHVrhZffCgk7HVdMsvbtTRweG9ytamNPPVHg0++n/OMD0um",
-	"xOOldx0aQL5TaTkRTJBgmcmW4wIFQQvVDfxzB/tzFsOVSsO4VkxbiNL+NGt1fv5Tmtkcyxpguct0p097",
-	"nu1Zb0+7O477Nsrh1hcIxD3LbNtx4P5BGu75J3DZXgI3lkthaA58Iybgnj1zCrOZy/c8WxtT66enp1dX",
-	"Vydem3aSy+p0BWEnmZFNvj71A2HVpzgQ3HVxmRItFS43hueaPHv7CngmbkoGHuwFuwatXcCs2eOTR5g/",
-	"gAla89nT2ZOTRyff4o6tAQlOMVfH7OnHT/PZ6eXj09hVZpUs4sWoytcoCLi2JxALz1C6eVWERi+leuaH",
-	"c2YPLGP89MNYwSJ7Ze3fvzZMbWY+i36sBmqNccPrsTvKGdUUGl0wTaMwblwxknsmLrI0Y5k9dskE4cj2",
-	"lbzioXiGskKte7UTMEPbPQFuU2rRFYvgPSE/aBblrZQXEASC7KZ3KfdpF0OnEcDsECm4WpQfhvjirjlW",
-	"Fzz8qPCa9xWEPYHRRESuoyednHBOVeuKaLiUHfmGNKK0/IU3P4DVUIelQbpAzGaRU7cDLt7K+63q8RPw",
-	"k2QOwsxCuOeJuMzqIBvBY+I8bUHL5UQnh+PzkH4k9huYtwXYnKJ+TkJCj56Gee7s/r6+8rBsMXoVjC3Y",
-	"OQFntCxTy4xsTfudcOnK7nyhx2unuNXZeo+/yJzrau3AeiHHpz3wC7YZA6YNjB2/WTv9+LZ/HgPf0zRv",
-	"RW8rp2CqREigXDMFQ4ocFPkaMNNryZAue0eOgmu6KKGYAIrAHS+AUeQL+V33OIE4zck48e/7P2yZ4Sco",
-	"AAIJp+AJe/zokX+nnVorGu30F40MWDvguN/oPoEgKUbRZ8/bGmQbEh+jvQXP9Qrfp6puzLhN+tpk8CoM",
-	"R/5BOy+3mq64cJ4coCyq6AXohASGBDlHKn87fUy1fWqCFcA9Tg5jJuhs2ve/uwE/JfmqLuQPwKHioV3g",
-	"d7c6x9FMY+MZv3rr8A2ngP3OISA6g2Kmsk/z2Z+/9iVYpKYry73NNPB3s58+9bjG04/ek5EXn0ZZyNdS",
-	"XjR10EXGVTMGnCS2dffqbxsgEls5yaDh9DQXSIpleCOKEoCcxXtkVMP24oumUuADUszfJz9yJ2R7D2J9",
-	"h8Q5TRCP9HD23aPvjiT9yyHpJRDaHST9tF8ZZQp975s7txD4uE7JLkJ/FO4PI9xHOU7sLEt+7cic9+vJ",
-	"ZS8/noDsydwVrU5CAZZ0GGxveQhtImPiUPj6MTmxD1eLJz1AiF1q2/jq/aa2+1CCF/wvdrc8BjatpTew",
-	"Aj6IMqg4IcBR8xXJgsHN/lLhT6DEPeMr+1OJP4H5CJXnqbVrvhpfvIZuFf5jx5u0SHeTo4V0LWeLjcuc",
-	"kj6LtLT2RfJTfkpqiFRRCYN26oq7ogFj04cGBwEB8733YaDXO2DwDfYVxO9E/9pfWbQmrIhleMVOyBtH",
-	"aKgg714+J0+ePPneFXi1zCuiy9iCcUgMEI+BCwSjoCZ8nkJ+3r18DgCcBZvEpFY7DzVg1KFWDiN+eQv/",
-	"A+uK/5BK1M8pb+OqnZTpxDLMmLGdPQl5Ne5RKP2D6P+GxRNvnyJrpA6Jf+c6Ex71ir8rITRSXE2ySMft",
-	"x43S3VbbDdOHtlD8US2MR3H9RuL6gTWjvfs0zajVTX58NGz1grJvbdz6XVuGon06/dgllLstRN1M9knF",
-	"YdskbR1KsaN9cr2TJT0aZA5FdvYkNvdnmLmlOeZoy/hK2MgBETr1iTknUiJi208gR6/lSn8eknRktQ5j",
-	"GfnM2u8/qCoaQq2CTmeQjQs98lz8XBs6ljSIYCrONpXG3Tjm3dlbOZ75rubFdS+vJBYmGAklvEsWvZSr",
-	"zJP/feWJ13L1gqbTJX8NnD+S6ltwDtverJCaa6fSA1puc8LHoXZoOo56iOPjuMdr9RLs3mj29pnh/JVC",
-	"E1fIk7KdSrtmh57djj66Wtozmh1gvkZwMzaf/bbffAexxx74YQoEaRqVt82P+qLwangafHSD/h0ru+CQ",
-	"Tz/667lbweUyku12gLYNp0uTcdako2rrTlVb2tXrmUQL79HPGKY8kpujZu7L1sz1KeapK8+8UyOHrHcv",
-	"Zf/VWgJBiQvFb6WofrKjbHSUjQ4nG30GP9aj293v3e3uYHzeYRmgmF5PEgzfcMGB+P4D6d1RRgzFv9vX",
-	"6Cgl/pF4nn2iqjoWkThz91bR8RhYdQysOgZWHQOrjoFV92zNPoZAHUOgjrLY7zsEaorHik+kykWcRjgm",
-	"+a5Q6hiq37ETy2BRz2W14IK10oxfQZsvykh7UNAorhLrG0IVFu+lsGNdmZLlyPvqK5GGrM/zma+3SpXl",
-	"lKe8t53VeAAh53U0f1zUbK+1QcENUNgRH3qGuCzsPpflhhi4UgXU+gvJr+eWQd7IhlzBZSn5BfSHAvUY",
-	"z1ZhucFumi6oVdKMGrdd9yyUZ9mlA7x7A9IxXu8Yr3eM1/sDqDagBrs+/YhV21GBsNMIDp3GtBd/sx93",
-	"aSzwMuJ06QjkGKD71ZZuu0W4uGNowVeM8ZNUd5Gz5vZkSMFl86ivO+rrjvq6o77uqK87JkI6agGPWsCj",
-	"FvCoBTxqAY9awLvTAn5Ozd3XVhfgqBs86gaPmpI9g2M6VRQ/Wplod3gMseJjOShUn1IUxlg3JUbGCWXT",
-	"sxF+RSQk2q69Luv0y3mMJDmSly9FEQv17tWlv+vdsnvsmlZ1yaDiHqRqcP1Dwb5cVhU8VOEXN3L0iyNl",
-	"n3769D8BAAD//9X7UAtdHwEA",
+	"H4sIAAAAAAAC/+x9+2/cuNXov0LM/YAme0d29tHiboDiQ5ps0KBJG8TZLXDjXJQjcWa41pAqSdmezfX/",
+	"/oHnkBQlURqNPXaS7vyUeMTHIXl43ufw0yyXm0oKJoyePf00q6iiG2aYgr9onstamIwX9q+C6VzxynAp",
+	"Zk/9N6KN4mI1m8+4/bWiZj2bzwTdsKaN7T+fKfbvmitWzJ4aVbP5TOdrtqF2YLOtbGs30s3NfEaLQjGt",
+	"+7P+Q5RbwkVe1gUjRlGhaW4/aXLFzZqYNdfEdSZcECkYkUti1q3GZMlZWegTD/S/a6a2EdRu8mEQ57Pr",
+	"jJYrqagosqVUG2pmT2fPXL+bnZ/dDJmSJeuv8bncLLhgfkUsLCgcDjGSFGwJjdbUEAudXadvaCTRjKp8",
+	"TZZS7VgmAhGvlYl6M3v6YaaZKJiCk8sZv4T/LhVjv7HMULViZvZxnjq7pWEqM3yTWNord3KK6bo0mkBb",
+	"WOOKXzJBbK8T8qbWhiwYoYK8e/mcfP/99z8S3EbDCodwg6tqZo/XFE6hoIb5z1MO9d3L5zD/mVvg1Fa0",
+	"qkqeU7vu5PV51nwnr14MLaY9SAIhuTBsxRRuvNYsfVef2S8j0/iOuyaozTqzaDN8sO7Ga5JLseSrWrHC",
+	"YmOtGd5NXTFRcLEiF2w7eIRhmvu7gQu2lIpNxFJsfFA0jef/rHia10oxkW+zlWIUrs6aiv6WvHNbodey",
+	"LguyppewbroBHuD6EtsXz/mSlrXdIp4r+axcSU2o28GCLWldGuInJrUoLc2yozk8JFyTSslLXrBibsn4",
+	"1Zrna5JTjUNAO3LFy9Juf61ZMbTN6dXtQPPQycJ1q/2ABX25m9Gsa8dOsGu4CP3l/3TtrntRcPsTLQk3",
+	"bKOJrvM1odpBtZalvex6TiJKRkqZ05IU1FCijbQUYimVY91IPuaufyONkBwOsCCLbbelKFqj7+5j94dd",
+	"V6W0K1vSUrP0fvnVx5sEq4yZJC3LmSO9VmJwU2bhB1pVOoMVZ9pQw+I2VWVbCClYgpOGH6hSdGv/1mZr",
+	"xQWgEbPmdLK8lJplRu6QJLxwABsW8f54x/aSK8j7NSMwuf2AMhVgtrDkpiy3xLgDsAhBvBQxJ3xJtrIm",
+	"V3B1Sn4B/d1qLE5viD18OLKWyGPlxiHk7m1GArUXUpaMCkBtJ0Nm9vyGuVnp8RqbW8YFExSB0c1JwUoG",
+	"i2yQEH7VRsktLN6iwpzIyh66rE3/cojCDYufu3cFEGdQXI1XsmPRJd9w01/uG3rNN/WGiHqzYMoeuOd8",
+	"RhLFTK0EHLZiJIczW7RufkVXTBNmGSNHWRvmsYRLSEMUo/l6mCohTDsI0YZeZ0rWopggUhoiVcyydcVy",
+	"vuSsIGGUIViaaXbBw8V+8DSCbgSOH2QQnDDLDnAEu04cq72e9gscUHSqJ+Rnxzvgq5EXTAQWg8SSkUqx",
+	"Sy5rHToNwAhTjytzQhqWVYot+XUfyDO3HZZCYBvH4DZOusqlMJQLVljeB0BLw5DaDMIUTbivCLmgmv3p",
+	"hyH5qfmq2AXbJoluFwFwOUFnXdsv2Hd8FWGGHZd6Ih4ij43xbxT3JuEdNMqQbCRkJPvVEZW0faDVf4KF",
+	"IJ4btdPsTpYCHMOzt6Gt6Mx0f0qJ5qsMR+zdEr56b3nxkpfAp3+1l8OfbK0tX2qfrefcmq8ENbViT8/F",
+	"N/YvkpEzQ0VBVWF/2eBPb+rS8DO+sj+V+NNrueL5GV8NbYqHNWk5gG4b/MeOl7YUmOuw3NQU/nNqhora",
+	"hhdsq5idg+ZL+Od6CYhEl+o3lL3KoZlTavJrKS/qKt7JvGU2WmzJqxdDWAJDjhFCIBq6kkIzQNdnKEG8",
+	"c7/ZnyytYwJIeSQEnP6qJaggzdiVkhVThrPYTGf/+1+KLWdPZ//rtDHrnWI3feombLQ+M8TD8OZS42gX",
+	"0ixHzVAK2FS1QZ6eIgvhHn8IsHXnbI5FLn5lucENaoPxiG0qs31sAXaw68Ptlm6J8xP3rSuS3+M+IlfP",
+	"gDv3R/5ZO7WpoisuYOFzcrVmgmzohSUHVEizZorYs2DaeP6OdA9ZfrAvOiHBSdons9SNSZypvvOhNqf2",
+	"2sq5ZyDnHuKIO0rXHmedAul48uHkext7SBRYHejsRw2v5+cfaFXx4vr8/GNL1eKiYNfp87jXwy7lKiuo",
+	"obfD0dUL2zWBoF8yDrWN2odCoMMizx6n8LAc9VDbdeDLdisae6SsiVtxd6KqNTN/oSUV+UHY6cINNfmE",
+	"33DBAYi/oo3reMz+mMNWHuKI3e4e5CKjvXryFT4ebuoOBy/AnY/2UEc66SAfWCOEKQ+xSZ8L8Y8Yf1iM",
+	"/0sp84tbneXYUcGoO2b+SSmpDoBFXn7vrHo+2zCt6YqlDePxTvqGU7bOAwzHzuwSwHz4V0ZLs36+Zvew",
+	"mdHYO7b0fWMwO8DG3uu1imx7u9YfrWqHQN4eds+bEE2jv/Td+3KIUmvLp9Py1pl2Kfr0M9b7HfKNtxHH",
+	"RuBEyJYLr+QCPQVcCntS1EUgoe/mXJyLF2zJBbhin54LS4dOF1TzXJ/WmimnBJysJHlK3JAvqKHnYjbv",
+	"MsIhRwoEmThoqnpR8pxcsG3qFDD6JW1yKVfy/PwjMdLQMnI0RzExzr3XGIz7KIcTZBYzZG0yF0uWKXZF",
+	"VZEAXQfnIoyMwTljs86JGxt9oC5WzY2fvga9AI8Bi1PZsTfpRBwMF+1AFXu+f5fGeQ3pFUH8IrVmmvxr",
+	"Q6sPXJiPJDuvnzz5npFnVdUYLf/VRNVYoMFtcVALKCwczjNj10bRDOIAkss3jFZw+mtGdL2BkJKyJNCt",
+	"Hbyj5ErRjQsp6IYFjRwAwjGNl0UrhMWdYa+beSQM9k/QfoIjhDZkzcp+YNG+5xVpUbc+rh2a2EjM5vn5",
+	"BwjH9CcTAoRWlAvtuYLmK2EvgYt0WzCSWymAFSfk1ZIAVZu3urt4a0cxA+ngGoPTyHu7RvB8k5wKCFqr",
+	"CggT4oJQse263DQzxjs437ELtn0fOc73dMC6KBu6gyUWtR0usMXmhMkV1WQjwfmaM2HKrQvcSaBmGpia",
+	"C4MRBK0wsAGiAbcmis+yFycmIQMRblG4Eq0qsirlwlGagKJPA476PsNE5a0FQB+AoCQVp3bEXHojqEps",
+	"BF7EoSC//Rdqx7vTNRxd3q1RbsmVhqAwRh2PoPEVuQXmuYi1Pij/XDOQyqSCyK02Sml/pVNIHwJS5rOK",
+	"KsNzXk2zouPob1t97CC7WHuSmctll2f3WGqShWDjbEF1mn0z+8ViYK0xmtGu0RM6PxNKy7CCEwLRJ+6q",
+	"LkoIcAyh8XjGVEHkpV82hooPgZa+F0yJRqbyYLR3JBbe1lT7IEyIJPYkYpKYM4C87+0GAALbexNhbyy3",
+	"cjtvyS7p0P4PB768EoWlHUy3A1JDWItnK/24YB8/hilAPvzFx7z4QBf7r8X2uiwJX5JaXAh5ZYXjfUJZ",
+	"5jMr+dXpQ5ICJD9751a4HdjYo48D+A86OjYL1T+Wy5ILRjLCwx4Y2AMM+pY5x9ja5n66OZhVDL4hFgft",
+	"AJNHSCF3BHYlZYkDk7/L+MaK1T5ACsaBxlA/NhCb6G+W1vBAwANZDwNpuUhjY+7pgpUwW8wSAINI/QVj",
+	"AuNxCRdzYvW8S1paacVIFF7CIOm49UctUduJefrxkByftj7gioCL7bUm5Hu3WU0sLHqg05LsCMTjckvq",
+	"CDTsF0oRzV6NROfvnHpAVhjaq0ew8DsA0DV7hlBAp/LuVE37HK0h7fMm2BLJSBrbhzAmeS4DO9a3VITQ",
+	"qrddtp20R7RaEWyycPp1JJ6lSLK9FbkUmgldQ0qLkbksT3qGCM1KBpJN1pIksgu2TeswDAjsme8WGSnI",
+	"I760KsXjSHRRbMW1Ya20kxAJ2wT6biFVo6LGMGUn+n+P/vvph2fZ/6XZb0+yH//36cdPP9w8/qb343c3",
+	"f/7z/2//9P3Nnx//93/NBrgGyyol5XJ4daZSS7u+d1IGqgwdCXRsLfPBV3ApDctAQM0uaTkQbmMbvdSg",
+	"PL8EWTYpMLQOm2DWFB8wPcK0F2ybFbys0/jq5v3bCzvt34O9SdeLC7YFsZDRfE0W1ORrkBtb09s2I1OX",
+	"dOeCX+OCX9ODrXfabbBN7cTKokt7jq/kXnRo7Rg5SCBgCjn6pza4pSMEElj9C1aip2c4mxcvZ2EbnoxZ",
+	"WXuXqfBjjylMERTDXAlHSq6lHeA0vAqIhoPMJG6iNCzdW9FUBRes/8gPommuaNDg712RjVcXK7NulLQ2",
+	"6z7eYXn94acu71Dhi3B6+9hpUFLqIRhcHDfYDuSKTMf9ZAYrJHvzN96WSFXAXEURr61/jZpsuWkH40UQ",
+	"l7wn68BKO9PcGwKyhCqBa0/hIlkquYGb1xdKI+TkAxp5CwUbltOZ1dWG6OOLJZ6Qs7zTg8Zo+Te2/cW2",
+	"hVO1vb1gOvXKNAYKr8M4teVuR3M3X0AK892IOzEfQ3KH0B6qCKBBtuXb2/MGlHKVtjeUK5A75KpJ+YrR",
+	"YcGs7seuWV6bJtuvY08MJs+HlSa7ttN0lk7ktsWSFuPyA2yUG2vH0b0NdPI+T45WlZKXtMycs2uIxit5",
+	"6Wg8NPe+sQcWx9LX7P1Pz16/deCDW4VRlQV1ZnBV0K76alZl5RKpBkisT4lfUxMsCV3+75xdXLccZFeQ",
+	"Sd3RmK2k5ZALCXTj/Ixur3OYLb1cvqf7y/lpcYkj/lpWBXdtY2dHb23bQ0svKS+9gdtDm2YquLjGR743",
+	"X4kHuLOnN3LYZwflFL3bnb4dOyhRPMNIyvQGE/c1kS41Oui5oNyCtRwQdEO3Fm/QPNknSaLeZPbSZbrk",
+	"edoFIhbaooRA771tTKDxgJpsR7S8OD1WzaOxbDM9wejWATKaI7mZPvp1aO8W0oUX1YL/u2aEF0wY+0nB",
+	"XexcT3sbfVGWW6tACR8fFm95QCUIJtxH/XFlLO60uDDKbZQgq9f0J3Wn5tYTzu4u+k9jI+7LfwDEuPIT",
+	"B2L0wH0RLKUei4LdnYqWz3qPeK54xp6UMRKL5S6fIxW14M4LcIvT2V1zzCtartxJmlzspUfF1VPupD3p",
+	"bKnkbyxtPQSj61V/+mhi7J0efLIW1Lk3A9oQ75RUusVRhfozdwUpaM93BqrLO4MzpSlI1xzS4KUbEttj",
+	"p087EnCAsMP9i+JNQEH13lAq8MI9h8J2LY0pfW3jENFTHL+5tg7mvl2DXi1ofpGWni1Mz5ooq5bf1kji",
+	"O4fKQu1TOiFRwFZo64r0VExtuGmzgUYxu60kjNNOloEbkRewKhZ2XZ2vUsvEMLW4osL4UkuOoLnemqHn",
+	"yfa6kkobqJyWXGXBcr6hZVokLmD337eErIKvOBZJqjWLSvy4gUgluTCIRQXXVUm3GMfWbM2rJXkyj6ia",
+	"O42CX3LNFyWDFt9iiwXVIKw0pivfxS6PCbPW0Py7Cc3XtSgUK8zaVZ/SkgRtBSw/IXxiwcwVY4I8gXbf",
+	"/kgeQeCI5pfssd1FJ4LOnn77I5RFwj+epIk8FLsbI7oFUF1P9NN4DJEzOIZln27UNBXGcqXD9H3kNmHX",
+	"KXcJWjqWsPsubaigK5YOx9zsgAn7wmmCF6uzL6LAAm4gbBFu0vMzQy19ytZUr9PyAYJBcrnZcLNxgQRa",
+	"biw+NSVmcFI/HFaDQwof4PIfIUqnImm73sPamLBaS2rVEEv1d7ph7W2dE6qJri3Mjb3MEcQT4qosFUSK",
+	"chtZNGFv7FwgoFhhE+zOS1IpLgxozLVZZv+H5GuqaG7J38kQuNniTz/0Qf4LlKIiTOTSzi/2A/zB910x",
+	"zdRleuvVANp7Ucv1JY+EFNnGUpTisaPy7Vs5GDiUjkr3FL2blDA+9FR5y46SDaJb3UI3GlHqOyGeGBnw",
+	"jqgY1rMXPu69sgfHzFql0YPW9oR+fvfaSRkbqVjb8LvwiSIteUUxozi7hAD59CHZMe94FqqcdAp3gf7z",
+	"uv29yBmJZf4upxQBTPbsb4f9OV72kIot5cUFYxUXq9OF7YOiOo7aFdJXTDDN9TADXa0t5tjPluVFFhEY",
+	"mixYKcVKPzyme8AH/MorBjTp1YtdUPcG9sUiM2g6vDG2nZ3irS8uiUPb9p+DI4XI6p1pxO9c2+FAaMvG",
+	"MJXmuUt8waiftgcW13tFwU7ORIFiHZC/NeViIDqasWIg8o3BjGdSGY6xJ4x9hjg2wzdMG7qp0mwWDMd4",
+	"E+FWW0BDF6uNaJZLUWiiucgZYZXU6135ugN5ZtcCJiu5RpYTl33MpcL6eyBTGNnJpZya6TGaNdqGMVNS",
+	"miFAQfiI032lNITWZs2ECZHUDCohd1eCuSCgcSBDQZJF3lga7ysX0rLczgk3f8BxlAsfpGTD1EXJiFGM",
+	"kau11IyUjF6ypig5jPYHTd5f80JDyfGSXfNcrhSt1jwnUhVMnZCXzrsMWhB2cvM9OSEuC85Fgr+/FrC8",
+	"QjJUkeJ14jJ9QH/wZcQrniMD7f4MtaI1Ky+ZPiHvryQCoZvMYW2FkFaPRW0wg6bgyyWDewrLAeUJ+jUf",
+	"IpigvDoEW4dh3Zo+w227FhnIxwNKpEFLxbV4jo2ISztpO4g6V2ODGqtHqJIVK6bmaEiFbecb1mSKW9lN",
+	"KtMYbJYMszEsZePCKFnUOcP85LMWPkZg8R5IoSJx5OEHHPLV7Rs4vbHF01SrkIOA+wTFLCHbK4SzY5dM",
+	"YbR8M9AjJDoRXNpQBaERECnhlsqKx2niXFcrRQs2za8JRPBn7BHyav0Il3K/AX6x7btiU0s2aXH8NJeO",
+	"Ys8tl4lpeYqWDYpe74bSlF5iWXjFSswUgYri0HbeE6yWjGWai7T1c8kY0Haa56yy6By/58OYJVQoxAKp",
+	"gMRWz1vtCQvDLxnmsIwIA1lOy7wuMR50hNNf5bRUbTdKyZZGWgSLn3loTILczrWAeFQsxY3zKUsAox5Q",
+	"0eOSqa1rgdqTr3xtL4fq+P77uWJZyS5ZWqdhFFPG/iqvyIaKbTgLO0UDxjxKLAmQo6wCjmU87Z+dYheB",
+	"j5fJYd04kPYoBja3iM+5YorLgueEi1+Zu82BLHmMwRL6Uhguanh5QLEGbuQTBLLfuhlufQxQQzn89kM7",
+	"mFywq9ZpF5E81w691oZeMATb5+k51jj1TBXTvKgHTJmK5m3I9kNGd3nfUcNOVThafSC87FCocMnHLl0X",
+	"lzto0zmt/i4N0qkW8Z1CrGjIVCGOUCeiUV1xEN9yQPeRRnqLk0+OD2NfMqXbcY6RDZBd7xjbtmiNjyVT",
+	"lET7wv6zZD6MRQ/Ot0Vy3OCcF74wuxX6MxdHkdjBgXoyAQB9xU2+zgZSO2xbbIGpMR1Nqz8lihBwC9ly",
+	"yXIzBQbIEcCXJAahwM8WiheMFpBw2aR7YKJHF5RHf5fEDq0juUZoDlJoI9bAKI/3qAcaMGQX8v8iJ+L+",
+	"pYT/gYt0wjXwgow7+7TZE9s45GmyeynZMg27EqJWoztSSU3LtIfHT1qwkm7HpoQG7UmDYOudXMhzqOVh",
+	"lqFglGw6/Dia2t2zscltk+6Cw/Xs34q4Un33JH+6pOVAFso7VimmrcBIKHn/07PXzpc3lIuSD6ZOUeNy",
+	"lg0lg2UGbuag8KRJBIaLwXf3/lXSjjkUIoYRYvZzr/ftQguGynFFG+ojDvsA/c0HxJOKcueobhJx+jvr",
+	"krP66XJTguqbA+4uwqU8wSCplcRF2vrREGQNn7F8C/FPEfSBH6xlVyyyEO+ZeotkPnO16OICXDuDvLnO",
+	"NnylgOikRx2uoRdZ4xJJc8jsEq9iOcIyzA07+95aeAfiBrxGlfIzp86oVxo3cVCab6oSnaxuqF7y9l6J",
+	"ZU0s2P2HFh46LuveI6vYrR18hw+oui0su9PTx8Oo/iGey01VsmF+UKF7HB+HQ84JBTmiZ8C8qUXmea0a",
+	"G1w3UOoXWnJ8n0ZDUQ4hZQVVOCrDhf0P5GjJ2uD/GVX2P1giqv0/xKqoVocdagbnAmnxfiAfgj2zLLtA",
+	"hcH1TdXyuGWe5yTjcZ/XJCjiaPB3i8fDyZRo8m4C2u2thC8r+BLHzRMEBII1tP9Lk4IZpjZWdl3LK7Kp",
+	"8zWEitMV85HjEIEChtPORK3RfTBdOwPCOR91RXMcCAOUSqpWTBEXM0RcZewQeLShvPPwVzcsAFRZmuK/",
+	"u+LZ+w/egbQURbUnwuY9GBdse4rCAPx+C8IxHBw/ABiEyN8jSHeKtI+TNXbg60VLjsJ6b638lgD+AeUp",
+	"C5+7a3vKU/00lKnLg3XAdag1669zurMp3tsEqWjWNlUZ6G/usAxvFlNk+HThJtsdlAjcECimRgBU8q9v",
+	"/0UUW7r3Rr/5Bib45pu5a/qv79qfLeJ9801aA3so9QH3yI3h5k1iTLuicPc1ViBoGirTuOdSc7nZSAGG",
+	"prLsePlEQSDuScP7qYIwcclKWbFka9zg6NAhv0WxVV1S9G5xIZhqdZoSuKz5SrDCXAuMiDiDP99fi1Tb",
+	"mNVD62g7UhVno4dgbleKuVNaEMPG8eXx247YhHg3I/pH728/4kuMQw0jwlBLpu4y5ns3xoQqnyuhMJ8P",
+	"A7G5D0sCIQ1PuPNEog9V8tU/fcB18OCyf9e0dB5qAf7g9xB0nF8wgYU9w5vvRhImdK2cQ9jCCuNZUNww",
+	"Mmbwumly2xKf2VjZPAXG8mCHd2FoEECPXa3oUdjDkeNFqWx7LlbZSK5NDsk2rqFPpgQL12gFRzu4RUK1",
+	"YcXEJPrYHwYJZb7/wPBNtajmNaZ0qlX0RKvol5wgj169eEygnsxQZY/oxc3dy44LVk2DCGMbe7B0U+v2",
+	"gWLJ2JATshO3QZZswJ69qyzS8rKpiAStuobjnVBODET7K9VQ4sg1dw7zLzT6rAWke26zP1ScCrx32Zz5",
+	"bKVknQ5WWmF6eieMEhQDELowhEav6R+//e70uz/+iRR8xbQ5If+EXCFkvv1iiO3TJLwpstiq5UoAsJB/",
+	"ivKQi5OI5ly7A+3Fw3AXLwHDPPwJ36Zaw3wGcklmrlMxXa96MgupXHAJpE5G9KZlrD9EJBcXRlEkvplc",
+	"LpPpxP+A3xtTkvI0WbH+qU+gyvig7S2lgr/ha7g389mO+mTlZShNdjvCU7KhSrnldeL6fP9d1tygE/La",
+	"9iZMLKWymvamNlYGgAf8va2zJaVCro1pqoZDmo34jSkJhgRBpMhZjwfyaLMhNoTmIM9rF+BkYQh5wyEK",
+	"/dEZSDNzBPIx6qn9q0ZqYTiKP3Ybf4l2sbKMxwL9zzUvE1hQSftdx3DMiZAE38OIW2IkX5MzhjC7OO0W",
+	"Ij3sNY9rJxRpO5nFhALr0DQlhxorRb6moinwv7tATR8n93m4t037u9f8kIV0RuD8vJV0hBwIahGuXKBV",
+	"UCB7K1jUHhbgim43TJhbUr632BvjZaDAtRrXANSABuB77yoXPvT2vx3bfgzZw0HVAtspUttojfMBvSdE",
+	"BvinERrZFW+QFRGWNcRcRmGq3nbqVLpgg79gW6K8aSCuzNo8fL+nloVs0fBUdtN7vmGNXoKCXEoE4pNY",
+	"IqqXab0WA+6RZP9hZDlhmHGs0ANYgX3HcSKcwh5oexb6tB/D71vSthVrhw+0qqG342VBxz8hL0IcM/ha",
+	"MKKvCW5G+1PXI4PZwCE5mytvp6LK25zBaXN+/qHCaIrExXUNUJaxbfpSjWtC8+UqvKmSMNz4ZtdLppp2",
+	"KeOJb7lUvzUN+3Yb36z/HE+L8jQupYpuZ14sm81nFmD7jwXI/rtUv83gBZqy70pK3yF3zBlMkIiNm7UV",
+	"x5YsFy5Dgy07jJCj5T5dxA84bSLGtq+FMLZrY4GD5ofntCzfXwucKRGA0rzEn3I5YgVdl8sRiKSlpM7r",
+	"6A1H7oLGDhKa51bKKppY0QjOP2jSrdOEEaT9Sk0tJr4nkUy8mBTQjarV4LrBZtSXBHlOqFrVG7Tp3//6",
+	"dqxgsDopL1waWb/EppOa8KbXihVEKpdAwpcuO2ioRszEunn40tRrueJ5I5014asDmD63+gerXLUGKbI8",
+	"OMQtq7JKnpHkHB3J57MT8gqDzRWjBdJMxQ1LVXBrrR8yX68YVKb3GJ2F043qc57YW9SqkKcBsxWDB6US",
+	"NRu/1pqAtNL1wIkNUSUUbNqH9BlO6LmdqanFjoeUUyGk+YrOac+agJ0n9aLwj6oKxQFLJvzLjij6wrAD",
+	"ZlKpGF+JsWewltQzAt09riQ7aFMpl+QWH7zucYkgEd+OiILzAwfD125okUlRblPUNU5o7JDXsBejb2GF",
+	"FEfdhAxpt8qoms60JXoy8zZaISA2aM1vD7u+W5RwvHPdxs4ALaqxq28rLmrkxX7Mr2oPvUsyixyNo5IZ",
+	"lnYp7cKRPimWef7pKZYosOpL3YRZnYtn5DempNMXw1D2QjTmaZf677JyTxKdQokm3evWnXLPEli4+BHp",
+	"cLC03Pn5h2vakzIApjvIF7erErjzjF8OlCCKz9h7q1zNoTvWFsMZRzZ26KXX8/MPS1oUnWoscegVEplQ",
+	"TQR329ViAmShVwNlj0ZPczl6miPjt1I3rrzCN/Ial1cQMUnmyu849kiFow6HVjY16vpTT7n8wX8/CTW8",
+	"0ntX5PCzjqDHSOVIugGd7FkoCuyAkwG+E+JIiPN1+9+VN6WUS0/NvHvMO3A7z6HhE/9kQ6uD1qXcSTwi",
+	"iIfd/mzQ6d8kRPmHutx4Ua0HGKCJLug+una31x396OkThK/dNBgaF4JpHnpVbAM5XI2KmTgcV0AuiIVN",
+	"ZT8MpIC4hzg0XEczxHtNyCs7Mi2v6FZ7U2mDWMPD+V3FijEJM12c5In23fTeqBwcY+9YzisOb9e2qWDA",
+	"8WED48DbwWiotEQHs8/4ZTBauNhw2pRkbDu/vO/LFZejEYOeu22mZdtagAN7Y7Bt89yP7VcUjjTiZ7sT",
+	"IVIFOsOW7qB5zjs5SuycpXBfGoe9kMjhNMPUTXQfEhpwiwjbyB7aG6ouWjyQ6va7nZgE0Rq1JWJEqQu3",
+	"eNrMORPeNm83QSh2MO3/whQ6MN9RUcgNeVkLxIJHv7x7+di95++RzJc9sMjnIPlCXz2r1NKt/Kzz1pmP",
+	"REefxoproxJ2yy/3JbRl/yW0xHtgdnWHegPtovhMb6CVvTfQbr/S6a+f+Rsz9PbZF4lAOzQJ7+Acp57O",
+	"F7Mv+XTdkH66mW4nHqJ02CQvRAUE7Hn6elcdxn8nIav11jE15MpKHzp+/DQR1NlUDxYhNjPyI+wM+myP",
+	"N/DUiZOzYBIoeph4Ile7p5c9b4ke2ceXqrDqcRkJP8taFLqzhc3rGyMe0FHZx4k+vs2oM3VIKJgqCZzF",
+	"rtI2JOCKdKkg4Ynn7gM7UIkWa87CM9v4wnO3jFSzlZWSl7xIvXtRyhXPNVpg9vXZvvZ9b+azTV0afstx",
+	"3vi+6EROs0O+cqxQFFQVhBXf/fGP3/7YLPcLI1f9TUoG2LhlOSMjNTxvy7FhdROImD/Kk5Xsk6xBX5ta",
+	"Na6H4FubQ+3sJn5tPxcZAJJeb7RYH6Kx2BIaobq0YntpePPT3P62pnrdkM6o/jnUpafE0atu3B1k/Xye",
+	"B5aiS5HdKTSicz2GCEdzSb6Eu9F5f4znk0nim4iS9MuDuyWi2dXii0+FhL2uSmZlu4YG9u9NrraVkaf+",
+	"aJDl+znPeP8ZkXi89K5DA6h3Kq0kggUSrDDZSFxgIGigukV8bm9/zmK4UmUY14ppC1E6nmatzs8/poXN",
+	"oaoBVrpMd7rZ82zPOnva3nHct0EJt7pAIB5YZxvHgYcHqb/nNxCyvQRpLJfC0BzkRizAPXvmDGYzV+95",
+	"tjam0k9PT6+urk68Ne0kl5vTFaSdZEbW+frUD4QvIcWJ4K6Lq5RoqXC5NTzX5NnbVyAzcVMyiGAv2DVY",
+	"7QJmzb47eYL1A5igFZ89nX1/8uTkW9yxNSDBKdbqmD39dDOfnV5+dxqHyqySD1sxqvI1KgKu7QnkwjPU",
+	"bl4VodFLqZ754ZzbA5/2ffph6BEfe2Xt3/+umdrOfBX92AzUOOP612N3ljOaKTSGYJpaYd64gtf8UYiL",
+	"PM349By7ZIJwFPtKvuHh8QxllVrHtRMwQ9s9AW5KatEVi+A9IT9rFtWtlBeQBILipg8p92UXQ6cBwOwQ",
+	"KbgalO+n+OKuOVEXIvyo8Jb3FaQ9gdNERKGjJ62acM5U6x7RcCU78i2pRWnlC+9+AK+hDkuDcoFYzSKn",
+	"bgdcvpWPW9XDJ+AnyRyEmYVwzxNxldVBNwJm4iJtwcrlVCeH4/NQfiSOG5g3j5I5Q/2chIIeHQvz3Pn9",
+	"/ZvD/ad8MapgaMEuCDijZZlaZuRr6i7zp2u3zAb7cbW6ztcQodIFtPfIMLy/4coFNA/s4N7MXf8oasAn",
+	"y4VogdBStDZwQh+7Hey6KmXBZk+XtNQsvT0MF9namiAg+EBM3DsXGNFJE9QYg6mzKDpg1kpxtC2EFOmC",
+	"H13ZQZstkG7Lz2b73rrSPYX0hV45O8Wd7puPwoxc7O79I1gv1F21l/CCbYeAaZKVh6ndztjK8c9D4Hs+",
+	"4yMbmtdssHwlFLWumIIhRQ7OFQ3UwlsuEed9cE3BNV2U8MADmiVakRmDBCHU3N3jBOLSM8MMuRuTMjLD",
+	"R3iUBYqAwU377skTLzs5U2M02umvGoXiZsDhWN59knNSF9BXNBxNfA7FqNEHhud6hTLDpqrNcJzAtcmA",
+	"U/dH/lk7IlnRFRcuugYMeBt6AXY6gWlaLrjN306f527Zf/DMOIHBYcwEO1ojk7U34GNS1m1D/giCXB7b",
+	"Bf5wp3McrP42XIWtsw7fcArY7xwCYoAuVo+7mc/++LUvwSI1XVmJeqZB5p59vOlI8qeffHQpL24GxfrX",
+	"Ul7UVbAPxy+Z9KR7bOvu1V+2QCRGpftgdfY0F0iKVUIiihKAnMV7ZFTN9pJVp1LgA1LMo4x4lBEfRka8",
+	"F1a6BwO9R4aZZlJHHjX74ckPRzb75bDZEpjfDjZ72qMAu/iuiGLeunRUVkhuy63zv4c0ESxbMsKdn1UV",
+	"ZMZDcIv+kvj0wdWM3ytbPho5b2XkPDAr7dz3PdTTZpbmph6V1Sj5pbOxR4ngKBF8jRJBSLX7LHKAV02+",
+	"HP5/Lx6/I88/8vwH4/nhRk9j9PFjDEf+7vl7MKIcmfqRqX9tTD1R3HY/Fu+tlWlj5p1Y/nMc+lkM2lH/",
+	"P8oCR1ngfvT/FgHYV/U/CgSJahdHseAoFnzdYsH+On8QCDq+0IOIAkcjwJHxHxn/ZzcCHJn9Ufs/svmv",
+	"n83HeaFTA+u6uf8jXPt9PPwOpn3kBYfJdIke/LGzLPm1o7i+yE0uO49FCnhKnLNycHsElJWAwfYORMcE",
+	"4aE49PD1U3JiX7s5nvQA9aZT28ZX77eV3YcSgvB+tbvlMbBuyh6EGExfUTzk+0G1b81XJAvZ5/aXDf4E",
+	"GY1nfGV/KvEnyKXGTNLU2jVfDS9eQ7cN/mPHm7RId5OjhbTTyBdbJ4mnzyItxn6Rgax+SmqI1TSWmN0V",
+	"T73hIhudPjQ4CAgLtpQunSWCgV7vgME32DcD4l61Er+yaE0rbimv4Rt2Qt44QkMFeffyOfn+++9/JHjh",
+	"rZaC6DK0YBwSX0uIgQsEo6AmfJ5Cft69fA4AnIX41Emtdh5qwKhDrRxG/PIW/jtOnPxdZq99zkQHXLUz",
+	"JzgNEZ+PGRdPwiMzo9aHw2rNvxNtdz7rqgh3fy+uo/W0d7Iz4TGh6z9KCZ3iZI7LM7Q9KUMVGvbwD9+/",
+	"z/YlKBCoP7Sq74dLhxJDqMHaFA9LEnRsdjvB+2g+PpoMjn7j36Pf+D86LTjap9NPbWK9Oz04eoJryHjZ",
+	"NEmnBqdE4i7L2CkW/+68f/dGdvYkNg+XAXpHl9DRn/KViLI9InTqX8qdSImIbT+BHL2WK/15SNJR1DqM",
+	"d+YzW+B/p+ZwqH0c7Eq95/GwHJMraD2ujrm3cZu3be6nKtO98crhpygrXlx3HnolXBTseqC2932K6KVc",
+	"ZZ7875+CunpB0++Xfw2SP5LqO0gOYzxrPJgvNrxAy7GqmJMC8Y52iCNz3INbtUxn7qnGhzOa7Z7djj64",
+	"Wtpx3B1gvlpwMzSf/TZ7+EjVY+jhMfTwqGc+pLELDvn0k7+euw1c7onA3dXvbMPp2mT8jNnRtHWvpi0g",
+	"c1Np4QMWNIMpj+TmaJn7si1zXYp5uqAlFTnbaZFD0Vvja62+evPVWgJBcbUYgcCMUlQ/2VE3OupGxwcM",
+	"jnF4U+PwDiZ0HVYaiYnnJC3tDRf8WCkmxfUWDWs4qmy/JwFknzSrlnsiftd+VI87ZlodM62OmVbHTKtj",
+	"ptUDu5aPOVHHnKijLvafnRM1JXzEPzPMRfzIdkzyge8Pih/3HVHSW9RzuVlwwRptxq+gebnLSHtQ0Ahe",
+	"YXd82Dc0kugQMrBjXZmS5QB/hYia+E30+WypGPuNZYYqKylP4bet1XgA4Y2VaP74kZW91malYbSeEZ+L",
+	"hrgs7D6X5ZaYUPSI0PA0/NwKyFtZkyu4LCW/gP7ugRa76RtikbjzYJqRxOr4Qzvqumf4uv6urLf5Q3hz",
+	"jgl8xwS+YwLf78C0sShlfqFPP8FRZ2hA2OmRhk5D1ou/2I+7LBZ4GXG6dEpyDNDDWkvHbhEu7hjn/xVj",
+	"/CTTXRQ5OV4dKcRPHu11R3vd0V53tNcd7XXHykhHK+DRCni0Ah6tgEcr4NEKeH9WwM9pubv/p1OOtsGj",
+	"bfBoKfmsmSrx0Z5+sjrR7lwVYtXHssUhhwyFMdZNSVhxStn08oRfEQmJtmuvyzr9ch7TOo7k5UsxxN7M",
+	"Z5qpS3/Xa1XOns7WxlT66ekpu6abqmQnudycQt0E1/9TkPvlZgOMKvziRo5+caTs5uPN/wQAAP//N7du",
+	"Y+VJAQA=",
 }
 
 // GetSwagger returns the Swagger specification corresponding to the generated code
diff --git a/api/generated/v2/types.go b/api/generated/v2/types.go
index 6b6a120fe..298972d96 100644
--- a/api/generated/v2/types.go
+++ b/api/generated/v2/types.go
@@ -84,6 +84,18 @@ type Account struct {
 	// *  Online  - indicates that the associated account used as part of the delegation pool.
 	// *   NotParticipating - indicates that the associated account is neither a delegator nor a delegate.
 	Status string `json:"status"`
+
+	// The count of all applications that have been opted in, equivalent to the count of application local data (AppLocalState objects) stored in this account.
+	TotalAppsOptedIn uint64 `json:"total-apps-opted-in"`
+
+	// The count of all assets that have been opted in, equivalent to the count of AssetHolding objects held by this account.
+	TotalAssetsOptedIn uint64 `json:"total-assets-opted-in"`
+
+	// The count of all apps (AppParams objects) created by this account.
+	TotalCreatedApps uint64 `json:"total-created-apps"`
+
+	// The count of all assets (AssetParams objects) created by this account.
+	TotalCreatedAssets uint64 `json:"total-created-assets"`
 }
 
 // AccountParticipation defines model for AccountParticipation.
@@ -235,9 +247,6 @@ type AssetHolding struct {
 	// Asset ID of the holding.
 	AssetId uint64 `json:"asset-id"`
 
-	// Address that created this asset. This is the address where the parameters for this asset can be found, and also the address where unwanted asset units can be sent in the worst case.
-	Creator string `json:"creator"`
-
 	// Whether or not the asset holding is currently deleted from its account.
 	Deleted *bool `json:"deleted,omitempty"`
 
@@ -847,6 +856,9 @@ type CurrencyGreaterThan uint64
 // CurrencyLessThan defines model for currency-less-than.
 type CurrencyLessThan uint64
 
+// Exclude defines model for exclude.
+type Exclude []string
+
 // ExcludeCloseTo defines model for exclude-close-to.
 type ExcludeCloseTo bool
 
@@ -913,6 +925,17 @@ type AccountsResponse struct {
 	NextToken *string `json:"next-token,omitempty"`
 }
 
+// ApplicationLocalStatesResponse defines model for ApplicationLocalStatesResponse.
+type ApplicationLocalStatesResponse struct {
+	AppsLocalStates []ApplicationLocalState `json:"apps-local-states"`
+
+	// Round at which the results were computed.
+	CurrentRound uint64 `json:"current-round"`
+
+	// Used for pagination, when making another request provide this token with the next parameter.
+	NextToken *string `json:"next-token,omitempty"`
+}
+
 // ApplicationLogsResponse defines model for ApplicationLogsResponse.
 type ApplicationLogsResponse struct {
 
@@ -959,6 +982,17 @@ type AssetBalancesResponse struct {
 	NextToken *string `json:"next-token,omitempty"`
 }
 
+// AssetHoldingsResponse defines model for AssetHoldingsResponse.
+type AssetHoldingsResponse struct {
+	Assets []AssetHolding `json:"assets"`
+
+	// Round at which the results were computed.
+	CurrentRound uint64 `json:"current-round"`
+
+	// Used for pagination, when making another request provide this token with the next parameter.
+	NextToken *string `json:"next-token,omitempty"`
+}
+
 // AssetResponse defines model for AssetResponse.
 type AssetResponse struct {
 
@@ -1035,6 +1069,9 @@ type SearchForAccountsParams struct {
 	// Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.
 	IncludeAll *bool `json:"include-all,omitempty"`
 
+	// Exclude additional items such as asset holdings, application local data stored for this account, asset parameters created by this account, and application parameters created by this account.
+	Exclude *[]string `json:"exclude,omitempty"`
+
 	// Results should have an amount less than this value. MicroAlgos are the default currency unless an asset-id is provided, in which case the asset will be used.
 	CurrencyLessThan *uint64 `json:"currency-less-than,omitempty"`
 
@@ -1056,6 +1093,73 @@ type LookupAccountByIDParams struct {
 
 	// Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.
 	IncludeAll *bool `json:"include-all,omitempty"`
+
+	// Exclude additional items such as asset holdings, application local data stored for this account, asset parameters created by this account, and application parameters created by this account.
+	Exclude *[]string `json:"exclude,omitempty"`
+}
+
+// LookupAccountAppLocalStatesParams defines parameters for LookupAccountAppLocalStates.
+type LookupAccountAppLocalStatesParams struct {
+
+	// Application ID
+	ApplicationId *uint64 `json:"application-id,omitempty"`
+
+	// Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.
+	IncludeAll *bool `json:"include-all,omitempty"`
+
+	// Maximum number of results to return. There could be additional pages even if the limit is not reached.
+	Limit *uint64 `json:"limit,omitempty"`
+
+	// The next page of results. Use the next token provided by the previous results.
+	Next *string `json:"next,omitempty"`
+}
+
+// LookupAccountAssetsParams defines parameters for LookupAccountAssets.
+type LookupAccountAssetsParams struct {
+
+	// Asset ID
+	AssetId *uint64 `json:"asset-id,omitempty"`
+
+	// Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.
+	IncludeAll *bool `json:"include-all,omitempty"`
+
+	// Maximum number of results to return. There could be additional pages even if the limit is not reached.
+	Limit *uint64 `json:"limit,omitempty"`
+
+	// The next page of results. Use the next token provided by the previous results.
+	Next *string `json:"next,omitempty"`
+}
+
+// LookupAccountCreatedApplicationsParams defines parameters for LookupAccountCreatedApplications.
+type LookupAccountCreatedApplicationsParams struct {
+
+	// Application ID
+	ApplicationId *uint64 `json:"application-id,omitempty"`
+
+	// Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.
+	IncludeAll *bool `json:"include-all,omitempty"`
+
+	// Maximum number of results to return. There could be additional pages even if the limit is not reached.
+	Limit *uint64 `json:"limit,omitempty"`
+
+	// The next page of results. Use the next token provided by the previous results.
+	Next *string `json:"next,omitempty"`
+}
+
+// LookupAccountCreatedAssetsParams defines parameters for LookupAccountCreatedAssets.
+type LookupAccountCreatedAssetsParams struct {
+
+	// Asset ID
+	AssetId *uint64 `json:"asset-id,omitempty"`
+
+	// Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.
+	IncludeAll *bool `json:"include-all,omitempty"`
+
+	// Maximum number of results to return. There could be additional pages even if the limit is not reached.
+	Limit *uint64 `json:"limit,omitempty"`
+
+	// The next page of results. Use the next token provided by the previous results.
+	Next *string `json:"next,omitempty"`
 }
 
 // LookupAccountTransactionsParams defines parameters for LookupAccountTransactions.
@@ -1114,6 +1218,9 @@ type SearchForApplicationsParams struct {
 	// Application ID
 	ApplicationId *uint64 `json:"application-id,omitempty"`
 
+	// Filter just applications with the given creator address.
+	Creator *string `json:"creator,omitempty"`
+
 	// Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.
 	IncludeAll *bool `json:"include-all,omitempty"`
 
@@ -1197,9 +1304,6 @@ type LookupAssetBalancesParams struct {
 	// The next page of results. Use the next token provided by the previous results.
 	Next *string `json:"next,omitempty"`
 
-	// Include results for the specified round.
-	Round *uint64 `json:"round,omitempty"`
-
 	// Results should have an amount greater than this value. MicroAlgos are the default currency unless an asset-id is provided, in which case the asset will be used.
 	CurrencyGreaterThan *uint64 `json:"currency-greater-than,omitempty"`
 
diff --git a/api/handlers.go b/api/handlers.go
index 481a78ef8..96253674c 100644
--- a/api/handlers.go
+++ b/api/handlers.go
@@ -40,31 +40,9 @@ type ServerImplementation struct {
 	log *log.Logger
 
 	disabledParams *DisabledMap
-}
-
-/////////////////////
-// Limit Constants //
-/////////////////////
-
-// Transactions
-const maxTransactionsLimit = 10000
-const defaultTransactionsLimit = 1000
-
-// Accounts
-const maxAccountsLimit = 1000
-const defaultAccountsLimit = 100
-
-// Assets
-const maxAssetsLimit = 1000
-const defaultAssetsLimit = 100
 
-// Asset Balances
-const maxBalancesLimit = 10000
-const defaultBalancesLimit = 1000
-
-// Applications
-const maxApplicationsLimit = 1000
-const defaultApplicationsLimit = 100
+	opts ExtraOptions
+}
 
 //////////////////////
 // Helper functions //
@@ -147,6 +125,33 @@ func (si *ServerImplementation) MakeHealthCheck(ctx echo.Context) error {
 	})
 }
 
+var errInvalidExcludeParameter = errors.New("invalid exclude argument")
+
+// set query options based on the value of the "exclude" parameter
+func setExcludeQueryOptions(exclude []string, opts *idb.AccountQueryOptions) error {
+	for _, e := range exclude {
+		switch e {
+		case "all":
+			opts.IncludeAssetHoldings = false
+			opts.IncludeAssetParams = false
+			opts.IncludeAppLocalState = false
+			opts.IncludeAppParams = false
+		case "assets":
+			opts.IncludeAssetHoldings = false
+		case "created-assets":
+			opts.IncludeAssetParams = false
+		case "apps-local-state":
+			opts.IncludeAppLocalState = false
+		case "created-apps":
+			opts.IncludeAppParams = false
+		case "none":
+		default:
+			return fmt.Errorf(`unknown value "%s": %w`, e, errInvalidExcludeParameter)
+		}
+	}
+	return nil
+}
+
 func (si *ServerImplementation) verifyHandler(operationID string, ctx echo.Context) error {
 	return Verify(si.disabledParams, operationID, ctx, si.log)
 }
@@ -158,21 +163,35 @@ func (si *ServerImplementation) LookupAccountByID(ctx echo.Context, accountID st
 		return badRequest(ctx, err.Error())
 	}
 
-	addr, errors := decodeAddress(&accountID, "account-id", make([]string, 0))
-	if len(errors) != 0 {
-		return badRequest(ctx, errors[0])
+	addr, decodeErrors := decodeAddress(&accountID, "account-id", make([]string, 0))
+	if len(decodeErrors) != 0 {
+		return badRequest(ctx, decodeErrors[0])
 	}
 
 	options := idb.AccountQueryOptions{
 		EqualToAddress:       addr[:],
 		IncludeAssetHoldings: true,
 		IncludeAssetParams:   true,
+		IncludeAppLocalState: true,
+		IncludeAppParams:     true,
 		Limit:                1,
 		IncludeDeleted:       boolOrDefault(params.IncludeAll),
+		MaxResources:         uint64(si.opts.MaxAPIResourcesPerAccount),
+	}
+
+	if params.Exclude != nil {
+		err := setExcludeQueryOptions(*params.Exclude, &options)
+		if err != nil {
+			return badRequest(ctx, err.Error())
+		}
 	}
 
 	accounts, round, err := si.fetchAccounts(ctx.Request().Context(), options, params.Round)
 	if err != nil {
+		var maxErr idb.MaxAPIResourcesPerAccountError
+		if errors.As(err, &maxErr) {
+			return ctx.JSON(http.StatusBadRequest, si.maxAccountsErrorToAccountsErrorResponse(maxErr))
+		}
 		return indexerError(ctx, fmt.Errorf("%s: %w", errFailedSearchingAccount, err))
 	}
 
@@ -190,6 +209,123 @@ func (si *ServerImplementation) LookupAccountByID(ctx echo.Context, accountID st
 	})
 }
 
+// LookupAccountAppLocalStates queries indexer for AppLocalState for a given account, and optionally a given app ID.
+// (GET /v2/accounts/{account-id}/apps-local-state)
+func (si *ServerImplementation) LookupAccountAppLocalStates(ctx echo.Context, accountID string, params generated.LookupAccountAppLocalStatesParams) error {
+	if err := si.verifyHandler("LookupAccountAppLocalStates", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
+	search := generated.SearchForApplicationsParams{
+		Creator:       &accountID,
+		ApplicationId: params.ApplicationId,
+		IncludeAll:    params.IncludeAll,
+		Limit:         params.Limit,
+		Next:          params.Next,
+	}
+	options, err := si.appParamsToApplicationQuery(search)
+	if err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
+	apps, round, err := si.fetchAppLocalStates(ctx.Request().Context(), options)
+	if err != nil {
+		return indexerError(ctx, fmt.Errorf("%s: %w", errFailedSearchingApplication, err))
+	}
+
+	var next *string
+	if len(apps) > 0 {
+		next = strPtr(strconv.FormatUint(apps[len(apps)-1].Id, 10))
+	}
+
+	out := generated.ApplicationLocalStatesResponse{
+		AppsLocalStates: apps,
+		CurrentRound:    round,
+		NextToken:       next,
+	}
+	return ctx.JSON(http.StatusOK, out)
+}
+
+// LookupAccountAssets queries indexer for AssetHolding for a given account, and optionally a given asset ID.
+// (GET /v2/accounts/{account-id}/assets)
+func (si *ServerImplementation) LookupAccountAssets(ctx echo.Context, accountID string, params generated.LookupAccountAssetsParams) error {
+	if err := si.verifyHandler("LookupAccountAssets", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
+	addr, errors := decodeAddress(&accountID, "account-id", make([]string, 0))
+	if len(errors) != 0 {
+		return badRequest(ctx, errors[0])
+	}
+
+	var assetGreaterThan uint64 = 0
+	if params.Next != nil {
+		agt, err := strconv.ParseUint(*params.Next, 10, 64)
+		if err != nil {
+			return badRequest(ctx, fmt.Sprintf("%s: %v", errUnableToParseNext, err))
+		}
+		assetGreaterThan = agt
+	}
+
+	query := idb.AssetBalanceQuery{
+		Address:        addr,
+		AssetID:        uintOrDefault(params.AssetId),
+		AssetIDGT:      assetGreaterThan,
+		IncludeDeleted: boolOrDefault(params.IncludeAll),
+		Limit:          min(uintOrDefaultValue(params.Limit, si.opts.DefaultBalancesLimit), si.opts.MaxBalancesLimit),
+	}
+
+	assets, round, err := si.fetchAssetHoldings(ctx.Request().Context(), query)
+	if err != nil {
+		return indexerError(ctx, fmt.Errorf("%s: %w", errFailedSearchingAssetBalances, err))
+	}
+
+	var next *string
+	if len(assets) > 0 {
+		next = strPtr(strconv.FormatUint(assets[len(assets)-1].AssetId, 10))
+	}
+
+	return ctx.JSON(http.StatusOK, generated.AssetHoldingsResponse{
+		CurrentRound: round,
+		NextToken:    next,
+		Assets:       assets,
+	})
+}
+
+// LookupAccountCreatedApplications queries indexer for AppParams for a given account, and optionally a given app ID.
+// (GET /v2/accounts/{account-id}/created-applications)
+func (si *ServerImplementation) LookupAccountCreatedApplications(ctx echo.Context, accountID string, params generated.LookupAccountCreatedApplicationsParams) error {
+	if err := si.verifyHandler("LookupAccountCreatedApplications", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
+	search := generated.SearchForApplicationsParams{
+		Creator:       &accountID,
+		ApplicationId: params.ApplicationId,
+		IncludeAll:    params.IncludeAll,
+		Limit:         params.Limit,
+		Next:          params.Next,
+	}
+	return si.SearchForApplications(ctx, search)
+}
+
+// LookupAccountCreatedAssets queries indexer for AssetParams for a given account, and optionally a given asset ID.
+// (GET /v2/accounts/{account-id}/created-assets)
+func (si *ServerImplementation) LookupAccountCreatedAssets(ctx echo.Context, accountID string, params generated.LookupAccountCreatedAssetsParams) error {
+	if err := si.verifyHandler("LookupAccountCreatedAssets", ctx); err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
+	search := generated.SearchForAssetsParams{
+		Creator:    &accountID,
+		AssetId:    params.AssetId,
+		IncludeAll: params.IncludeAll,
+		Limit:      params.Limit,
+		Next:       params.Next,
+	}
+	return si.SearchForAssets(ctx, search)
+}
+
 // SearchForAccounts returns accounts matching the provided parameters
 // (GET /v2/accounts)
 func (si *ServerImplementation) SearchForAccounts(ctx echo.Context, params generated.SearchForAccountsParams) error {
@@ -201,19 +337,29 @@ func (si *ServerImplementation) SearchForAccounts(ctx echo.Context, params gener
 		return badRequest(ctx, errMultiAcctRewind)
 	}
 
-	spendingAddr, errors := decodeAddress(params.AuthAddr, "account-id", make([]string, 0))
-	if len(errors) != 0 {
-		return badRequest(ctx, errors[0])
+	spendingAddr, decodeErrors := decodeAddress(params.AuthAddr, "account-id", make([]string, 0))
+	if len(decodeErrors) != 0 {
+		return badRequest(ctx, decodeErrors[0])
 	}
 
 	options := idb.AccountQueryOptions{
 		IncludeAssetHoldings: true,
 		IncludeAssetParams:   true,
-		Limit:                min(uintOrDefaultValue(params.Limit, defaultAccountsLimit), maxAccountsLimit),
+		IncludeAppLocalState: true,
+		IncludeAppParams:     true,
+		Limit:                min(uintOrDefaultValue(params.Limit, si.opts.DefaultAccountsLimit), si.opts.MaxAccountsLimit),
 		HasAssetID:           uintOrDefault(params.AssetId),
 		HasAppID:             uintOrDefault(params.ApplicationId),
 		EqualToAuthAddr:      spendingAddr[:],
 		IncludeDeleted:       boolOrDefault(params.IncludeAll),
+		MaxResources:         uint64(si.opts.MaxAPIResourcesPerAccount),
+	}
+
+	if params.Exclude != nil {
+		err := setExcludeQueryOptions(*params.Exclude, &options)
+		if err != nil {
+			return badRequest(ctx, err.Error())
+		}
 	}
 
 	// Set GT/LT on Algos or Asset depending on whether or not an assetID was specified
@@ -234,8 +380,11 @@ func (si *ServerImplementation) SearchForAccounts(ctx echo.Context, params gener
 	}
 
 	accounts, round, err := si.fetchAccounts(ctx.Request().Context(), options, params.Round)
-
 	if err != nil {
+		var maxErr idb.MaxAPIResourcesPerAccountError
+		if errors.As(err, &maxErr) {
+			return ctx.JSON(http.StatusBadRequest, si.maxAccountsErrorToAccountsErrorResponse(maxErr))
+		}
 		return indexerError(ctx, fmt.Errorf("%s: %w", errFailedSearchingAccount, err))
 	}
 
@@ -297,7 +446,13 @@ func (si *ServerImplementation) SearchForApplications(ctx echo.Context, params g
 	if err := si.verifyHandler("SearchForApplications", ctx); err != nil {
 		return badRequest(ctx, err.Error())
 	}
-	apps, round, err := si.fetchApplications(ctx.Request().Context(), params)
+
+	options, err := si.appParamsToApplicationQuery(params)
+	if err != nil {
+		return badRequest(ctx, err.Error())
+	}
+
+	apps, round, err := si.fetchApplications(ctx.Request().Context(), options)
 	if err != nil {
 		return indexerError(ctx, fmt.Errorf("%s: %w", errFailedSearchingApplication, err))
 	}
@@ -321,13 +476,13 @@ func (si *ServerImplementation) LookupApplicationByID(ctx echo.Context, applicat
 	if err := si.verifyHandler("LookupApplicationByID", ctx); err != nil {
 		return badRequest(ctx, err.Error())
 	}
-	p := generated.SearchForApplicationsParams{
-		ApplicationId: &applicationID,
-		IncludeAll:    params.IncludeAll,
-		Limit:         uint64Ptr(1),
+	q := idb.ApplicationQuery{
+		ApplicationID:  applicationID,
+		IncludeDeleted: boolOrDefault(params.IncludeAll),
+		Limit:          1,
 	}
 
-	apps, round, err := si.fetchApplications(ctx.Request().Context(), p)
+	apps, round, err := si.fetchApplications(ctx.Request().Context(), q)
 	if err != nil {
 		return indexerError(ctx, fmt.Errorf("%s: %w", errFailedSearchingApplication, err))
 	}
@@ -364,7 +519,7 @@ func (si *ServerImplementation) LookupApplicationLogsByID(ctx echo.Context, appl
 		Address:       params.SenderAddress,
 	}
 
-	filter, err := transactionParamsToTransactionFilter(searchParams)
+	filter, err := si.transactionParamsToTransactionFilter(searchParams)
 	if err != nil {
 		return badRequest(ctx, err.Error())
 	}
@@ -421,7 +576,7 @@ func (si *ServerImplementation) LookupAssetByID(ctx echo.Context, assetID uint64
 		Limit:      uint64Ptr(1),
 		IncludeAll: params.IncludeAll,
 	}
-	options, err := assetParamsToAssetQuery(search)
+	options, err := si.assetParamsToAssetQuery(search)
 	if err != nil {
 		return badRequest(ctx, err.Error())
 	}
@@ -457,7 +612,7 @@ func (si *ServerImplementation) LookupAssetBalances(ctx echo.Context, assetID ui
 		AmountGT:       params.CurrencyGreaterThan,
 		AmountLT:       params.CurrencyLessThan,
 		IncludeDeleted: boolOrDefault(params.IncludeAll),
-		Limit:          min(uintOrDefaultValue(params.Limit, defaultBalancesLimit), maxBalancesLimit),
+		Limit:          min(uintOrDefaultValue(params.Limit, si.opts.DefaultBalancesLimit), si.opts.MaxBalancesLimit),
 	}
 
 	if params.Next != nil {
@@ -524,7 +679,7 @@ func (si *ServerImplementation) SearchForAssets(ctx echo.Context, params generat
 		return badRequest(ctx, err.Error())
 	}
 
-	options, err := assetParamsToAssetQuery(params)
+	options, err := si.assetParamsToAssetQuery(params)
 	if err != nil {
 		return badRequest(ctx, err.Error())
 	}
@@ -570,7 +725,7 @@ func (si *ServerImplementation) LookupTransaction(ctx echo.Context, txid string)
 		return badRequest(ctx, err.Error())
 	}
 
-	filter, err := transactionParamsToTransactionFilter(generated.SearchForTransactionsParams{
+	filter, err := si.transactionParamsToTransactionFilter(generated.SearchForTransactionsParams{
 		Txid: strPtr(txid),
 	})
 	if err != nil {
@@ -611,7 +766,7 @@ func (si *ServerImplementation) SearchForTransactions(ctx echo.Context, params g
 		return badRequest(ctx, err.Error())
 	}
 
-	filter, err := transactionParamsToTransactionFilter(params)
+	filter, err := si.transactionParamsToTransactionFilter(params)
 	if err != nil {
 		return badRequest(ctx, err.Error())
 	}
@@ -677,13 +832,12 @@ func notFound(ctx echo.Context, err string) error {
 ///////////////////////
 
 // fetchApplications fetches all results
-func (si *ServerImplementation) fetchApplications(ctx context.Context, params generated.SearchForApplicationsParams) ([]generated.Application, uint64, error) {
-	params.Limit = uint64Ptr(min(uintOrDefaultValue(params.Limit, defaultApplicationsLimit), maxApplicationsLimit))
+func (si *ServerImplementation) fetchApplications(ctx context.Context, params idb.ApplicationQuery) ([]generated.Application, uint64, error) {
 	var apps []generated.Application
 	var round uint64
 	err := callWithTimeout(ctx, si.log, si.timeout, func(ctx context.Context) error {
 		var results <-chan idb.ApplicationRow
-		results, round = si.db.Applications(ctx, &params)
+		results, round = si.db.Applications(ctx, params)
 
 		for result := range results {
 			if result.Error != nil {
@@ -698,7 +852,31 @@ func (si *ServerImplementation) fetchApplications(ctx context.Context, params ge
 		return nil, 0, err
 	}
 
-	return apps, round, err
+	return apps, round, nil
+}
+
+// fetchAppLocalStates fetches all generated.AppLocalState from a query
+func (si *ServerImplementation) fetchAppLocalStates(ctx context.Context, params idb.ApplicationQuery) ([]generated.ApplicationLocalState, uint64, error) {
+	var als []generated.ApplicationLocalState
+	var round uint64
+	err := callWithTimeout(ctx, si.log, si.timeout, func(ctx context.Context) error {
+		var results <-chan idb.AppLocalStateRow
+		results, round = si.db.AppLocalState(ctx, params)
+
+		for result := range results {
+			if result.Error != nil {
+				return result.Error
+			}
+			als = append(als, result.AppLocalState)
+		}
+
+		return nil
+	})
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return als, round, nil
 }
 
 // fetchAssets fetches all results and converts them into generated.Asset objects
@@ -797,6 +975,47 @@ func (si *ServerImplementation) fetchAssetBalances(ctx context.Context, options
 	return balances, round, nil
 }
 
+// fetchAssetHoldings fetches all balances from a query and converts them into
+// generated.AssetHolding objects
+func (si *ServerImplementation) fetchAssetHoldings(ctx context.Context, options idb.AssetBalanceQuery) ([]generated.AssetHolding, uint64 /*round*/, error) {
+	var round uint64
+	balances := make([]generated.AssetHolding, 0)
+	err := callWithTimeout(ctx, si.log, si.timeout, func(ctx context.Context) error {
+		var assetbalchan <-chan idb.AssetBalanceRow
+		assetbalchan, round = si.db.AssetBalances(ctx, options)
+
+		for row := range assetbalchan {
+			if row.Error != nil {
+				return row.Error
+			}
+
+			addr := basics.Address{}
+			if len(row.Address) != len(addr) {
+				return fmt.Errorf(errInvalidCreatorAddress)
+			}
+			copy(addr[:], row.Address[:])
+
+			bal := generated.AssetHolding{
+				Amount:          row.Amount,
+				AssetId:         row.AssetID,
+				IsFrozen:        row.Frozen,
+				OptedInAtRound:  row.CreatedRound,
+				OptedOutAtRound: row.ClosedRound,
+				Deleted:         row.Deleted,
+			}
+
+			balances = append(balances, bal)
+		}
+
+		return nil
+	})
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return balances, round, nil
+}
+
 // fetchBlock looks up a block and converts it into a generated.Block object
 // the method also loads the transactions into the returned block object.
 func (si *ServerImplementation) fetchBlock(ctx context.Context, round uint64) (generated.Block, error) {
@@ -975,7 +1194,7 @@ func (si *ServerImplementation) fetchTransactions(ctx context.Context, filter id
 		return nil, "", 0, err
 	}
 
-	return results, nextToken, round, err
+	return results, nextToken, round, nil
 }
 
 //////////////////////
diff --git a/api/handlers_e2e_test.go b/api/handlers_e2e_test.go
index 753ddb822..9d675dc06 100644
--- a/api/handlers_e2e_test.go
+++ b/api/handlers_e2e_test.go
@@ -1,16 +1,21 @@
 package api
 
 import (
+	"context"
 	"encoding/base64"
 	"fmt"
+	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
 	"strconv"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/algorand/go-algorand/crypto"
 	"github.com/labstack/echo/v4"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/algorand/go-algorand-sdk/encoding/json"
@@ -26,6 +31,29 @@ import (
 	"github.com/algorand/indexer/util/test"
 )
 
+var defaultOpts = ExtraOptions{
+	MaxTransactionsLimit:     10000,
+	DefaultTransactionsLimit: 1000,
+
+	MaxAccountsLimit:     1000,
+	DefaultAccountsLimit: 100,
+
+	MaxAssetsLimit:     1000,
+	DefaultAssetsLimit: 100,
+
+	MaxBalancesLimit:     10000,
+	DefaultBalancesLimit: 1000,
+
+	MaxApplicationsLimit:     1000,
+	DefaultApplicationsLimit: 100,
+
+	DisabledMapConfig: MakeDisabledMapConfig(),
+}
+
+func testServerImplementation(db idb.IndexerDb) *ServerImplementation {
+	return &ServerImplementation{db: db, timeout: 30 * time.Second, opts: defaultOpts}
+}
+
 func setupIdb(t *testing.T, genesis bookkeeping.Genesis, genesisBlock bookkeeping.Block) (*postgres.IndexerDb /*db*/, func() /*shutdownFunc*/) {
 	_, connStr, shutdownFunc := pgtest.SetupPostgres(t)
 
@@ -46,12 +74,12 @@ func setupIdb(t *testing.T, genesis bookkeeping.Genesis, genesisBlock bookkeepin
 	return db, newShutdownFunc
 }
 
-func TestApplicationHandler(t *testing.T) {
+func TestApplicationHandlers(t *testing.T) {
 	db, shutdownFunc := setupIdb(t, test.MakeGenesis(), test.MakeGenesisBlock())
 	defer shutdownFunc()
 
 	///////////
-	// Given // A block containing an app call txn with ExtraProgramPages
+	// Given // A block containing an app call txn with ExtraProgramPages, that the creator and another account have opted into
 	///////////
 
 	const expectedAppIdx = 1 // must be 1 since this is the first txn
@@ -76,8 +104,10 @@ func TestApplicationHandler(t *testing.T) {
 			ApplicationID: expectedAppIdx,
 		},
 	}
+	optInTxnA := test.MakeAppOptInTxn(expectedAppIdx, test.AccountA)
+	optInTxnB := test.MakeAppOptInTxn(expectedAppIdx, test.AccountB)
 
-	block, err := test.MakeBlockForTxns(test.MakeGenesisBlock().BlockHeader, &txn)
+	block, err := test.MakeBlockForTxns(test.MakeGenesisBlock().BlockHeader, &txn, &optInTxnA, &optInTxnB)
 	require.NoError(t, err)
 
 	err = db.AddBlock(&block)
@@ -87,30 +117,641 @@ func TestApplicationHandler(t *testing.T) {
 	// When // We query the app
 	//////////
 
-	e := echo.New()
-	req := httptest.NewRequest(http.MethodGet, "/", nil)
-	rec := httptest.NewRecorder()
-	c := e.NewContext(req, rec)
-	c.SetPath("/v2/applications/:appidx")
-	c.SetParamNames("appidx")
-	c.SetParamValues(strconv.Itoa(expectedAppIdx))
+	setupReq := func(path, paramName, paramValue string) (echo.Context, *ServerImplementation, *httptest.ResponseRecorder) {
+		e := echo.New()
+		req := httptest.NewRequest(http.MethodGet, "/", nil)
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+		c.SetPath(path)
+		c.SetParamNames(paramName)
+		c.SetParamValues(paramValue)
+		api := testServerImplementation(db)
+		return c, api, rec
+	}
 
-	api := &ServerImplementation{db: db, timeout: 30 * time.Second}
+	c, api, rec := setupReq("/v2/applications/:appidx", "appidx", strconv.Itoa(expectedAppIdx))
 	params := generated.LookupApplicationByIDParams{}
 	err = api.LookupApplicationByID(c, expectedAppIdx, params)
 	require.NoError(t, err)
 	require.Equal(t, http.StatusOK, rec.Code, fmt.Sprintf("unexpected return code, body: %s", rec.Body.String()))
 
 	//////////
-	// Then // The response has non-zero ExtraProgramPages
+	// Then // The response has non-zero ExtraProgramPages and other app data
 	//////////
 
+	checkApp := func(t *testing.T, app *generated.Application) {
+		require.NotNil(t, app)
+		require.NotNil(t, app.Params.ExtraProgramPages)
+		require.Equal(t, uint64(extraPages), *app.Params.ExtraProgramPages)
+		require.Equal(t, app.Id, uint64(expectedAppIdx))
+		require.NotNil(t, app.Params.Creator)
+		require.Equal(t, *app.Params.Creator, test.AccountA.String())
+		require.Equal(t, app.Params.ApprovalProgram, []byte{0x02, 0x20, 0x01, 0x01, 0x22})
+		require.Equal(t, app.Params.ClearStateProgram, []byte{0x02, 0x20, 0x01, 0x01, 0x22})
+	}
+
 	var response generated.ApplicationResponse
 	data := rec.Body.Bytes()
 	err = json.Decode(data, &response)
 	require.NoError(t, err)
-	require.NotNil(t, response.Application.Params.ExtraProgramPages)
-	require.Equal(t, uint64(extraPages), *response.Application.Params.ExtraProgramPages)
+	checkApp(t, response.Application)
+
+	t.Run("created-applications", func(t *testing.T) {
+		//////////
+		// When // We look up the app by creator address
+		//////////
+
+		c, api, rec := setupReq("/v2/accounts/:accountid/created-applications", "accountid", test.AccountA.String())
+		params := generated.LookupAccountCreatedApplicationsParams{}
+		err = api.LookupAccountCreatedApplications(c, test.AccountA.String(), params)
+		require.NoError(t, err)
+		require.Equal(t, http.StatusOK, rec.Code, fmt.Sprintf("unexpected return code, body: %s", rec.Body.String()))
+
+		//////////
+		// Then // The response has non-zero ExtraProgramPages and other app data
+		//////////
+
+		var response generated.ApplicationsResponse
+		data := rec.Body.Bytes()
+		err = json.Decode(data, &response)
+		require.NoError(t, err)
+		require.Len(t, response.Applications, 1)
+		checkApp(t, &response.Applications[0])
+	})
+
+	checkAppLocalState := func(t *testing.T, ls *generated.ApplicationLocalState) {
+		require.NotNil(t, ls)
+		require.NotNil(t, ls.Deleted)
+		require.False(t, *ls.Deleted)
+		require.Equal(t, ls.Id, uint64(expectedAppIdx))
+	}
+
+	for _, tc := range []struct{ name, addr string }{
+		{"creator", test.AccountA.String()},
+		{"opted-in-account", test.AccountB.String()},
+	} {
+		t.Run("app-local-state-"+tc.name, func(t *testing.T) {
+			//////////
+			// When // We look up the app's local state for an address that has opted in
+			//////////
+
+			c, api, rec := setupReq("/v2/accounts/:accountid/apps-local-state", "accountid", test.AccountA.String())
+			params := generated.LookupAccountAppLocalStatesParams{}
+			err = api.LookupAccountAppLocalStates(c, tc.addr, params)
+			require.NoError(t, err)
+			require.Equal(t, http.StatusOK, rec.Code, fmt.Sprintf("unexpected return code, body: %s", rec.Body.String()))
+
+			//////////
+			// Then // AppLocalState is available for that address
+			//////////
+
+			var response generated.ApplicationLocalStatesResponse
+			data := rec.Body.Bytes()
+			err = json.Decode(data, &response)
+			require.NoError(t, err)
+			require.Len(t, response.AppsLocalStates, 1)
+			checkAppLocalState(t, &response.AppsLocalStates[0])
+		})
+	}
+}
+
+func TestAccountExcludeParameters(t *testing.T) {
+	db, shutdownFunc := setupIdb(t, test.MakeGenesis(), test.MakeGenesisBlock())
+	defer shutdownFunc()
+
+	///////////
+	// Given // A block containing a creator of an app, an asset, who also holds and has opted-into those apps.
+	///////////
+
+	const expectedAppIdx = 1 // must be 1 since this is the first txn
+	const expectedAssetIdx = 2
+	createAppTxn := test.MakeCreateAppTxn(test.AccountA)
+	createAssetTxn := test.MakeAssetConfigTxn(0, 100, 0, false, "UNIT", "Asset 2", "http://asset2.com", test.AccountA)
+	appOptInTxnA := test.MakeAppOptInTxn(expectedAppIdx, test.AccountA)
+	appOptInTxnB := test.MakeAppOptInTxn(expectedAppIdx, test.AccountB)
+	assetOptInTxnA := test.MakeAssetOptInTxn(expectedAssetIdx, test.AccountA)
+	assetOptInTxnB := test.MakeAssetOptInTxn(expectedAssetIdx, test.AccountB)
+
+	block, err := test.MakeBlockForTxns(test.MakeGenesisBlock().BlockHeader, &createAppTxn, &createAssetTxn,
+		&appOptInTxnA, &appOptInTxnB, &assetOptInTxnA, &assetOptInTxnB)
+	require.NoError(t, err)
+
+	err = db.AddBlock(&block)
+	require.NoError(t, err, "failed to commit")
+
+	//////////
+	// When // We look up the address using various exclude parameters.
+	//////////
+
+	setupReq := func(path, paramName, paramValue string) (echo.Context, *ServerImplementation, *httptest.ResponseRecorder) {
+		e := echo.New()
+		req := httptest.NewRequest(http.MethodGet, "/", nil)
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+		c.SetPath(path)
+		c.SetParamNames(paramName)
+		c.SetParamValues(paramValue)
+		api := testServerImplementation(db)
+		return c, api, rec
+	}
+
+	//////////
+	// Then // Those parameters are excluded.
+	//////////
+
+	testCases := []struct {
+		address   basics.Address
+		exclude   []string
+		check     func(*testing.T, generated.AccountResponse)
+		errStatus int
+	}{{
+		address: test.AccountA,
+		exclude: []string{"all"},
+		check: func(t *testing.T, r generated.AccountResponse) {
+			require.Nil(t, r.Account.CreatedAssets)
+			require.Nil(t, r.Account.CreatedApps)
+			require.Nil(t, r.Account.Assets)
+			require.Nil(t, r.Account.AppsLocalState)
+		}}, {
+		address: test.AccountA,
+		exclude: []string{"none"},
+		check: func(t *testing.T, r generated.AccountResponse) {
+			require.NotNil(t, r.Account.CreatedAssets)
+			require.NotNil(t, r.Account.CreatedApps)
+			require.NotNil(t, r.Account.Assets)
+			require.NotNil(t, r.Account.AppsLocalState)
+		}}, {
+		address: test.AccountA,
+		check: func(t *testing.T, r generated.AccountResponse) {
+			require.NotNil(t, r.Account.CreatedAssets)
+			require.NotNil(t, r.Account.CreatedApps)
+			require.NotNil(t, r.Account.Assets)
+			require.NotNil(t, r.Account.AppsLocalState)
+		}}, {
+		address: test.AccountA,
+		exclude: []string{"created-assets", "created-apps", "apps-local-state", "assets"},
+		check: func(t *testing.T, r generated.AccountResponse) {
+			require.Nil(t, r.Account.CreatedAssets)
+			require.Nil(t, r.Account.CreatedApps)
+			require.Nil(t, r.Account.Assets)
+			require.Nil(t, r.Account.AppsLocalState)
+		}}, {
+		address: test.AccountA,
+		exclude: []string{"created-assets"},
+		check: func(t *testing.T, r generated.AccountResponse) {
+			require.Nil(t, r.Account.CreatedAssets)
+			require.NotNil(t, r.Account.CreatedApps)
+			require.NotNil(t, r.Account.Assets)
+			require.NotNil(t, r.Account.AppsLocalState)
+		}}, {
+		address: test.AccountA,
+		exclude: []string{"created-apps"},
+		check: func(t *testing.T, r generated.AccountResponse) {
+			require.NotNil(t, r.Account.CreatedAssets)
+			require.Nil(t, r.Account.CreatedApps)
+			require.NotNil(t, r.Account.Assets)
+			require.NotNil(t, r.Account.AppsLocalState)
+		}}, {
+		address: test.AccountA,
+		exclude: []string{"apps-local-state"},
+		check: func(t *testing.T, r generated.AccountResponse) {
+			require.NotNil(t, r.Account.CreatedAssets)
+			require.NotNil(t, r.Account.CreatedApps)
+			require.NotNil(t, r.Account.Assets)
+			require.Nil(t, r.Account.AppsLocalState)
+		}}, {
+		address: test.AccountA,
+		exclude: []string{"assets"},
+		check: func(t *testing.T, r generated.AccountResponse) {
+			require.NotNil(t, r.Account.CreatedAssets)
+			require.NotNil(t, r.Account.CreatedApps)
+			require.Nil(t, r.Account.Assets)
+			require.NotNil(t, r.Account.AppsLocalState)
+		}}, {
+		address: test.AccountB,
+		exclude: []string{"assets", "apps-local-state"},
+		check: func(t *testing.T, r generated.AccountResponse) {
+			require.Nil(t, r.Account.CreatedAssets)
+			require.Nil(t, r.Account.CreatedApps)
+			require.Nil(t, r.Account.Assets)
+			require.Nil(t, r.Account.AppsLocalState)
+		}},
+		{
+			address:   test.AccountA,
+			exclude:   []string{"abc"},
+			errStatus: http.StatusBadRequest,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("exclude %v", tc.exclude), func(t *testing.T) {
+			c, api, rec := setupReq("/v2/accounts/:account-id", "account-id", tc.address.String())
+			err := api.LookupAccountByID(c, tc.address.String(), generated.LookupAccountByIDParams{Exclude: &tc.exclude})
+			require.NoError(t, err)
+			if tc.errStatus != 0 {
+				require.Equal(t, tc.errStatus, rec.Code)
+				return
+			}
+			require.Equal(t, http.StatusOK, rec.Code, fmt.Sprintf("unexpected return code, body: %s", rec.Body.String()))
+			data := rec.Body.Bytes()
+			var response generated.AccountResponse
+			err = json.Decode(data, &response)
+			require.NoError(t, err)
+			tc.check(t, response)
+		})
+	}
+
+}
+
+type accountsErrorResponse struct {
+	Data struct {
+		Address            *string `json:"address,omitempty"`
+		MaxResults         *uint64 `json:"max-results,omitempty"`
+		Message            string  `json:"message"`
+		TotalAppsOptedIn   *uint64 `json:"total-apps-opted-in,omitempty"`
+		TotalAssetsOptedIn *uint64 `json:"total-assets-opted-in,omitempty"`
+		TotalCreatedApps   *uint64 `json:"total-created-apps,omitempty"`
+		TotalCreatedAssets *uint64 `json:"total-created-assets,omitempty"`
+	} `json:"data,omitempty"`
+	Message string `json:"message"`
+}
+
+func TestAccountMaxResultsLimit(t *testing.T) {
+	db, shutdownFunc := setupIdb(t, test.MakeGenesis(), test.MakeGenesisBlock())
+	defer shutdownFunc()
+
+	///////////
+	// Given // A block containing an address that has created 10 apps, deleted 5 apps, and created 10 assets,
+	//       // deleted 5 assets, and another address that has opted into the 5 apps and 5 assets remaining
+	///////////
+
+	deletedAppIDs := []uint64{1, 2, 3, 4, 5}
+	deletedAssetIDs := []uint64{6, 7, 8, 9, 10}
+	expectedAppIDs := []uint64{11, 12, 13, 14, 15}
+	expectedAssetIDs := []uint64{16, 17, 18, 19, 20}
+
+	var txns []transactions.SignedTxnWithAD
+	// make apps and assets
+	for range deletedAppIDs {
+		txns = append(txns, test.MakeCreateAppTxn(test.AccountA))
+	}
+	for _, id := range deletedAssetIDs {
+		txns = append(txns, test.MakeAssetConfigTxn(0, 100, 0, false, "UNIT",
+			fmt.Sprintf("Asset %d", id), "http://asset.com", test.AccountA))
+	}
+	for range expectedAppIDs {
+		txns = append(txns, test.MakeCreateAppTxn(test.AccountA))
+	}
+	for _, id := range expectedAssetIDs {
+		txns = append(txns, test.MakeAssetConfigTxn(0, 100, 0, false, "UNIT",
+			fmt.Sprintf("Asset %d", id), "http://asset.com", test.AccountA))
+	}
+	// delete some apps and assets
+	for _, id := range deletedAppIDs {
+		txns = append(txns, test.MakeAppDestroyTxn(id, test.AccountA))
+	}
+	for _, id := range deletedAssetIDs {
+		txns = append(txns, test.MakeAssetDestroyTxn(id, test.AccountA))
+	}
+
+	// opt in to the remaining ones
+	for _, id := range expectedAppIDs {
+		txns = append(txns, test.MakeAppOptInTxn(id, test.AccountA))
+		txns = append(txns, test.MakeAppOptInTxn(id, test.AccountB))
+	}
+	for _, id := range expectedAssetIDs {
+		txns = append(txns, test.MakeAssetOptInTxn(id, test.AccountA))
+		txns = append(txns, test.MakeAssetOptInTxn(id, test.AccountB))
+	}
+
+	ptxns := make([]*transactions.SignedTxnWithAD, len(txns))
+	for i := range txns {
+		ptxns[i] = &txns[i]
+	}
+	block, err := test.MakeBlockForTxns(test.MakeGenesisBlock().BlockHeader, ptxns...)
+	require.NoError(t, err)
+
+	err = db.AddBlock(&block)
+	require.NoError(t, err, "failed to commit")
+
+	//////////
+	// When // We look up the address using a ServerImplementation with a maxAccountsAPIResults limit set,
+	//      // and addresses with max # apps over & under the limit
+	//////////
+
+	maxResults := 14
+	serverCtx, serverCancel := context.WithCancel(context.Background())
+	defer serverCancel()
+	opts := defaultOpts
+	opts.MaxAPIResourcesPerAccount = uint64(maxResults)
+	listenAddr := "localhost:8989"
+	go Serve(serverCtx, listenAddr, db, nil, logrus.New(), opts)
+
+	// wait at most a few seconds for server to come up
+	serverUp := false
+	for maxWait := 3 * time.Second; !serverUp && maxWait > 0; maxWait -= 50 * time.Millisecond {
+		time.Sleep(50 * time.Millisecond)
+		resp, err := http.Get("http://" + listenAddr + "/health")
+		if err != nil {
+			t.Log("waiting for server:", err)
+			continue
+		}
+		resp.Body.Close()
+		if resp.StatusCode != http.StatusOK {
+			t.Log("waiting for server OK:", resp.StatusCode)
+			continue
+		}
+		serverUp = true // server is up now
+	}
+	require.True(t, serverUp, "api.Serve did not start server in time")
+
+	// make a real HTTP request (to additionally test generated param parsing logic)
+	makeReq := func(t *testing.T, path string, exclude []string, includeDeleted bool, next *string, limit *uint64) (*http.Response, []byte) {
+		var query []string
+		if len(exclude) > 0 {
+			query = append(query, "exclude="+strings.Join(exclude, ","))
+		}
+		if includeDeleted {
+			query = append(query, "include-all=true")
+		}
+		if next != nil {
+			query = append(query, "next="+*next)
+		}
+		if limit != nil {
+			query = append(query, fmt.Sprintf("limit=%d", *limit))
+		}
+		if len(query) > 0 {
+			path += "?" + strings.Join(query, "&")
+		}
+		t.Log("making HTTP request path", path)
+		resp, err := http.Get("http://" + listenAddr + path)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+		body, err := ioutil.ReadAll(resp.Body)
+		require.NoError(t, err)
+		return resp, body
+	}
+
+	//////////
+	// Then // The limit is enforced, leading to a 400 error
+	//////////
+
+	checkExclude := func(t *testing.T, acct generated.Account, exclude []string) {
+		for _, exc := range exclude {
+			switch exc {
+			case "all":
+				assert.Nil(t, acct.CreatedApps)
+				assert.Nil(t, acct.AppsLocalState)
+				assert.Nil(t, acct.CreatedAssets)
+				assert.Nil(t, acct.Assets)
+			case "created-assets":
+				assert.Nil(t, acct.CreatedAssets)
+			case "apps-local-state":
+				assert.Nil(t, acct.AppsLocalState)
+			case "created-apps":
+				assert.Nil(t, acct.CreatedApps)
+			case "assets":
+				assert.Nil(t, acct.Assets)
+			}
+		}
+	}
+
+	testCases := []struct {
+		address        basics.Address
+		exclude        []string
+		includeDeleted bool
+		errStatus      int
+	}{
+		{address: test.AccountA, exclude: []string{"all"}},
+		{address: test.AccountA, exclude: []string{"created-assets", "created-apps", "apps-local-state", "assets"}},
+		{address: test.AccountA, exclude: []string{"assets", "created-apps"}},
+		{address: test.AccountA, exclude: []string{"assets", "apps-local-state"}},
+		{address: test.AccountA, exclude: []string{"assets", "apps-local-state"}, includeDeleted: true, errStatus: http.StatusBadRequest},
+		{address: test.AccountB, exclude: []string{"created-assets", "apps-local-state"}},
+		{address: test.AccountB, exclude: []string{"assets", "apps-local-state"}},
+		{address: test.AccountA, exclude: []string{"created-assets"}, errStatus: http.StatusBadRequest},
+		{address: test.AccountA, exclude: []string{"created-apps"}, errStatus: http.StatusBadRequest},
+		{address: test.AccountA, exclude: []string{"apps-local-state"}, errStatus: http.StatusBadRequest},
+		{address: test.AccountA, exclude: []string{"assets"}, errStatus: http.StatusBadRequest},
+	}
+
+	for _, tc := range testCases {
+		maxResults := 14
+		t.Run(fmt.Sprintf("LookupAccountByID exclude %v", tc.exclude), func(t *testing.T) {
+			path := "/v2/accounts/" + tc.address.String()
+			resp, data := makeReq(t, path, tc.exclude, tc.includeDeleted, nil, nil)
+			if tc.errStatus != 0 { // was a 400 error expected? check error response
+				require.Equal(t, tc.errStatus, resp.StatusCode)
+				var response accountsErrorResponse
+				err = json.Decode(data, &response)
+				require.NoError(t, err)
+				assert.Equal(t, tc.address.String(), *response.Data.Address)
+				assert.Equal(t, uint64(maxResults), *response.Data.MaxResults)
+				if tc.includeDeleted {
+					assert.Equal(t, uint64(10), *response.Data.TotalCreatedApps)
+					assert.Equal(t, uint64(10), *response.Data.TotalCreatedAssets)
+				} else {
+					assert.Equal(t, uint64(5), *response.Data.TotalAppsOptedIn)
+					assert.Equal(t, uint64(5), *response.Data.TotalAssetsOptedIn)
+					assert.Equal(t, uint64(5), *response.Data.TotalCreatedApps)
+					assert.Equal(t, uint64(5), *response.Data.TotalCreatedAssets)
+				}
+				return
+			}
+			require.Equal(t, http.StatusOK, resp.StatusCode, fmt.Sprintf("unexpected return code, body: %s", string(data)))
+			var response generated.AccountResponse
+			err = json.Decode(data, &response)
+			require.NoError(t, err)
+			checkExclude(t, response.Account, tc.exclude)
+		})
+	}
+
+	//////////
+	// When // We search all addresses using a ServerImplementation with a maxAccountsAPIResults limit set,
+	//      // and one of those addresses is over the limit, but another address is not
+	//////////
+
+	for _, tc := range []struct {
+		exclude    []string
+		errStatus  int
+		errAddress basics.Address
+	}{
+		{exclude: []string{"all"}},
+		{exclude: []string{"created-assets", "created-apps", "apps-local-state", "assets"}},
+		{exclude: []string{"assets", "apps-local-state"}},
+		{errAddress: test.AccountA, exclude: nil, errStatus: 400},
+		{errAddress: test.AccountA, exclude: []string{"created-assets"}, errStatus: http.StatusBadRequest},
+		{errAddress: test.AccountA, exclude: []string{"created-apps"}, errStatus: http.StatusBadRequest},
+		{errAddress: test.AccountA, exclude: []string{"apps-local-state"}, errStatus: http.StatusBadRequest},
+		{errAddress: test.AccountA, exclude: []string{"assets"}, errStatus: http.StatusBadRequest},
+	} {
+		t.Run(fmt.Sprintf("SearchForAccounts exclude %v", tc.exclude), func(t *testing.T) {
+			maxResults := 14
+			resp, data := makeReq(t, "/v2/accounts", tc.exclude, false, nil, nil)
+			if tc.errStatus != 0 { // was a 400 error expected? check error response
+				require.Equal(t, tc.errStatus, resp.StatusCode)
+				var response accountsErrorResponse
+				err = json.Decode(data, &response)
+				require.NoError(t, err)
+				require.Equal(t, *response.Data.Address, tc.errAddress.String())
+				require.Equal(t, *response.Data.MaxResults, uint64(maxResults))
+				require.Equal(t, *response.Data.TotalAppsOptedIn, uint64(5))
+				require.Equal(t, *response.Data.TotalCreatedApps, uint64(5))
+				require.Equal(t, *response.Data.TotalAssetsOptedIn, uint64(5))
+				require.Equal(t, *response.Data.TotalCreatedAssets, uint64(5))
+				return
+			}
+			require.Equal(t, http.StatusOK, resp.StatusCode, fmt.Sprintf("unexpected return code, body: %s", string(data)))
+			var response generated.AccountsResponse
+			err = json.Decode(data, &response)
+			require.NoError(t, err)
+
+			// check that the accounts are in there
+			var sawAccountA, sawAccountB bool
+			for _, acct := range response.Accounts {
+				switch acct.Address {
+				case test.AccountA.String():
+					sawAccountA = true
+					require.Equal(t, acct.TotalAppsOptedIn, uint64(5))
+					require.Equal(t, acct.TotalCreatedApps, uint64(5))
+					require.Equal(t, acct.TotalAssetsOptedIn, uint64(5))
+					require.Equal(t, acct.TotalCreatedAssets, uint64(5))
+				case test.AccountB.String():
+					sawAccountB = true
+					require.Equal(t, acct.TotalAppsOptedIn, uint64(5))
+					require.Equal(t, acct.TotalCreatedApps, uint64(0))
+					require.Equal(t, acct.TotalAssetsOptedIn, uint64(5))
+					require.Equal(t, acct.TotalCreatedAssets, uint64(0))
+				}
+				checkExclude(t, acct, tc.exclude)
+			}
+			require.True(t, sawAccountA && sawAccountB)
+		})
+	}
+
+	//////////
+	// When // We look up the assets an account holds, and paginate through them using "Next"
+	//////////
+
+	t.Run("LookupAccountAssets", func(t *testing.T) {
+		var next *string   // nil/unset to start
+		limit := uint64(2) // 2 at a time
+		var assets []generated.AssetHolding
+		for {
+			resp, data := makeReq(t, "/v2/accounts/"+test.AccountB.String()+"/assets", nil, false, next, &limit)
+			require.Equal(t, http.StatusOK, resp.StatusCode, fmt.Sprintf("unexpected return code, body: %s", string(data)))
+			var response generated.AssetHoldingsResponse
+			err = json.Decode(data, &response)
+			require.NoError(t, err)
+			if len(response.Assets) == 0 {
+				require.Nil(t, response.NextToken)
+				break
+			}
+			require.NotEmpty(t, response.Assets)
+			assets = append(assets, response.Assets...)
+			next = response.NextToken // paginate
+		}
+		//////////
+		// Then // We can see all the assets, even though there were more than the limit
+		//////////
+		require.Len(t, assets, 5)
+		for i, asset := range assets {
+			require.Equal(t, expectedAssetIDs[i], asset.AssetId)
+		}
+	})
+
+	//////////
+	// When // We look up the assets an account has created, and paginate through them using "Next"
+	//////////
+
+	t.Run("LookupAccountCreatedAssets", func(t *testing.T) {
+		var next *string   // nil/unset to start
+		limit := uint64(2) // 2 at a time
+		var assets []generated.Asset
+		for {
+			resp, data := makeReq(t, "/v2/accounts/"+test.AccountA.String()+"/created-assets", nil, false, next, &limit)
+			require.Equal(t, http.StatusOK, resp.StatusCode, fmt.Sprintf("unexpected return code, body: %s", string(data)))
+			var response generated.AssetsResponse
+			err = json.Decode(data, &response)
+			require.NoError(t, err)
+			if len(response.Assets) == 0 {
+				require.Nil(t, response.NextToken)
+				break
+			}
+			require.NotEmpty(t, response.Assets)
+			assets = append(assets, response.Assets...)
+			next = response.NextToken // paginate
+		}
+		//////////
+		// Then // We can see all the assets, even though there were more than the limit
+		//////////
+		require.Len(t, assets, 5)
+		for i, asset := range assets {
+			require.Equal(t, expectedAssetIDs[i], asset.Index)
+		}
+	})
+
+	//////////
+	// When // We look up the apps an account has opted in to, and paginate through them using "Next"
+	//////////
+
+	t.Run("LookupAccountAppLocalStates", func(t *testing.T) {
+		var next *string   // nil/unset to start
+		limit := uint64(2) // 2 at a time
+		var apps []generated.ApplicationLocalState
+		for {
+			resp, data := makeReq(t, "/v2/accounts/"+test.AccountA.String()+"/apps-local-state", nil, false, next, &limit)
+			require.Equal(t, http.StatusOK, resp.StatusCode, fmt.Sprintf("unexpected return code, body: %s", string(data)))
+			var response generated.ApplicationLocalStatesResponse
+			err = json.Decode(data, &response)
+			require.NoError(t, err)
+			if len(response.AppsLocalStates) == 0 {
+				require.Nil(t, response.NextToken)
+				break
+			}
+			require.NotEmpty(t, response.AppsLocalStates)
+			apps = append(apps, response.AppsLocalStates...)
+			next = response.NextToken // paginate
+		}
+		//////////
+		// Then // We can see all the apps, even though there were more than the limit
+		//////////
+		require.Len(t, apps, 5)
+		for i, app := range apps {
+			require.Equal(t, expectedAppIDs[i], app.Id)
+		}
+	})
+
+	//////////
+	// When // We look up the apps an account has opted in to, and paginate through them using "Next"
+	//////////
+
+	t.Run("LookupAccountCreatedApplications", func(t *testing.T) {
+		var next *string   // nil/unset to start
+		limit := uint64(2) // 2 at a time
+		var apps []generated.Application
+		for {
+			resp, data := makeReq(t, "/v2/accounts/"+test.AccountA.String()+"/created-applications", nil, false, next, &limit)
+			require.Equal(t, http.StatusOK, resp.StatusCode, fmt.Sprintf("unexpected return code, body: %s", string(data)))
+			var response generated.ApplicationsResponse
+			err = json.Decode(data, &response)
+			require.NoError(t, err)
+			if len(response.Applications) == 0 {
+				require.Nil(t, response.NextToken)
+				break
+			}
+			require.NotEmpty(t, response.Applications)
+			apps = append(apps, response.Applications...)
+			next = response.NextToken // paginate
+		}
+		//////////
+		// Then // We can see all the apps, even though there were more than the limit
+		//////////
+		require.Len(t, apps, 5)
+		for i, app := range apps {
+			require.Equal(t, expectedAppIDs[i], app.Id)
+		}
+	})
 }
 
 func TestBlockNotFound(t *testing.T) {
@@ -132,7 +773,7 @@ func TestBlockNotFound(t *testing.T) {
 	c.SetParamNames("round-number")
 	c.SetParamValues(strconv.Itoa(100))
 
-	api := &ServerImplementation{db: db, timeout: 30 * time.Second}
+	api := testServerImplementation(db)
 	err := api.LookupBlock(c, 100)
 	require.NoError(t, err)
 
@@ -205,7 +846,7 @@ func TestInnerTxn(t *testing.T) {
 			c := e.NewContext(req, rec)
 			c.SetPath("/v2/transactions/")
 
-			api := &ServerImplementation{db: db, timeout: 30 * time.Second}
+			api := testServerImplementation(db)
 			err = api.SearchForTransactions(c, tc.filter)
 			require.NoError(t, err)
 
@@ -214,7 +855,8 @@ func TestInnerTxn(t *testing.T) {
 			//////////
 			require.Equal(t, http.StatusOK, rec.Code)
 			var response generated.TransactionsResponse
-			json.Decode(rec.Body.Bytes(), &response)
+			err = json.Decode(rec.Body.Bytes(), &response)
+			require.NoError(t, err)
 
 			require.Len(t, response.Transactions, 1)
 			require.Equal(t, expectedID, *(response.Transactions[0].Id))
@@ -276,13 +918,14 @@ func TestPagingRootTxnDeduplication(t *testing.T) {
 
 			// Get first page with limit 1.
 			// Address filter causes results to return newest to oldest.
-			api := &ServerImplementation{db: db, timeout: 30 * time.Second}
+			api := testServerImplementation(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)
+			err = json.Decode(rec1.Body.Bytes(), &response)
+			require.NoError(t, err)
 			require.Len(t, response.Transactions, 1)
 			require.Equal(t, expectedID, *(response.Transactions[0].Id))
 			pageOneNextToken := *response.NextToken
@@ -304,7 +947,8 @@ func TestPagingRootTxnDeduplication(t *testing.T) {
 			//////////
 			var response2 generated.TransactionsResponse
 			require.Equal(t, http.StatusOK, rec2.Code)
-			json.Decode(rec2.Body.Bytes(), &response2)
+			err = json.Decode(rec2.Body.Bytes(), &response2)
+			require.NoError(t, err)
 
 			require.Len(t, response2.Transactions, 0)
 			// The fact that NextToken changes indicates that the search results were different.
@@ -327,7 +971,7 @@ func TestPagingRootTxnDeduplication(t *testing.T) {
 
 		// Get first page with limit 1.
 		// Address filter causes results to return newest to oldest.
-		api := &ServerImplementation{db: db, timeout: 30 * time.Second}
+		api := testServerImplementation(db)
 		err = api.LookupBlock(c, uint64(block.Round()))
 		require.NoError(t, err)
 
@@ -336,7 +980,8 @@ func TestPagingRootTxnDeduplication(t *testing.T) {
 		//////////
 		var response generated.BlockResponse
 		require.Equal(t, http.StatusOK, rec.Code)
-		json.Decode(rec.Body.Bytes(), &response)
+		err = json.Decode(rec.Body.Bytes(), &response)
+		require.NoError(t, err)
 
 		require.NotNil(t, response.Transactions)
 		require.Len(t, *response.Transactions, 1)
@@ -442,7 +1087,7 @@ func TestVersion(t *testing.T) {
 	///////////
 	db, shutdownFunc := setupIdb(t, test.MakeGenesis(), test.MakeGenesisBlock())
 	defer shutdownFunc()
-	api := &ServerImplementation{db: db, timeout: 30 * time.Second}
+	api := testServerImplementation(db)
 
 	e := echo.New()
 	req := httptest.NewRequest(http.MethodGet, "/", nil)
@@ -518,7 +1163,7 @@ func TestAccountClearsNonUTF8(t *testing.T) {
 		c := e.NewContext(req, rec)
 		c.SetPath("/v2/assets/")
 
-		api := &ServerImplementation{db: db, timeout: 30 * time.Second}
+		api := testServerImplementation(db)
 		err = api.SearchForAssets(c, generated.SearchForAssetsParams{})
 		require.NoError(t, err)
 
@@ -543,7 +1188,7 @@ func TestAccountClearsNonUTF8(t *testing.T) {
 		c := e.NewContext(req, rec)
 		c.SetPath("/v2/accounts/")
 
-		api := &ServerImplementation{db: db, timeout: 30 * time.Second}
+		api := testServerImplementation(db)
 		err = api.LookupAccountByID(c, test.AccountA.String(), generated.LookupAccountByIDParams{})
 		require.NoError(t, err)
 
@@ -626,7 +1271,7 @@ func TestLookupInnerLogs(t *testing.T) {
 			c.SetParamNames("appIdx")
 			c.SetParamValues(fmt.Sprintf("%d", tc.appID))
 
-			api := &ServerImplementation{db: db, timeout: 30 * time.Second}
+			api := testServerImplementation(db)
 			err = api.LookupApplicationLogsByID(c, tc.appID, params)
 			require.NoError(t, err)
 
diff --git a/api/handlers_test.go b/api/handlers_test.go
index 4d62cd6a6..b1dfdcea7 100644
--- a/api/handlers_test.go
+++ b/api/handlers_test.go
@@ -41,49 +41,49 @@ func TestTransactionParamToTransactionFilter(t *testing.T) {
 		{
 			"Default",
 			generated.SearchForTransactionsParams{},
-			idb.TransactionFilter{Limit: defaultTransactionsLimit},
+			idb.TransactionFilter{Limit: defaultOpts.DefaultTransactionsLimit},
 			nil,
 		},
 		{
 			"Limit",
-			generated.SearchForTransactionsParams{Limit: uint64Ptr(defaultTransactionsLimit + 10)},
-			idb.TransactionFilter{Limit: defaultTransactionsLimit + 10},
+			generated.SearchForTransactionsParams{Limit: uint64Ptr(defaultOpts.DefaultTransactionsLimit + 10)},
+			idb.TransactionFilter{Limit: defaultOpts.DefaultTransactionsLimit + 10},
 			nil,
 		},
 		{
 			"Limit Max",
-			generated.SearchForTransactionsParams{Limit: uint64Ptr(maxTransactionsLimit + 10)},
-			idb.TransactionFilter{Limit: maxTransactionsLimit},
+			generated.SearchForTransactionsParams{Limit: uint64Ptr(defaultOpts.MaxTransactionsLimit + 10)},
+			idb.TransactionFilter{Limit: defaultOpts.MaxTransactionsLimit},
 			nil,
 		},
 		{
 			"Int field",
 			generated.SearchForTransactionsParams{AssetId: uint64Ptr(1234)},
-			idb.TransactionFilter{AssetID: 1234, Limit: defaultTransactionsLimit},
+			idb.TransactionFilter{AssetID: 1234, Limit: defaultOpts.DefaultTransactionsLimit},
 			nil,
 		},
 		{
 			"Pointer field",
 			generated.SearchForTransactionsParams{Round: uint64Ptr(1234)},
-			idb.TransactionFilter{Round: uint64Ptr(1234), Limit: defaultTransactionsLimit},
+			idb.TransactionFilter{Round: uint64Ptr(1234), Limit: defaultOpts.DefaultTransactionsLimit},
 			nil,
 		},
 		{
 			"Base64 field",
 			generated.SearchForTransactionsParams{NotePrefix: strPtr(base64.StdEncoding.EncodeToString([]byte("SomeData")))},
-			idb.TransactionFilter{NotePrefix: []byte("SomeData"), Limit: defaultTransactionsLimit},
+			idb.TransactionFilter{NotePrefix: []byte("SomeData"), Limit: defaultOpts.DefaultTransactionsLimit},
 			nil,
 		},
 		{
 			"Enum fields",
 			generated.SearchForTransactionsParams{TxType: strPtr("pay"), SigType: strPtr("lsig")},
-			idb.TransactionFilter{TypeEnum: 1, SigType: "lsig", Limit: defaultTransactionsLimit},
+			idb.TransactionFilter{TypeEnum: 1, SigType: "lsig", Limit: defaultOpts.DefaultTransactionsLimit},
 			nil,
 		},
 		{
 			"Date time fields",
 			generated.SearchForTransactionsParams{AfterTime: timePtr(time.Date(2020, 3, 4, 12, 0, 0, 0, time.FixedZone("UTC", 0)))},
-			idb.TransactionFilter{AfterTime: time.Date(2020, 3, 4, 12, 0, 0, 0, time.FixedZone("UTC", 0)), Limit: defaultTransactionsLimit},
+			idb.TransactionFilter{AfterTime: time.Date(2020, 3, 4, 12, 0, 0, 0, time.FixedZone("UTC", 0)), Limit: defaultOpts.DefaultTransactionsLimit},
 			nil,
 		},
 		{
@@ -95,7 +95,7 @@ func TestTransactionParamToTransactionFilter(t *testing.T) {
 		{
 			"As many fields as possible",
 			generated.SearchForTransactionsParams{
-				Limit:               uint64Ptr(defaultTransactionsLimit + 1),
+				Limit:               uint64Ptr(defaultOpts.DefaultTransactionsLimit + 1),
 				Next:                strPtr("next-token"),
 				NotePrefix:          strPtr(base64.StdEncoding.EncodeToString([]byte("custom-note"))),
 				TxType:              strPtr("pay"),
@@ -115,7 +115,7 @@ func TestTransactionParamToTransactionFilter(t *testing.T) {
 				ApplicationId:       uint64Ptr(7),
 			},
 			idb.TransactionFilter{
-				Limit:             defaultTransactionsLimit + 1,
+				Limit:             defaultOpts.DefaultTransactionsLimit + 1,
 				NextToken:         "next-token",
 				NotePrefix:        []byte("custom-note"),
 				TypeEnum:          1,
@@ -157,56 +157,57 @@ func TestTransactionParamToTransactionFilter(t *testing.T) {
 		{
 			name:          "Bitmask sender + closeTo(true)",
 			params:        generated.SearchForTransactionsParams{AddressRole: strPtr("sender"), ExcludeCloseTo: boolPtr(true)},
-			filter:        idb.TransactionFilter{AddressRole: 9, Limit: defaultTransactionsLimit},
+			filter:        idb.TransactionFilter{AddressRole: 9, Limit: defaultOpts.DefaultTransactionsLimit},
 			errorContains: nil,
 		},
 		{
 			name:          "Bitmask sender + closeTo(false)",
 			params:        generated.SearchForTransactionsParams{AddressRole: strPtr("sender"), ExcludeCloseTo: boolPtr(false)},
-			filter:        idb.TransactionFilter{AddressRole: 9, Limit: defaultTransactionsLimit},
+			filter:        idb.TransactionFilter{AddressRole: 9, Limit: defaultOpts.DefaultTransactionsLimit},
 			errorContains: nil,
 		},
 		{
 			name:          "Bitmask receiver + closeTo(true)",
 			params:        generated.SearchForTransactionsParams{AddressRole: strPtr("receiver"), ExcludeCloseTo: boolPtr(true)},
-			filter:        idb.TransactionFilter{AddressRole: 18, Limit: defaultTransactionsLimit},
+			filter:        idb.TransactionFilter{AddressRole: 18, Limit: defaultOpts.DefaultTransactionsLimit},
 			errorContains: nil,
 		},
 		{
 			name:          "Bitmask receiver + closeTo(false)",
 			params:        generated.SearchForTransactionsParams{AddressRole: strPtr("receiver"), ExcludeCloseTo: boolPtr(false)},
-			filter:        idb.TransactionFilter{AddressRole: 54, Limit: defaultTransactionsLimit},
+			filter:        idb.TransactionFilter{AddressRole: 54, Limit: defaultOpts.DefaultTransactionsLimit},
 			errorContains: nil,
 		},
 		{
 			name:          "Bitmask receiver + implicit closeTo (false)",
 			params:        generated.SearchForTransactionsParams{AddressRole: strPtr("receiver")},
-			filter:        idb.TransactionFilter{AddressRole: 54, Limit: defaultTransactionsLimit},
+			filter:        idb.TransactionFilter{AddressRole: 54, Limit: defaultOpts.DefaultTransactionsLimit},
 			errorContains: nil,
 		},
 		{
 			name:          "Bitmask freeze-target",
 			params:        generated.SearchForTransactionsParams{AddressRole: strPtr("freeze-target")},
-			filter:        idb.TransactionFilter{AddressRole: 64, Limit: defaultTransactionsLimit},
+			filter:        idb.TransactionFilter{AddressRole: 64, Limit: defaultOpts.DefaultTransactionsLimit},
 			errorContains: nil,
 		},
 		{
 			name:          "Currency to Algos when no asset-id",
 			params:        generated.SearchForTransactionsParams{CurrencyGreaterThan: uint64Ptr(10), CurrencyLessThan: uint64Ptr(20)},
-			filter:        idb.TransactionFilter{AlgosGT: uint64Ptr(10), AlgosLT: uint64Ptr(20), Limit: defaultTransactionsLimit},
+			filter:        idb.TransactionFilter{AlgosGT: uint64Ptr(10), AlgosLT: uint64Ptr(20), Limit: defaultOpts.DefaultTransactionsLimit},
 			errorContains: nil,
 		},
 		{
 			name:          "Searching by application-id",
 			params:        generated.SearchForTransactionsParams{ApplicationId: uint64Ptr(1234)},
-			filter:        idb.TransactionFilter{ApplicationID: 1234, Limit: defaultTransactionsLimit},
+			filter:        idb.TransactionFilter{ApplicationID: 1234, Limit: defaultOpts.DefaultTransactionsLimit},
 			errorContains: nil,
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			filter, err := transactionParamsToTransactionFilter(test.params)
+			si := testServerImplementation(nil)
+			filter, err := si.transactionParamsToTransactionFilter(test.params)
 			if len(test.errorContains) > 0 {
 				require.Error(t, err)
 				for _, msg := range test.errorContains {
@@ -228,7 +229,7 @@ func TestValidateTransactionFilter(t *testing.T) {
 	}{
 		{
 			"Default",
-			idb.TransactionFilter{Limit: defaultTransactionsLimit},
+			idb.TransactionFilter{Limit: defaultOpts.DefaultTransactionsLimit},
 			nil,
 		},
 		{
@@ -540,11 +541,9 @@ func TestFetchTransactions(t *testing.T) {
 			// Setup the mocked responses
 
 			mockIndexer := &mocks.IndexerDb{}
-			si := ServerImplementation{
-				EnableAddressSearchRoundRewind: true,
-				db:                             mockIndexer,
-				timeout:                        1 * time.Second,
-			}
+			si := testServerImplementation(mockIndexer)
+			si.EnableAddressSearchRoundRewind = true
+			si.timeout = 1 * time.Second
 
 			roundTime := time.Now()
 			roundTime64 := uint64(roundTime.Unix())
@@ -627,10 +626,8 @@ func TestFetchAccountsRewindRoundTooLarge(t *testing.T) {
 	db := &mocks.IndexerDb{}
 	db.On("GetAccounts", mock.Anything, mock.Anything).Return(outCh, uint64(7)).Once()
 
-	si := ServerImplementation{
-		EnableAddressSearchRoundRewind: true,
-		db:                             db,
-	}
+	si := testServerImplementation(db)
+	si.EnableAddressSearchRoundRewind = true
 	atRound := uint64(8)
 	_, _, err := si.fetchAccounts(context.Background(), idb.AccountQueryOptions{}, &atRound)
 	assert.Error(t, err)
@@ -680,10 +677,8 @@ func createTxn(t *testing.T, target string) []byte {
 
 func TestLookupApplicationLogsByID(t *testing.T) {
 	mockIndexer := &mocks.IndexerDb{}
-	si := ServerImplementation{
-		EnableAddressSearchRoundRewind: true,
-		db:                             mockIndexer,
-	}
+	si := testServerImplementation(mockIndexer)
+	si.EnableAddressSearchRoundRewind = true
 
 	txnBytes := loadResourceFileOrPanic("test_resources/app_call_logs.txn")
 	var stxn transactions.SignedTxnWithAD
@@ -894,10 +889,8 @@ func TestTimeouts(t *testing.T) {
 			// Make a mock indexer and tell the mock to timeout.
 			mockIndexer := &mocks.IndexerDb{}
 
-			si := ServerImplementation{
-				db:      mockIndexer,
-				timeout: 5 * time.Millisecond,
-			}
+			si := testServerImplementation(mockIndexer)
+			si.timeout = 5 * time.Millisecond
 
 			// Setup context...
 			e := echo.New()
@@ -907,7 +900,7 @@ func TestTimeouts(t *testing.T) {
 
 			// configure the mock to timeout, then call the handler.
 			tc.mockCall(mockIndexer, timeout)
-			err := tc.callHandler(c, si)
+			err := tc.callHandler(c, *si)
 
 			require.NoError(t, err)
 			bodyStr := rec1.Body.String()
@@ -927,21 +920,19 @@ func TestApplicationLimits(t *testing.T) {
 		{
 			name:     "Default",
 			limit:    nil,
-			expected: defaultApplicationsLimit,
+			expected: defaultOpts.DefaultApplicationsLimit,
 		},
 		{
 			name:     "Max",
 			limit:    uint64Ptr(math.MaxUint64),
-			expected: maxApplicationsLimit,
+			expected: defaultOpts.MaxApplicationsLimit,
 		},
 	}
 
 	// Mock backend to capture default limits
 	mockIndexer := &mocks.IndexerDb{}
-	si := ServerImplementation{
-		db:      mockIndexer,
-		timeout: 5 * time.Millisecond,
-	}
+	si := testServerImplementation(mockIndexer)
+	si.timeout = 5 * time.Millisecond
 
 	for _, tc := range testcases {
 		t.Run(tc.name, func(t *testing.T) {
@@ -957,10 +948,9 @@ func TestApplicationLimits(t *testing.T) {
 				Return(nil, uint64(0)).
 				Run(func(args mock.Arguments) {
 					require.Len(t, args, 2)
-					require.IsType(t, &generated.SearchForApplicationsParams{}, args[1])
-					params := args[1].(*generated.SearchForApplicationsParams)
-					require.NotNil(t, params.Limit)
-					require.Equal(t, *params.Limit, tc.expected)
+					require.IsType(t, idb.ApplicationQuery{}, args[1])
+					params := args[1].(idb.ApplicationQuery)
+					require.Equal(t, params.Limit, tc.expected)
 				})
 
 			err := si.SearchForApplications(c, generated.SearchForApplicationsParams{
diff --git a/api/indexer.oas2.json b/api/indexer.oas2.json
index 342da079f..a3c33ff8b 100644
--- a/api/indexer.oas2.json
+++ b/api/indexer.oas2.json
@@ -69,6 +69,9 @@
           {
             "$ref": "#/parameters/include-all"
           },
+          {
+            "$ref": "#/parameters/exclude"
+          },
           {
             "$ref": "#/parameters/currency-less-than"
           },
@@ -120,6 +123,9 @@
           },
           {
             "$ref": "#/parameters/include-all"
+          },
+          {
+            "$ref": "#/parameters/exclude"
           }
         ],
         "responses": {
@@ -138,6 +144,190 @@
         }
       }
     },
+    "/v2/accounts/{account-id}/assets": {
+      "get": {
+        "description": "Lookup an account's asset holdings, optionally for a specific ID.",
+        "consumes": [
+          "application/json"
+        ],
+        "produces": [
+          "application/json"
+        ],
+        "tags": [
+          "lookup"
+        ],
+        "operationId": "lookupAccountAssets",
+        "parameters": [
+          {
+            "$ref": "#/parameters/account-id"
+          },
+          {
+            "$ref": "#/parameters/asset-id"
+          },
+          {
+            "$ref": "#/parameters/include-all"
+          },
+          {
+            "$ref": "#/parameters/limit"
+          },
+          {
+            "$ref": "#/parameters/next"
+          }
+        ],
+        "responses": {
+          "200": {
+            "$ref": "#/responses/AssetHoldingsResponse"
+          },
+          "400": {
+            "$ref": "#/responses/ErrorResponse"
+          },
+          "404": {
+            "$ref": "#/responses/ErrorResponse"
+          },
+          "500": {
+            "$ref": "#/responses/ErrorResponse"
+          }
+        }
+      }
+    },
+    "/v2/accounts/{account-id}/created-assets": {
+      "get": {
+        "description": "Lookup an account's created asset parameters, optionally for a specific ID.",
+        "consumes": [
+          "application/json"
+        ],
+        "produces": [
+          "application/json"
+        ],
+        "tags": [
+          "lookup"
+        ],
+        "operationId": "lookupAccountCreatedAssets",
+        "parameters": [
+          {
+            "$ref": "#/parameters/account-id"
+          },
+          {
+            "$ref": "#/parameters/asset-id"
+          },
+          {
+            "$ref": "#/parameters/include-all"
+          },
+          {
+            "$ref": "#/parameters/limit"
+          },
+          {
+            "$ref": "#/parameters/next"
+          }
+        ],
+        "responses": {
+          "200": {
+            "$ref": "#/responses/AssetsResponse"
+          },
+          "400": {
+            "$ref": "#/responses/ErrorResponse"
+          },
+          "404": {
+            "$ref": "#/responses/ErrorResponse"
+          },
+          "500": {
+            "$ref": "#/responses/ErrorResponse"
+          }
+        }
+      }
+    },
+    "/v2/accounts/{account-id}/apps-local-state": {
+      "get": {
+        "description": "Lookup an account's asset holdings, optionally for a specific ID.",
+        "consumes": [
+          "application/json"
+        ],
+        "produces": [
+          "application/json"
+        ],
+        "tags": [
+          "lookup"
+        ],
+        "operationId": "lookupAccountAppLocalStates",
+        "parameters": [
+          {
+            "$ref": "#/parameters/account-id"
+          },
+          {
+            "$ref": "#/parameters/application-id"
+          },
+          {
+            "$ref": "#/parameters/include-all"
+          },
+          {
+            "$ref": "#/parameters/limit"
+          },
+          {
+            "$ref": "#/parameters/next"
+          }
+        ],
+        "responses": {
+          "200": {
+            "$ref": "#/responses/ApplicationLocalStatesResponse"
+          },
+          "400": {
+            "$ref": "#/responses/ErrorResponse"
+          },
+          "404": {
+            "$ref": "#/responses/ErrorResponse"
+          },
+          "500": {
+            "$ref": "#/responses/ErrorResponse"
+          }
+        }
+      }
+    },
+    "/v2/accounts/{account-id}/created-applications": {
+      "get": {
+        "description": "Lookup an account's created application parameters, optionally for a specific ID.",
+        "consumes": [
+          "application/json"
+        ],
+        "produces": [
+          "application/json"
+        ],
+        "tags": [
+          "lookup"
+        ],
+        "operationId": "lookupAccountCreatedApplications",
+        "parameters": [
+          {
+            "$ref": "#/parameters/account-id"
+          },
+          {
+            "$ref": "#/parameters/application-id"
+          },
+          {
+            "$ref": "#/parameters/include-all"
+          },
+          {
+            "$ref": "#/parameters/limit"
+          },
+          {
+            "$ref": "#/parameters/next"
+          }
+        ],
+        "responses": {
+          "200": {
+            "$ref": "#/responses/ApplicationsResponse"
+          },
+          "400": {
+            "$ref": "#/responses/ErrorResponse"
+          },
+          "404": {
+            "$ref": "#/responses/ErrorResponse"
+          },
+          "500": {
+            "$ref": "#/responses/ErrorResponse"
+          }
+        }
+      }
+    },
     "/v2/accounts/{account-id}/transactions": {
       "get": {
         "description": "Lookup account transactions.",
@@ -231,6 +421,12 @@
           {
             "$ref": "#/parameters/application-id"
           },
+          {
+            "type": "string",
+            "description": "Filter just applications with the given creator address.",
+            "name": "creator",
+            "in": "query"
+          },
           {
             "$ref": "#/parameters/include-all"
           },
@@ -455,9 +651,6 @@
           {
             "$ref": "#/parameters/next"
           },
-          {
-            "$ref": "#/parameters/round"
-          },
           {
             "$ref": "#/parameters/currency-greater-than"
           },
@@ -734,7 +927,11 @@
         "pending-rewards",
         "amount-without-pending-rewards",
         "rewards",
-        "status"
+        "status",
+        "total-apps-opted-in",
+        "total-assets-opted-in",
+        "total-created-apps",
+        "total-created-assets"
       ],
       "properties": {
         "address": {
@@ -817,6 +1014,22 @@
             "lsig"
           ]
         },
+        "total-apps-opted-in": {
+          "description": "The count of all applications that have been opted in, equivalent to the count of application local data (AppLocalState objects) stored in this account.",
+          "type": "integer"
+        },
+        "total-assets-opted-in": {
+          "description": "The count of all assets that have been opted in, equivalent to the count of AssetHolding objects held by this account.",
+          "type": "integer"
+        },
+        "total-created-apps": {
+          "description": "The count of all apps (AppParams objects) created by this account.",
+          "type": "integer"
+        },
+        "total-created-assets": {
+          "description": "The count of all assets (AssetParams objects) created by this account.",
+          "type": "integer"
+        },
         "auth-addr": {
           "description": "\\[spend\\] the address against which signing should be checked. If empty, the address of the current account is used. This field can be updated in any transaction by setting the RekeyTo field.",
           "type": "string",
@@ -1112,7 +1325,6 @@
       "type": "object",
       "required": [
         "asset-id",
-        "creator",
         "amount",
         "is-frozen"
       ],
@@ -1126,10 +1338,6 @@
           "description": "Asset ID of the holding.",
           "type": "integer"
         },
-        "creator": {
-          "description": "Address that created this asset. This is the address where the parameters for this asset can be found, and also the address where unwanted asset units can be sent in the worst case.",
-          "type": "string"
-        },
         "is-frozen": {
           "description": "\\[f\\] whether or not the holding is frozen.",
           "type": "boolean"
@@ -2092,6 +2300,23 @@
       "name": "include-all",
       "in": "query"
     },
+    "exclude": {
+      "description": "Exclude additional items such as asset holdings, application local data stored for this account, asset parameters created by this account, and application parameters created by this account.",
+      "name": "exclude",
+      "in": "query",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": [
+          "all",
+          "assets",
+          "created-assets",
+          "apps-local-state",
+          "created-apps",
+          "none"
+        ]
+      }
+    },
     "limit": {
       "type": "integer",
       "description": "Maximum number of results to return. There could be additional pages even if the limit is not reached.",
@@ -2207,6 +2432,32 @@
         }
       }
     },
+    "AssetHoldingsResponse": {
+      "description": "(empty)",
+      "schema": {
+        "type": "object",
+        "required": [
+          "current-round",
+          "assets"
+        ],
+        "properties": {
+          "current-round": {
+            "description": "Round at which the results were computed.",
+            "type": "integer"
+          },
+          "next-token": {
+            "description": "Used for pagination, when making another request provide this token with the next parameter.",
+            "type": "string"
+          },
+          "assets": {
+            "type": "array",
+            "items": {
+              "$ref": "#/definitions/AssetHolding"
+            }
+          }
+        }
+      }
+    },
     "AccountsResponse": {
       "description": "(empty)",
       "schema": {
@@ -2334,6 +2585,32 @@
         }
       }
     },
+    "ApplicationLocalStatesResponse": {
+      "description": "(empty)",
+      "schema": {
+        "type": "object",
+        "required": [
+          "current-round",
+          "apps-local-states"
+        ],
+        "properties": {
+          "apps-local-states": {
+            "type": "array",
+            "items": {
+              "$ref": "#/definitions/ApplicationLocalState"
+            }
+          },
+          "current-round": {
+            "description": "Round at which the results were computed.",
+            "type": "integer"
+          },
+          "next-token": {
+            "description": "Used for pagination, when making another request provide this token with the next parameter.",
+            "type": "string"
+          }
+        }
+      }
+    },
     "AssetResponse": {
       "description": "(empty)",
       "schema": {
diff --git a/api/indexer.oas3.yml b/api/indexer.oas3.yml
index afb6456dc..4f86e7c9d 100644
--- a/api/indexer.oas3.yml
+++ b/api/indexer.oas3.yml
@@ -97,6 +97,27 @@
           "type": "integer"
         }
       },
+      "exclude": {
+        "description": "Exclude additional items such as asset holdings, application local data stored for this account, asset parameters created by this account, and application parameters created by this account.",
+        "explode": false,
+        "in": "query",
+        "name": "exclude",
+        "schema": {
+          "items": {
+            "enum": [
+              "all",
+              "assets",
+              "created-assets",
+              "apps-local-state",
+              "created-apps",
+              "none"
+            ],
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "style": "form"
+      },
       "exclude-close-to": {
         "description": "Combine with address and address-role parameters to define what type of address to search for. The close to fields are normally treated as a receiver, if you would like to exclude them set this parameter to true.",
         "in": "query",
@@ -281,6 +302,36 @@
         },
         "description": "(empty)"
       },
+      "ApplicationLocalStatesResponse": {
+        "content": {
+          "application/json": {
+            "schema": {
+              "properties": {
+                "apps-local-states": {
+                  "items": {
+                    "$ref": "#/components/schemas/ApplicationLocalState"
+                  },
+                  "type": "array"
+                },
+                "current-round": {
+                  "description": "Round at which the results were computed.",
+                  "type": "integer"
+                },
+                "next-token": {
+                  "description": "Used for pagination, when making another request provide this token with the next parameter.",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "apps-local-states",
+                "current-round"
+              ],
+              "type": "object"
+            }
+          }
+        },
+        "description": "(empty)"
+      },
       "ApplicationLogsResponse": {
         "content": {
           "application/json": {
@@ -397,6 +448,36 @@
         },
         "description": "(empty)"
       },
+      "AssetHoldingsResponse": {
+        "content": {
+          "application/json": {
+            "schema": {
+              "properties": {
+                "assets": {
+                  "items": {
+                    "$ref": "#/components/schemas/AssetHolding"
+                  },
+                  "type": "array"
+                },
+                "current-round": {
+                  "description": "Round at which the results were computed.",
+                  "type": "integer"
+                },
+                "next-token": {
+                  "description": "Used for pagination, when making another request provide this token with the next parameter.",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "assets",
+                "current-round"
+              ],
+              "type": "object"
+            }
+          }
+        },
+        "description": "(empty)"
+      },
       "AssetResponse": {
         "content": {
           "application/json": {
@@ -647,6 +728,22 @@
           "status": {
             "description": "\\[onl\\] delegation status of the account's MicroAlgos\n* Offline - indicates that the associated account is delegated.\n*  Online  - indicates that the associated account used as part of the delegation pool.\n*   NotParticipating - indicates that the associated account is neither a delegator nor a delegate.",
             "type": "string"
+          },
+          "total-apps-opted-in": {
+            "description": "The count of all applications that have been opted in, equivalent to the count of application local data (AppLocalState objects) stored in this account.",
+            "type": "integer"
+          },
+          "total-assets-opted-in": {
+            "description": "The count of all assets that have been opted in, equivalent to the count of AssetHolding objects held by this account.",
+            "type": "integer"
+          },
+          "total-created-apps": {
+            "description": "The count of all apps (AppParams objects) created by this account.",
+            "type": "integer"
+          },
+          "total-created-assets": {
+            "description": "The count of all assets (AssetParams objects) created by this account.",
+            "type": "integer"
           }
         },
         "required": [
@@ -656,7 +753,11 @@
           "pending-rewards",
           "rewards",
           "round",
-          "status"
+          "status",
+          "total-apps-opted-in",
+          "total-assets-opted-in",
+          "total-created-apps",
+          "total-created-assets"
         ],
         "type": "object"
       },
@@ -910,10 +1011,6 @@
             "description": "Asset ID of the holding.",
             "type": "integer"
           },
-          "creator": {
-            "description": "Address that created this asset. This is the address where the parameters for this asset can be found, and also the address where unwanted asset units can be sent in the worst case.",
-            "type": "string"
-          },
           "deleted": {
             "description": "Whether or not the asset holding is currently deleted from its account.",
             "type": "boolean"
@@ -936,7 +1033,6 @@
         "required": [
           "amount",
           "asset-id",
-          "creator",
           "is-frozen"
         ],
         "type": "object"
@@ -1923,6 +2019,27 @@
               "type": "boolean"
             }
           },
+          {
+            "description": "Exclude additional items such as asset holdings, application local data stored for this account, asset parameters created by this account, and application parameters created by this account.",
+            "explode": false,
+            "in": "query",
+            "name": "exclude",
+            "schema": {
+              "items": {
+                "enum": [
+                  "all",
+                  "assets",
+                  "created-assets",
+                  "apps-local-state",
+                  "created-apps",
+                  "none"
+                ],
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "style": "form"
+          },
           {
             "description": "Results should have an amount less than this value. MicroAlgos are the default currency unless an asset-id is provided, in which case the asset will be used.",
             "in": "query",
@@ -2068,6 +2185,27 @@
             "schema": {
               "type": "boolean"
             }
+          },
+          {
+            "description": "Exclude additional items such as asset holdings, application local data stored for this account, asset parameters created by this account, and application parameters created by this account.",
+            "explode": false,
+            "in": "query",
+            "name": "exclude",
+            "schema": {
+              "items": {
+                "enum": [
+                  "all",
+                  "assets",
+                  "created-assets",
+                  "apps-local-state",
+                  "created-apps",
+                  "none"
+                ],
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "style": "form"
           }
         ],
         "responses": {
@@ -2166,159 +2304,51 @@
         ]
       }
     },
-    "/v2/accounts/{account-id}/transactions": {
+    "/v2/accounts/{account-id}/apps-local-state": {
       "get": {
-        "description": "Lookup account transactions.",
-        "operationId": "lookupAccountTransactions",
+        "description": "Lookup an account's asset holdings, optionally for a specific ID.",
+        "operationId": "lookupAccountAppLocalStates",
         "parameters": [
           {
-            "description": "Maximum number of results to return. There could be additional pages even if the limit is not reached.",
-            "in": "query",
-            "name": "limit",
-            "schema": {
-              "type": "integer"
-            }
-          },
-          {
-            "description": "The next page of results. Use the next token provided by the previous results.",
-            "in": "query",
-            "name": "next",
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "description": "Specifies a prefix which must be contained in the note field.",
-            "in": "query",
-            "name": "note-prefix",
-            "schema": {
-              "type": "string",
-              "x-algorand-format": "base64"
-            },
-            "x-algorand-format": "base64"
-          },
-          {
-            "in": "query",
-            "name": "tx-type",
-            "schema": {
-              "enum": [
-                "pay",
-                "keyreg",
-                "acfg",
-                "axfer",
-                "afrz",
-                "appl"
-              ],
-              "type": "string"
-            }
-          },
-          {
-            "description": "SigType filters just results using the specified type of signature:\n* sig - Standard\n* msig - MultiSig\n* lsig - LogicSig",
-            "in": "query",
-            "name": "sig-type",
-            "schema": {
-              "enum": [
-                "sig",
-                "msig",
-                "lsig"
-              ],
-              "type": "string"
-            }
-          },
-          {
-            "description": "Lookup the specific transaction by ID.",
-            "in": "query",
-            "name": "txid",
+            "description": "account string",
+            "in": "path",
+            "name": "account-id",
+            "required": true,
             "schema": {
               "type": "string"
             }
           },
           {
-            "description": "Include results for the specified round.",
-            "in": "query",
-            "name": "round",
-            "schema": {
-              "type": "integer"
-            }
-          },
-          {
-            "description": "Include results at or after the specified min-round.",
-            "in": "query",
-            "name": "min-round",
-            "schema": {
-              "type": "integer"
-            }
-          },
-          {
-            "description": "Include results at or before the specified max-round.",
+            "description": "Application ID",
             "in": "query",
-            "name": "max-round",
+            "name": "application-id",
             "schema": {
               "type": "integer"
             }
           },
           {
-            "description": "Asset ID",
+            "description": "Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.",
             "in": "query",
-            "name": "asset-id",
+            "name": "include-all",
             "schema": {
-              "type": "integer"
+              "type": "boolean"
             }
           },
           {
-            "description": "Include results before the given time. Must be an RFC 3339 formatted string.",
-            "in": "query",
-            "name": "before-time",
-            "schema": {
-              "format": "date-time",
-              "type": "string",
-              "x-algorand-format": "RFC3339 String"
-            },
-            "x-algorand-format": "RFC3339 String"
-          },
-          {
-            "description": "Include results after the given time. Must be an RFC 3339 formatted string.",
-            "in": "query",
-            "name": "after-time",
-            "schema": {
-              "format": "date-time",
-              "type": "string",
-              "x-algorand-format": "RFC3339 String"
-            },
-            "x-algorand-format": "RFC3339 String"
-          },
-          {
-            "description": "Results should have an amount greater than this value. MicroAlgos are the default currency unless an asset-id is provided, in which case the asset will be used.",
+            "description": "Maximum number of results to return. There could be additional pages even if the limit is not reached.",
             "in": "query",
-            "name": "currency-greater-than",
+            "name": "limit",
             "schema": {
               "type": "integer"
             }
           },
           {
-            "description": "Results should have an amount less than this value. MicroAlgos are the default currency unless an asset-id is provided, in which case the asset will be used.",
+            "description": "The next page of results. Use the next token provided by the previous results.",
             "in": "query",
-            "name": "currency-less-than",
-            "schema": {
-              "type": "integer"
-            }
-          },
-          {
-            "description": "account string",
-            "in": "path",
-            "name": "account-id",
-            "required": true,
+            "name": "next",
             "schema": {
               "type": "string"
             }
-          },
-          {
-            "description": "Include results which include the rekey-to field.",
-            "in": "query",
-            "name": "rekey-to",
-            "schema": {
-              "type": "boolean"
-            }
           }
         ],
         "responses": {
@@ -2327,6 +2357,12 @@
               "application/json": {
                 "schema": {
                   "properties": {
+                    "apps-local-states": {
+                      "items": {
+                        "$ref": "#/components/schemas/ApplicationLocalState"
+                      },
+                      "type": "array"
+                    },
                     "current-round": {
                       "description": "Round at which the results were computed.",
                       "type": "integer"
@@ -2334,17 +2370,11 @@
                     "next-token": {
                       "description": "Used for pagination, when making another request provide this token with the next parameter.",
                       "type": "string"
-                    },
-                    "transactions": {
-                      "items": {
-                        "$ref": "#/components/schemas/Transaction"
-                      },
-                      "type": "array"
                     }
                   },
                   "required": [
-                    "current-round",
-                    "transactions"
+                    "apps-local-states",
+                    "current-round"
                   ],
                   "type": "object"
                 }
@@ -2374,7 +2404,7 @@
             },
             "description": "Response for errors"
           },
-          "500": {
+          "404": {
             "content": {
               "application/json": {
                 "schema": {
@@ -2395,24 +2425,740 @@
               }
             },
             "description": "Response for errors"
-          }
-        },
-        "tags": [
-          "lookup"
-        ]
-      }
-    },
-    "/v2/applications": {
-      "get": {
-        "description": "Search for applications",
-        "operationId": "searchForApplications",
-        "parameters": [
-          {
-            "description": "Application ID",
-            "in": "query",
-            "name": "application-id",
-            "schema": {
-              "type": "integer"
+          },
+          "500": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          }
+        },
+        "tags": [
+          "lookup"
+        ]
+      }
+    },
+    "/v2/accounts/{account-id}/assets": {
+      "get": {
+        "description": "Lookup an account's asset holdings, optionally for a specific ID.",
+        "operationId": "lookupAccountAssets",
+        "parameters": [
+          {
+            "description": "account string",
+            "in": "path",
+            "name": "account-id",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "description": "Asset ID",
+            "in": "query",
+            "name": "asset-id",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.",
+            "in": "query",
+            "name": "include-all",
+            "schema": {
+              "type": "boolean"
+            }
+          },
+          {
+            "description": "Maximum number of results to return. There could be additional pages even if the limit is not reached.",
+            "in": "query",
+            "name": "limit",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "The next page of results. Use the next token provided by the previous results.",
+            "in": "query",
+            "name": "next",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "assets": {
+                      "items": {
+                        "$ref": "#/components/schemas/AssetHolding"
+                      },
+                      "type": "array"
+                    },
+                    "current-round": {
+                      "description": "Round at which the results were computed.",
+                      "type": "integer"
+                    },
+                    "next-token": {
+                      "description": "Used for pagination, when making another request provide this token with the next parameter.",
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "assets",
+                    "current-round"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "(empty)"
+          },
+          "400": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          },
+          "404": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          },
+          "500": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          }
+        },
+        "tags": [
+          "lookup"
+        ]
+      }
+    },
+    "/v2/accounts/{account-id}/created-applications": {
+      "get": {
+        "description": "Lookup an account's created application parameters, optionally for a specific ID.",
+        "operationId": "lookupAccountCreatedApplications",
+        "parameters": [
+          {
+            "description": "account string",
+            "in": "path",
+            "name": "account-id",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "description": "Application ID",
+            "in": "query",
+            "name": "application-id",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.",
+            "in": "query",
+            "name": "include-all",
+            "schema": {
+              "type": "boolean"
+            }
+          },
+          {
+            "description": "Maximum number of results to return. There could be additional pages even if the limit is not reached.",
+            "in": "query",
+            "name": "limit",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "The next page of results. Use the next token provided by the previous results.",
+            "in": "query",
+            "name": "next",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "applications": {
+                      "items": {
+                        "$ref": "#/components/schemas/Application"
+                      },
+                      "type": "array"
+                    },
+                    "current-round": {
+                      "description": "Round at which the results were computed.",
+                      "type": "integer"
+                    },
+                    "next-token": {
+                      "description": "Used for pagination, when making another request provide this token with the next parameter.",
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "applications",
+                    "current-round"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "(empty)"
+          },
+          "400": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          },
+          "404": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          },
+          "500": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          }
+        },
+        "tags": [
+          "lookup"
+        ]
+      }
+    },
+    "/v2/accounts/{account-id}/created-assets": {
+      "get": {
+        "description": "Lookup an account's created asset parameters, optionally for a specific ID.",
+        "operationId": "lookupAccountCreatedAssets",
+        "parameters": [
+          {
+            "description": "account string",
+            "in": "path",
+            "name": "account-id",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "description": "Asset ID",
+            "in": "query",
+            "name": "asset-id",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Include all items including closed accounts, deleted applications, destroyed assets, opted-out asset holdings, and closed-out application localstates.",
+            "in": "query",
+            "name": "include-all",
+            "schema": {
+              "type": "boolean"
+            }
+          },
+          {
+            "description": "Maximum number of results to return. There could be additional pages even if the limit is not reached.",
+            "in": "query",
+            "name": "limit",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "The next page of results. Use the next token provided by the previous results.",
+            "in": "query",
+            "name": "next",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "assets": {
+                      "items": {
+                        "$ref": "#/components/schemas/Asset"
+                      },
+                      "type": "array"
+                    },
+                    "current-round": {
+                      "description": "Round at which the results were computed.",
+                      "type": "integer"
+                    },
+                    "next-token": {
+                      "description": "Used for pagination, when making another request provide this token with the next parameter.",
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "assets",
+                    "current-round"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "(empty)"
+          },
+          "400": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          },
+          "404": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          },
+          "500": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          }
+        },
+        "tags": [
+          "lookup"
+        ]
+      }
+    },
+    "/v2/accounts/{account-id}/transactions": {
+      "get": {
+        "description": "Lookup account transactions.",
+        "operationId": "lookupAccountTransactions",
+        "parameters": [
+          {
+            "description": "Maximum number of results to return. There could be additional pages even if the limit is not reached.",
+            "in": "query",
+            "name": "limit",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "The next page of results. Use the next token provided by the previous results.",
+            "in": "query",
+            "name": "next",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "description": "Specifies a prefix which must be contained in the note field.",
+            "in": "query",
+            "name": "note-prefix",
+            "schema": {
+              "type": "string",
+              "x-algorand-format": "base64"
+            },
+            "x-algorand-format": "base64"
+          },
+          {
+            "in": "query",
+            "name": "tx-type",
+            "schema": {
+              "enum": [
+                "pay",
+                "keyreg",
+                "acfg",
+                "axfer",
+                "afrz",
+                "appl"
+              ],
+              "type": "string"
+            }
+          },
+          {
+            "description": "SigType filters just results using the specified type of signature:\n* sig - Standard\n* msig - MultiSig\n* lsig - LogicSig",
+            "in": "query",
+            "name": "sig-type",
+            "schema": {
+              "enum": [
+                "sig",
+                "msig",
+                "lsig"
+              ],
+              "type": "string"
+            }
+          },
+          {
+            "description": "Lookup the specific transaction by ID.",
+            "in": "query",
+            "name": "txid",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "description": "Include results for the specified round.",
+            "in": "query",
+            "name": "round",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Include results at or after the specified min-round.",
+            "in": "query",
+            "name": "min-round",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Include results at or before the specified max-round.",
+            "in": "query",
+            "name": "max-round",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Asset ID",
+            "in": "query",
+            "name": "asset-id",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Include results before the given time. Must be an RFC 3339 formatted string.",
+            "in": "query",
+            "name": "before-time",
+            "schema": {
+              "format": "date-time",
+              "type": "string",
+              "x-algorand-format": "RFC3339 String"
+            },
+            "x-algorand-format": "RFC3339 String"
+          },
+          {
+            "description": "Include results after the given time. Must be an RFC 3339 formatted string.",
+            "in": "query",
+            "name": "after-time",
+            "schema": {
+              "format": "date-time",
+              "type": "string",
+              "x-algorand-format": "RFC3339 String"
+            },
+            "x-algorand-format": "RFC3339 String"
+          },
+          {
+            "description": "Results should have an amount greater than this value. MicroAlgos are the default currency unless an asset-id is provided, in which case the asset will be used.",
+            "in": "query",
+            "name": "currency-greater-than",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Results should have an amount less than this value. MicroAlgos are the default currency unless an asset-id is provided, in which case the asset will be used.",
+            "in": "query",
+            "name": "currency-less-than",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "account string",
+            "in": "path",
+            "name": "account-id",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "description": "Include results which include the rekey-to field.",
+            "in": "query",
+            "name": "rekey-to",
+            "schema": {
+              "type": "boolean"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "current-round": {
+                      "description": "Round at which the results were computed.",
+                      "type": "integer"
+                    },
+                    "next-token": {
+                      "description": "Used for pagination, when making another request provide this token with the next parameter.",
+                      "type": "string"
+                    },
+                    "transactions": {
+                      "items": {
+                        "$ref": "#/components/schemas/Transaction"
+                      },
+                      "type": "array"
+                    }
+                  },
+                  "required": [
+                    "current-round",
+                    "transactions"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "(empty)"
+          },
+          "400": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          },
+          "500": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "data": {
+                      "properties": {},
+                      "type": "object"
+                    },
+                    "message": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "message"
+                  ],
+                  "type": "object"
+                }
+              }
+            },
+            "description": "Response for errors"
+          }
+        },
+        "tags": [
+          "lookup"
+        ]
+      }
+    },
+    "/v2/applications": {
+      "get": {
+        "description": "Search for applications",
+        "operationId": "searchForApplications",
+        "parameters": [
+          {
+            "description": "Application ID",
+            "in": "query",
+            "name": "application-id",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Filter just applications with the given creator address.",
+            "in": "query",
+            "name": "creator",
+            "schema": {
+              "type": "string"
             }
           },
           {
@@ -2989,14 +3735,6 @@
               "type": "string"
             }
           },
-          {
-            "description": "Include results for the specified round.",
-            "in": "query",
-            "name": "round",
-            "schema": {
-              "type": "integer"
-            }
-          },
           {
             "description": "Results should have an amount greater than this value. MicroAlgos are the default currency unless an asset-id is provided, in which case the asset will be used.",
             "in": "query",
diff --git a/api/server.go b/api/server.go
index 74f5616ee..6854eb7a8 100644
--- a/api/server.go
+++ b/api/server.go
@@ -40,6 +40,35 @@ type ExtraOptions struct {
 
 	// DisabledMapConfig is the disabled map configuration that is being used by the server
 	DisabledMapConfig *DisabledMapConfig
+
+	// MaxAPIResourcesPerAccount is the maximum number of combined AppParams, AppLocalState, AssetParams,
+	// and AssetHolding resources per address that can be returned by the /v2/accounts endpoints.
+	// If an address exceeds this number, a 400 error is returned. Zero means unlimited.
+	MaxAPIResourcesPerAccount uint64
+
+	/////////////////////
+	// Limit Constants //
+	/////////////////////
+
+	// Transactions
+	MaxTransactionsLimit     uint64
+	DefaultTransactionsLimit uint64
+
+	// Accounts
+	MaxAccountsLimit     uint64
+	DefaultAccountsLimit uint64
+
+	// Assets
+	MaxAssetsLimit     uint64
+	DefaultAssetsLimit uint64
+
+	// Asset Balances
+	MaxBalancesLimit     uint64
+	DefaultBalancesLimit uint64
+
+	// Applications
+	MaxApplicationsLimit     uint64
+	DefaultApplicationsLimit uint64
 }
 
 func (e ExtraOptions) handlerTimeout() time.Duration {
@@ -98,6 +127,7 @@ func Serve(ctx context.Context, serveAddr string, db idb.IndexerDb, fetcherError
 		timeout:                        options.handlerTimeout(),
 		log:                            log,
 		disabledParams:                 disabledMap,
+		opts:                           options,
 	}
 
 	generated.RegisterHandlers(e, &api, middleware...)
diff --git a/cmd/algorand-indexer/daemon.go b/cmd/algorand-indexer/daemon.go
index c0d63efbd..dba0b3ff5 100644
--- a/cmd/algorand-indexer/daemon.go
+++ b/cmd/algorand-indexer/daemon.go
@@ -24,19 +24,30 @@ import (
 )
 
 var (
-	algodDataDir        string
-	algodAddr           string
-	algodToken          string
-	daemonServerAddr    string
-	noAlgod             bool
-	developerMode       bool
-	allowMigration      bool
-	metricsMode         string
-	tokenString         string
-	writeTimeout        time.Duration
-	readTimeout         time.Duration
-	maxConn             uint32
-	enableAllParameters bool
+	algodDataDir              string
+	algodAddr                 string
+	algodToken                string
+	daemonServerAddr          string
+	noAlgod                   bool
+	developerMode             bool
+	allowMigration            bool
+	metricsMode               string
+	tokenString               string
+	writeTimeout              time.Duration
+	readTimeout               time.Duration
+	maxConn                   uint32
+	maxAPIResourcesPerAccount uint32
+	maxTransactionsLimit      uint32
+	defaultTransactionsLimit  uint32
+	maxAccountsLimit          uint32
+	defaultAccountsLimit      uint32
+	maxAssetsLimit            uint32
+	defaultAssetsLimit        uint32
+	maxBalancesLimit          uint32
+	defaultBalancesLimit      uint32
+	maxApplicationsLimit      uint32
+	defaultApplicationsLimit  uint32
+	enableAllParameters       bool
 )
 
 const paramConfigEnableFlag = false
@@ -168,6 +179,19 @@ func init() {
 		daemonCmd.Flags().MarkHidden("enable-all-parameters")
 	}
 
+	daemonCmd.Flags().Uint32VarP(&maxAPIResourcesPerAccount, "max-api-resources-per-account", "", 0, "set the maximum total number of resources (created assets, created apps, asset holdings, and application local state) per account that will be allowed in REST API lookupAccountByID and searchForAccounts responses before returning a 400 Bad Request. Set zero for no limit (default: unlimited)")
+
+	daemonCmd.Flags().Uint32VarP(&maxTransactionsLimit, "max-transactions-limit", "", 10000, "set the maximum allowed Limit parameter for querying transactions")
+	daemonCmd.Flags().Uint32VarP(&defaultTransactionsLimit, "default-transactions-limit", "", 1000, "set the default Limit parameter for querying transactions, if none is provided")
+	daemonCmd.Flags().Uint32VarP(&maxAccountsLimit, "max-accounts-limit", "", 1000, "set the maximum allowed Limit parameter for querying accounts")
+	daemonCmd.Flags().Uint32VarP(&defaultAccountsLimit, "default-accounts-limit", "", 100, "set the default Limit parameter for querying accounts, if none is provided")
+	daemonCmd.Flags().Uint32VarP(&maxAssetsLimit, "max-assets-limit", "", 1000, "set the maximum allowed Limit parameter for querying assets")
+	daemonCmd.Flags().Uint32VarP(&defaultAssetsLimit, "default-assets-limit", "", 100, "set the default Limit parameter for querying assets, if none is provided")
+	daemonCmd.Flags().Uint32VarP(&maxBalancesLimit, "max-balances-limit", "", 10000, "set the maximum allowed Limit parameter for querying balances")
+	daemonCmd.Flags().Uint32VarP(&defaultBalancesLimit, "default-balances-limit", "", 1000, "set the default Limit parameter for querying balances, if none is provided")
+	daemonCmd.Flags().Uint32VarP(&maxApplicationsLimit, "max-applications-limit", "", 1000, "set the maximum allowed Limit parameter for querying applications")
+	daemonCmd.Flags().Uint32VarP(&defaultApplicationsLimit, "default-applications-limit", "", 100, "set the default Limit parameter for querying applications, if none is provided")
+
 	viper.RegisterAlias("algod", "algod-data-dir")
 	viper.RegisterAlias("algod-net", "algod-address")
 	viper.RegisterAlias("server", "server-address")
@@ -195,6 +219,18 @@ func makeOptions() (options api.ExtraOptions) {
 	options.WriteTimeout = writeTimeout
 	options.ReadTimeout = readTimeout
 
+	options.MaxAPIResourcesPerAccount = uint64(maxAPIResourcesPerAccount)
+	options.MaxTransactionsLimit = uint64(maxTransactionsLimit)
+	options.DefaultTransactionsLimit = uint64(defaultTransactionsLimit)
+	options.MaxAccountsLimit = uint64(maxAccountsLimit)
+	options.DefaultAccountsLimit = uint64(defaultAccountsLimit)
+	options.MaxAssetsLimit = uint64(maxAssetsLimit)
+	options.DefaultAssetsLimit = uint64(defaultAssetsLimit)
+	options.MaxBalancesLimit = uint64(maxBalancesLimit)
+	options.DefaultBalancesLimit = uint64(defaultBalancesLimit)
+	options.MaxApplicationsLimit = uint64(maxApplicationsLimit)
+	options.DefaultApplicationsLimit = uint64(defaultApplicationsLimit)
+
 	if paramConfigEnableFlag {
 		if enableAllParameters {
 			options.DisabledMapConfig = api.MakeDisabledMapConfig()
diff --git a/cmd/block-generator/generator/generate.go b/cmd/block-generator/generator/generate.go
index 6ed7eb4ea..9b221eaa9 100644
--- a/cmd/block-generator/generator/generate.go
+++ b/cmd/block-generator/generator/generate.go
@@ -681,7 +681,6 @@ func (g *generator) WriteAccount(output io.Writer, accountString string) error {
 			assets = append(assets, generated.AssetHolding{
 				Amount:   holding.balance,
 				AssetId:  a.assetID,
-				Creator:  indexToAccount(a.creator).String(),
 				IsFrozen: false,
 			})
 		}
diff --git a/cmd/idbtest/idbtest.go b/cmd/idbtest/idbtest.go
index 1f945342c..465932287 100644
--- a/cmd/idbtest/idbtest.go
+++ b/cmd/idbtest/idbtest.go
@@ -134,7 +134,13 @@ func main() {
 	<-availableCh
 
 	if accounttest {
-		printAccountQuery(db, idb.AccountQueryOptions{IncludeAssetHoldings: true, IncludeAssetParams: true, AlgosGreaterThan: uint64Ptr(10000000000), Limit: 20})
+		printAccountQuery(db, idb.AccountQueryOptions{
+			IncludeAssetHoldings: true,
+			IncludeAssetParams:   true,
+			IncludeAppLocalState: true,
+			IncludeAppParams:     true,
+			AlgosGreaterThan:     uint64Ptr(10000000000),
+			Limit:                20})
 		printAccountQuery(db, idb.AccountQueryOptions{HasAssetID: 312769, Limit: 19})
 	}
 	if assettest {
diff --git a/cmd/import-validator/README.md b/cmd/import-validator/README.md
index 7a9e83000..aaffa31e7 100644
--- a/cmd/import-validator/README.md
+++ b/cmd/import-validator/README.md
@@ -1,14 +1,14 @@
 # Import validation tool
 
 The import validator tool imports blocks into indexer database and algod's
-sqlite database in lockstep and checks that the modified accounts are the same
-in the two databases.
+sqlite database in lockstep and checks that the modified accounts and resources
+are the same in the two databases.
 It lets us detect the first round where an accounting discrepancy occurs
 and it prints out the difference before crashing.
 
 There is a small limitation, however.
-The set of modified accounts is computed using the sqlite database.
-Thus, if indexer's accounting were to modify a superset of those accounts,
+The list of modified address and resources is computed using the sqlite database.
+Thus, if indexer's accounting were to modify a superset of that data,
 this tool would not detect it.
 This, however, should be unlikely.
 
@@ -45,5 +45,5 @@ or one round behind; otherwise, the import validator will fail to start.
 
 Reading and writing to/from the sqlite database is negligible compared to
 importing blocks into the postgres database.
-However, the tool has to read the modified accounts after importing each block.
-Thus, we can expect the import validator to be 1.5 times slower than indexer.
+However, the tool has to read the modified state after importing each block.
+Thus, we can expect the import validator to be about 1.5 times slower than indexer.
diff --git a/cmd/import-validator/core/service.go b/cmd/import-validator/core/service.go
index 27874faf6..66a91afc2 100644
--- a/cmd/import-validator/core/service.go
+++ b/cmd/import-validator/core/service.go
@@ -128,37 +128,91 @@ func openLedger(ledgerPath string, genesis *bookkeeping.Genesis, genesisBlock *b
 	return ledger, nil
 }
 
-func getModifiedAccounts(l *ledger.Ledger, block *bookkeeping.Block) ([]basics.Address, error) {
+func getModifiedState(l *ledger.Ledger, block *bookkeeping.Block) (map[basics.Address]struct{}, map[basics.Address]map[ledger.Creatable]struct{}, error) {
 	eval, err := l.StartEvaluator(block.BlockHeader, len(block.Payset), 0)
 	if err != nil {
-		return nil, fmt.Errorf("changedAccounts() start evaluator err: %w", err)
+		return nil, nil, fmt.Errorf("getModifiedState() start evaluator err: %w", err)
 	}
 
 	paysetgroups, err := block.DecodePaysetGroups()
 	if err != nil {
-		return nil, fmt.Errorf("changedAccounts() decode payset groups err: %w", err)
+		return nil, nil, fmt.Errorf("getModifiedState() decode payset groups err: %w", err)
 	}
 
 	for _, group := range paysetgroups {
 		err = eval.TransactionGroup(group)
 		if err != nil {
-			return nil, fmt.Errorf("changedAccounts() apply transaction group err: %w", err)
+			return nil, nil,
+				fmt.Errorf("getModifiedState() apply transaction group err: %w", err)
 		}
 	}
 
 	vb, err := eval.GenerateBlock()
 	if err != nil {
-		return nil, fmt.Errorf("changedAccounts() generate block err: %w", err)
+		return nil, nil, fmt.Errorf("getModifiedState() generate block err: %w", err)
 	}
 
 	accountDeltas := vb.Delta().Accts
-	return accountDeltas.ModifiedAccounts(), nil
+
+	modifiedAccounts := make(map[basics.Address]struct{})
+	for _, address := range accountDeltas.ModifiedAccounts() {
+		modifiedAccounts[address] = struct{}{}
+	}
+
+	modifiedResources := make(map[basics.Address]map[ledger.Creatable]struct{})
+	for _, r := range accountDeltas.GetAllAssetResources() {
+		c, ok := modifiedResources[r.Addr]
+		if !ok {
+			c = make(map[ledger.Creatable]struct{})
+			modifiedResources[r.Addr] = c
+		}
+		creatable := ledger.Creatable{
+			Index: basics.CreatableIndex(r.Aidx),
+			Type:  basics.AssetCreatable,
+		}
+		c[creatable] = struct{}{}
+	}
+	for _, r := range accountDeltas.GetAllAppResources() {
+		c, ok := modifiedResources[r.Addr]
+		if !ok {
+			c = make(map[ledger.Creatable]struct{})
+			modifiedResources[r.Addr] = c
+		}
+		creatable := ledger.Creatable{
+			Index: basics.CreatableIndex(r.Aidx),
+			Type:  basics.AppCreatable,
+		}
+		c[creatable] = struct{}{}
+	}
+
+	return modifiedAccounts, modifiedResources, nil
+}
+
+func normalizeAccountResource(r ledgercore.AccountResource) ledgercore.AccountResource {
+	if (r.AppParams != nil) && (len(r.AppParams.GlobalState) == 0) {
+		// Make a copy of `AppParams` to avoid modifying ledger's storage.
+		appParams := new(basics.AppParams)
+		*appParams = *r.AppParams
+		appParams.GlobalState = nil
+		r.AppParams = appParams
+	}
+	if (r.AppLocalState != nil) && (len(r.AppLocalState.KeyValue) == 0) {
+		// Make a copy of `AppLocalState` to avoid modifying ledger's storage.
+		appLocalState := new(basics.AppLocalState)
+		*appLocalState = *r.AppLocalState
+		appLocalState.KeyValue = nil
+		r.AppLocalState = appLocalState
+	}
+
+	return r
 }
 
-func checkModifiedAccounts(db *postgres.IndexerDb, l *ledger.Ledger, block *bookkeeping.Block, addresses []basics.Address) error {
-	var accountsIndexer map[basics.Address]basics.AccountData
+func checkModifiedState(db *postgres.IndexerDb, l *ledger.Ledger, block *bookkeeping.Block, addresses map[basics.Address]struct{}, resources map[basics.Address]map[ledger.Creatable]struct{}) error {
+	var accountsIndexer map[basics.Address]ledgercore.AccountData
+	var resourcesIndexer map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource
 	var err0 error
-	var accountsAlgod map[basics.Address]basics.AccountData
+	var accountsAlgod map[basics.Address]ledgercore.AccountData
+	var resourcesAlgod map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource
 	var err1 error
 	var wg sync.WaitGroup
 
@@ -166,64 +220,50 @@ func checkModifiedAccounts(db *postgres.IndexerDb, l *ledger.Ledger, block *book
 	go func() {
 		defer wg.Done()
 
-		accountsIndexer, err0 = db.GetAccountData(addresses)
+		var accounts map[basics.Address]*ledgercore.AccountData
+		accounts, resourcesIndexer, err0 = db.GetAccountState(addresses, resources)
 		if err0 != nil {
-			err0 = fmt.Errorf("checkModifiedAccounts() err0: %w", err0)
+			err0 = fmt.Errorf("checkModifiedState() err0: %w", err0)
 			return
 		}
+
+		accountsIndexer = make(map[basics.Address]ledgercore.AccountData, len(accounts))
+		for address, accountData := range accounts {
+			if accountData == nil {
+				accountsIndexer[address] = ledgercore.AccountData{}
+			} else {
+				accountsIndexer[address] = *accountData
+			}
+		}
 	}()
 
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 
-		accountsAlgod = make(map[basics.Address]basics.AccountData, len(addresses))
-		for _, address := range addresses {
-			var accountData basics.AccountData
-			accountData, _, err1 = l.LookupWithoutRewards(block.Round(), address)
+		accountsAlgod = make(map[basics.Address]ledgercore.AccountData, len(addresses))
+		for address := range addresses {
+			accountsAlgod[address], _, err1 = l.LookupWithoutRewards(block.Round(), address)
 			if err1 != nil {
-				err1 = fmt.Errorf("checkModifiedAccounts() lookup err1: %w", err1)
+				err1 = fmt.Errorf("checkModifiedState() lookup account err1: %w", err1)
 				return
 			}
-
-			// Indexer returns nil for these maps if they are empty. Unfortunately,
-			// in go-algorand it's not well defined, and sometimes ledger returns empty
-			// maps and sometimes nil maps. So we set those maps to nil if they are empty so
-			// that comparison works.
-			if len(accountData.AssetParams) == 0 {
-				accountData.AssetParams = nil
-			}
-			if len(accountData.Assets) == 0 {
-				accountData.Assets = nil
-			}
-
-			if accountData.AppParams != nil {
-				// Make a copy of `AppParams` to avoid modifying ledger's storage.
-				appParams :=
-					make(map[basics.AppIndex]basics.AppParams, len(accountData.AppParams))
-				for index, params := range accountData.AppParams {
-					if len(params.GlobalState) == 0 {
-						params.GlobalState = nil
-					}
-					appParams[index] = params
-				}
-				accountData.AppParams = appParams
-			}
-
-			if accountData.AppLocalStates != nil {
-				// Make a copy of `AppLocalStates` to avoid modifying ledger's storage.
-				appLocalStates :=
-					make(map[basics.AppIndex]basics.AppLocalState, len(accountData.AppLocalStates))
-				for index, state := range accountData.AppLocalStates {
-					if len(state.KeyValue) == 0 {
-						state.KeyValue = nil
-					}
-					appLocalStates[index] = state
+		}
+		resourcesAlgod =
+			make(map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource)
+		for address, creatables := range resources {
+			resourcesForAddress := make(map[ledger.Creatable]ledgercore.AccountResource)
+			resourcesAlgod[address] = resourcesForAddress
+			for creatable := range creatables {
+				var resource ledgercore.AccountResource
+				resource, err1 =
+					l.LookupResource(block.Round(), address, creatable.Index, creatable.Type)
+				if err1 != nil {
+					err1 = fmt.Errorf("checkModifiedState() lookup resource err1: %w", err1)
+					return
 				}
-				accountData.AppLocalStates = appLocalStates
+				resourcesForAddress[creatable] = normalizeAccountResource(resource)
 			}
-
-			accountsAlgod[address] = accountData
 		}
 	}()
 
@@ -238,10 +278,17 @@ func checkModifiedAccounts(db *postgres.IndexerDb, l *ledger.Ledger, block *book
 	if !reflect.DeepEqual(accountsIndexer, accountsAlgod) {
 		diff := util.Diff(accountsAlgod, accountsIndexer)
 		return fmt.Errorf(
-			"checkModifiedAccounts() accounts differ,"+
+			"checkModifiedState() accounts differ,"+
 				"\naccountsIndexer: %+v,\naccountsAlgod: %+v,\ndiff: %s",
 			accountsIndexer, accountsAlgod, diff)
 	}
+	if !reflect.DeepEqual(resourcesIndexer, resourcesAlgod) {
+		diff := util.Diff(resourcesAlgod, resourcesIndexer)
+		return fmt.Errorf(
+			"checkModifiedState() resources differ,"+
+				"\nresourcesIndexer: %+v,\nresourcesAlgod: %+v,\ndiff: %s",
+			resourcesIndexer, resourcesAlgod, diff)
+	}
 
 	return nil
 }
@@ -267,14 +314,15 @@ func catchup(db *postgres.IndexerDb, l *ledger.Ledger, bot fetcher.Fetcher, logg
 	}
 
 	blockHandlerFunc := func(ctx context.Context, block *rpcs.EncodedBlockCert) error {
-		var modifiedAccounts []basics.Address
+		var modifiedAccounts map[basics.Address]struct{}
+		var modifiedResources map[basics.Address]map[ledger.Creatable]struct{}
 		var err0 error
 		var err1 error
 		var wg sync.WaitGroup
 
 		wg.Add(1)
 		go func() {
-			modifiedAccounts, err0 = getModifiedAccounts(l, &block.Block)
+			modifiedAccounts, modifiedResources, err0 = getModifiedState(l, &block.Block)
 			wg.Done()
 		}()
 
@@ -307,7 +355,8 @@ func catchup(db *postgres.IndexerDb, l *ledger.Ledger, bot fetcher.Fetcher, logg
 		}
 		nextRoundLedger++
 
-		return checkModifiedAccounts(db, l, &block.Block, modifiedAccounts)
+		return checkModifiedState(
+			db, l, &block.Block, modifiedAccounts, modifiedResources)
 	}
 	bot.SetBlockHandler(blockHandlerFunc)
 	bot.SetNextRound(nextRoundLedger)
diff --git a/idb/dummy/dummy.go b/idb/dummy/dummy.go
index 29ca96e61..d4cc71980 100644
--- a/idb/dummy/dummy.go
+++ b/idb/dummy/dummy.go
@@ -7,7 +7,6 @@ import (
 	"github.com/algorand/go-algorand/data/transactions"
 	log "github.com/sirupsen/logrus"
 
-	models "github.com/algorand/indexer/api/generated/v2"
 	"github.com/algorand/indexer/idb"
 )
 
@@ -74,7 +73,12 @@ func (db *dummyIndexerDb) AssetBalances(ctx context.Context, abq idb.AssetBalanc
 }
 
 // Applications is part of idb.IndexerDB
-func (db *dummyIndexerDb) Applications(ctx context.Context, filter *models.SearchForApplicationsParams) (<-chan idb.ApplicationRow, uint64) {
+func (db *dummyIndexerDb) Applications(ctx context.Context, filter idb.ApplicationQuery) (<-chan idb.ApplicationRow, uint64) {
+	return nil, 0
+}
+
+// AppLocalState is part of idb.IndexerDB
+func (db *dummyIndexerDb) AppLocalState(ctx context.Context, filter idb.ApplicationQuery) (<-chan idb.AppLocalStateRow, uint64) {
 	return nil, 0
 }
 
diff --git a/idb/idb.go b/idb/idb.go
index fd86382a7..82901ed1c 100644
--- a/idb/idb.go
+++ b/idb/idb.go
@@ -179,7 +179,8 @@ type IndexerDb interface {
 	GetAccounts(ctx context.Context, opts AccountQueryOptions) (<-chan AccountRow, uint64)
 	Assets(ctx context.Context, filter AssetsQuery) (<-chan AssetRow, uint64)
 	AssetBalances(ctx context.Context, abq AssetBalanceQuery) (<-chan AssetBalanceRow, uint64)
-	Applications(ctx context.Context, filter *models.SearchForApplicationsParams) (<-chan ApplicationRow, uint64)
+	Applications(ctx context.Context, filter ApplicationQuery) (<-chan ApplicationRow, uint64)
+	AppLocalState(ctx context.Context, filter ApplicationQuery) (<-chan AppLocalStateRow, uint64)
 
 	Health(ctx context.Context) (status Health, err error)
 }
@@ -259,6 +260,11 @@ type AccountQueryOptions struct {
 
 	IncludeAssetHoldings bool
 	IncludeAssetParams   bool
+	IncludeAppLocalState bool
+	IncludeAppParams     bool
+
+	// MaxResources is the maximum combined number of AppParam, AppLocalState, AssetParam, and AssetHolding objects allowed.
+	MaxResources uint64
 
 	// IncludeDeleted indicated whether to include deleted Assets, Applications, etc within the account.
 	IncludeDeleted bool
@@ -269,7 +275,18 @@ type AccountQueryOptions struct {
 // AccountRow is metadata relating to one account in a account query.
 type AccountRow struct {
 	Account models.Account
-	Error   error
+	Error   error // could be MaxAPIResourcesPerAccountError
+}
+
+// MaxAPIResourcesPerAccountError records the offending address and resource count that exceeded the limit.
+type MaxAPIResourcesPerAccountError struct {
+	Address basics.Address
+
+	TotalAppLocalStates, TotalAppParams, TotalAssets, TotalAssetParams uint64
+}
+
+func (e MaxAPIResourcesPerAccountError) Error() string {
+	return "Max accounts API results limit exceeded"
 }
 
 // AssetsQuery is a parameter object with all of the asset filter options.
@@ -306,9 +323,12 @@ type AssetRow struct {
 
 // AssetBalanceQuery is a parameter object with all of the asset balance filter options.
 type AssetBalanceQuery struct {
-	AssetID  uint64
-	AmountGT *uint64 // only rows > this
-	AmountLT *uint64 // only rows < this
+	AssetID   uint64
+	AssetIDGT uint64
+	AmountGT  *uint64 // only rows > this
+	AmountLT  *uint64 // only rows < this
+
+	Address []byte
 
 	// IncludeDeleted indicated whether to include deleted AssetHoldingss in the results.
 	IncludeDeleted bool
@@ -332,12 +352,27 @@ type AssetBalanceRow struct {
 	Deleted      *bool
 }
 
-// ApplicationRow is metadata relating to one application in an application query.
+// ApplicationRow is metadata and global state (AppParams) relating to one application in an application query.
 type ApplicationRow struct {
 	Application models.Application
 	Error       error
 }
 
+// ApplicationQuery is a parameter object used for query local and global application state.
+type ApplicationQuery struct {
+	Address                  []byte
+	ApplicationID            uint64
+	ApplicationIDGreaterThan uint64
+	IncludeDeleted           bool
+	Limit                    uint64
+}
+
+// AppLocalStateRow is metadata and local state (AppLocalState) relating to one application in an application query.
+type AppLocalStateRow struct {
+	AppLocalState models.ApplicationLocalState
+	Error         error
+}
+
 // IndexerDbOptions are the options common to all indexer backends.
 type IndexerDbOptions struct {
 	ReadOnly bool
diff --git a/idb/mocks/IndexerDb.go b/idb/mocks/IndexerDb.go
index 1a110084a..0de088c21 100644
--- a/idb/mocks/IndexerDb.go
+++ b/idb/mocks/IndexerDb.go
@@ -7,8 +7,6 @@ import (
 
 	bookkeeping "github.com/algorand/go-algorand/data/bookkeeping"
 
-	generated "github.com/algorand/indexer/api/generated/v2"
-
 	idb "github.com/algorand/indexer/idb"
 
 	mock "github.com/stretchr/testify/mock"
@@ -35,12 +33,35 @@ func (_m *IndexerDb) AddBlock(block *bookkeeping.Block) error {
 	return r0
 }
 
+// AppLocalState provides a mock function with given fields: ctx, filter
+func (_m *IndexerDb) AppLocalState(ctx context.Context, filter idb.ApplicationQuery) (<-chan idb.AppLocalStateRow, uint64) {
+	ret := _m.Called(ctx, filter)
+
+	var r0 <-chan idb.AppLocalStateRow
+	if rf, ok := ret.Get(0).(func(context.Context, idb.ApplicationQuery) <-chan idb.AppLocalStateRow); ok {
+		r0 = rf(ctx, filter)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(<-chan idb.AppLocalStateRow)
+		}
+	}
+
+	var r1 uint64
+	if rf, ok := ret.Get(1).(func(context.Context, idb.ApplicationQuery) uint64); ok {
+		r1 = rf(ctx, filter)
+	} else {
+		r1 = ret.Get(1).(uint64)
+	}
+
+	return r0, r1
+}
+
 // Applications provides a mock function with given fields: ctx, filter
-func (_m *IndexerDb) Applications(ctx context.Context, filter *generated.SearchForApplicationsParams) (<-chan idb.ApplicationRow, uint64) {
+func (_m *IndexerDb) Applications(ctx context.Context, filter idb.ApplicationQuery) (<-chan idb.ApplicationRow, uint64) {
 	ret := _m.Called(ctx, filter)
 
 	var r0 <-chan idb.ApplicationRow
-	if rf, ok := ret.Get(0).(func(context.Context, *generated.SearchForApplicationsParams) <-chan idb.ApplicationRow); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, idb.ApplicationQuery) <-chan idb.ApplicationRow); ok {
 		r0 = rf(ctx, filter)
 	} else {
 		if ret.Get(0) != nil {
@@ -49,7 +70,7 @@ func (_m *IndexerDb) Applications(ctx context.Context, filter *generated.SearchF
 	}
 
 	var r1 uint64
-	if rf, ok := ret.Get(1).(func(context.Context, *generated.SearchForApplicationsParams) uint64); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, idb.ApplicationQuery) uint64); ok {
 		r1 = rf(ctx, filter)
 	} else {
 		r1 = ret.Get(1).(uint64)
diff --git a/idb/postgres/internal/encoding/encoding.go b/idb/postgres/internal/encoding/encoding.go
index b792cae86..6f6bf35dd 100644
--- a/idb/postgres/internal/encoding/encoding.go
+++ b/idb/postgres/internal/encoding/encoding.go
@@ -366,20 +366,6 @@ func DecodeSignedTxnWithAD(data []byte) (transactions.SignedTxnWithAD, error) {
 	return unconvertSignedTxnWithAD(stxn), nil
 }
 
-// TrimAccountData deletes various information from account data that we do not write to
-// `account.account_data`.
-func TrimAccountData(ad basics.AccountData) basics.AccountData {
-	ad.MicroAlgos = basics.MicroAlgos{}
-	ad.RewardsBase = 0
-	ad.RewardedMicroAlgos = basics.MicroAlgos{}
-	ad.AssetParams = nil
-	ad.Assets = nil
-	ad.AppLocalStates = nil
-	ad.AppParams = nil
-
-	return ad
-}
-
 func convertTrimmedAccountData(ad basics.AccountData) trimmedAccountData {
 	return trimmedAccountData{
 		AccountData:      ad,
@@ -683,3 +669,72 @@ func DecodeNetworkState(data []byte) (types.NetworkState, error) {
 
 	return state, nil
 }
+
+// TrimLcAccountData deletes various information from account data that we do not write
+// to `account.account_data`.
+func TrimLcAccountData(ad ledgercore.AccountData) ledgercore.AccountData {
+	ad.MicroAlgos = basics.MicroAlgos{}
+	ad.RewardsBase = 0
+	ad.RewardedMicroAlgos = basics.MicroAlgos{}
+	return ad
+}
+
+func convertTrimmedLcAccountData(ad ledgercore.AccountData) baseAccountData {
+	return baseAccountData{
+		Status:              ad.Status,
+		AuthAddr:            crypto.Digest(ad.AuthAddr),
+		TotalAppSchema:      ad.TotalAppSchema,
+		TotalExtraAppPages:  ad.TotalExtraAppPages,
+		TotalAssetParams:    ad.TotalAssetParams,
+		TotalAssets:         ad.TotalAssets,
+		TotalAppParams:      ad.TotalAppParams,
+		TotalAppLocalStates: ad.TotalAppLocalStates,
+		baseOnlineAccountData: baseOnlineAccountData{
+			VoteID:          ad.VoteID,
+			SelectionID:     ad.SelectionID,
+			StateProofID:    ad.StateProofID,
+			VoteFirstValid:  ad.VoteFirstValid,
+			VoteLastValid:   ad.VoteLastValid,
+			VoteKeyDilution: ad.VoteKeyDilution,
+		},
+	}
+}
+
+func unconvertTrimmedLcAccountData(ba baseAccountData) ledgercore.AccountData {
+	return ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			Status:              ba.Status,
+			AuthAddr:            basics.Address(ba.AuthAddr),
+			TotalAppSchema:      ba.TotalAppSchema,
+			TotalExtraAppPages:  ba.TotalExtraAppPages,
+			TotalAppParams:      ba.TotalAppParams,
+			TotalAppLocalStates: ba.TotalAppLocalStates,
+			TotalAssetParams:    ba.TotalAssetParams,
+			TotalAssets:         ba.TotalAssets,
+		},
+		VotingData: ledgercore.VotingData{
+			VoteID:          ba.VoteID,
+			SelectionID:     ba.SelectionID,
+			StateProofID:    ba.StateProofID,
+			VoteFirstValid:  ba.VoteFirstValid,
+			VoteLastValid:   ba.VoteLastValid,
+			VoteKeyDilution: ba.VoteKeyDilution,
+		},
+	}
+}
+
+// EncodeTrimmedLcAccountData encodes ledgercore account data into json.
+func EncodeTrimmedLcAccountData(ad ledgercore.AccountData) []byte {
+	return encodeJSON(convertTrimmedLcAccountData(ad))
+}
+
+// DecodeTrimmedLcAccountData decodes ledgercore account data from json.
+func DecodeTrimmedLcAccountData(data []byte) (ledgercore.AccountData, error) {
+	var ba baseAccountData
+	err := DecodeJSON(data, &ba)
+	if err != nil {
+		return ledgercore.AccountData{}, err
+	}
+
+	return unconvertTrimmedLcAccountData(ba), nil
+}
diff --git a/idb/postgres/internal/encoding/encoding_test.go b/idb/postgres/internal/encoding/encoding_test.go
index e02062861..0a3816e85 100644
--- a/idb/postgres/internal/encoding/encoding_test.go
+++ b/idb/postgres/internal/encoding/encoding_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/algorand/go-algorand/crypto"
+	"github.com/algorand/go-algorand/crypto/merklesignature"
 	"github.com/algorand/go-algorand/data/basics"
 	"github.com/algorand/go-algorand/data/bookkeeping"
 	"github.com/algorand/go-algorand/data/transactions"
@@ -465,20 +466,21 @@ func TestSpecialAddressesEncoding(t *testing.T) {
 // Test that encoding of AccountTotals is as expected and that decoding results in the
 // same object.
 func TestAccountTotalsEncoding(t *testing.T) {
+	random := rand.New(rand.NewSource(1))
 	totals := ledgercore.AccountTotals{
 		Online: ledgercore.AlgoCount{
-			Money:       basics.MicroAlgos{Raw: rand.Uint64()},
-			RewardUnits: rand.Uint64(),
+			Money:       basics.MicroAlgos{Raw: random.Uint64()},
+			RewardUnits: random.Uint64(),
 		},
 		Offline: ledgercore.AlgoCount{
-			Money:       basics.MicroAlgos{Raw: rand.Uint64()},
-			RewardUnits: rand.Uint64(),
+			Money:       basics.MicroAlgos{Raw: random.Uint64()},
+			RewardUnits: random.Uint64(),
 		},
 		NotParticipating: ledgercore.AlgoCount{
-			Money:       basics.MicroAlgos{Raw: rand.Uint64()},
-			RewardUnits: rand.Uint64(),
+			Money:       basics.MicroAlgos{Raw: random.Uint64()},
+			RewardUnits: random.Uint64(),
 		},
-		RewardsLevel: rand.Uint64(),
+		RewardsLevel: random.Uint64(),
 	}
 
 	buf := EncodeAccountTotals(&totals)
@@ -549,3 +551,51 @@ func TestNetworkStateEncoding(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, network, decodedNetwork)
 }
+
+// Test that encoding of ledgercore.AccountData is as expected and that decoding
+// results in the same object.
+func TestLcAccountDataEncoding(t *testing.T) {
+	var authAddr basics.Address
+	authAddr[0] = 6
+
+	var voteID crypto.OneTimeSignatureVerifier
+	voteID[0] = 14
+
+	var selectionID crypto.VRFVerifier
+	selectionID[0] = 15
+
+	var stateProofID merklesignature.Verifier
+	stateProofID[0] = 19
+
+	ad := ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			Status:   basics.Online,
+			AuthAddr: authAddr,
+			TotalAppSchema: basics.StateSchema{
+				NumUint:      7,
+				NumByteSlice: 8,
+			},
+			TotalExtraAppPages:  9,
+			TotalAppParams:      10,
+			TotalAppLocalStates: 11,
+			TotalAssetParams:    12,
+			TotalAssets:         13,
+		},
+		VotingData: ledgercore.VotingData{
+			VoteID:          voteID,
+			SelectionID:     selectionID,
+			StateProofID:    stateProofID,
+			VoteFirstValid:  16,
+			VoteLastValid:   17,
+			VoteKeyDilution: 18,
+		},
+	}
+	buf := EncodeTrimmedLcAccountData(ad)
+
+	expectedString := `{"onl":1,"sel":"DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=","spend":"BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=","stprf":"EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==","tapl":11,"tapp":10,"tas":13,"tasp":12,"teap":9,"tsch":{"nbs":8,"nui":7},"vote":"DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=","voteFst":16,"voteKD":18,"voteLst":17}`
+	assert.Equal(t, expectedString, string(buf))
+
+	decodedAd, err := DecodeTrimmedLcAccountData(buf)
+	require.NoError(t, err)
+	assert.Equal(t, ad, decodedAd)
+}
diff --git a/idb/postgres/internal/encoding/types.go b/idb/postgres/internal/encoding/types.go
index d2e4c8987..259be6aac 100644
--- a/idb/postgres/internal/encoding/types.go
+++ b/idb/postgres/internal/encoding/types.go
@@ -2,6 +2,7 @@ package encoding
 
 import (
 	"github.com/algorand/go-algorand/crypto"
+	"github.com/algorand/go-algorand/crypto/merklesignature"
 	"github.com/algorand/go-algorand/data/basics"
 	"github.com/algorand/go-algorand/data/bookkeeping"
 	"github.com/algorand/go-algorand/data/transactions"
@@ -106,3 +107,29 @@ type specialAddresses struct {
 	FeeSinkOverride     crypto.Digest `codec:"FeeSink"`
 	RewardsPoolOverride crypto.Digest `codec:"RewardsPool"`
 }
+
+type baseOnlineAccountData struct {
+	_struct struct{} `codec:",omitempty,omitemptyarray"`
+
+	VoteID          crypto.OneTimeSignatureVerifier `codec:"vote"`
+	SelectionID     crypto.VRFVerifier              `codec:"sel"`
+	StateProofID    merklesignature.Verifier        `codec:"stprf"`
+	VoteFirstValid  basics.Round                    `codec:"voteFst"`
+	VoteLastValid   basics.Round                    `codec:"voteLst"`
+	VoteKeyDilution uint64                          `codec:"voteKD"`
+}
+
+type baseAccountData struct {
+	_struct struct{} `codec:",omitempty,omitemptyarray"`
+
+	Status              basics.Status      `codec:"onl"`
+	AuthAddr            crypto.Digest      `codec:"spend"`
+	TotalAppSchema      basics.StateSchema `codec:"tsch"`
+	TotalExtraAppPages  uint32             `codec:"teap"`
+	TotalAssetParams    uint64             `codec:"tasp"`
+	TotalAssets         uint64             `codec:"tas"`
+	TotalAppParams      uint64             `codec:"tapp"`
+	TotalAppLocalStates uint64             `codec:"tapl"`
+
+	baseOnlineAccountData
+}
diff --git a/idb/postgres/internal/ledger_for_evaluator/ledger_for_evaluator.go b/idb/postgres/internal/ledger_for_evaluator/ledger_for_evaluator.go
index 005f27bc8..fbd275dd6 100644
--- a/idb/postgres/internal/ledger_for_evaluator/ledger_for_evaluator.go
+++ b/idb/postgres/internal/ledger_for_evaluator/ledger_for_evaluator.go
@@ -15,15 +15,15 @@ import (
 )
 
 const (
-	blockHeaderStmtName    = "block_header"
-	assetCreatorStmtName   = "asset_creator"
-	appCreatorStmtName     = "app_creator"
-	accountStmtName        = "account"
-	assetHoldingsStmtName  = "asset_holdings"
-	assetParamsStmtName    = "asset_params"
-	appParamsStmtName      = "app_params"
-	appLocalStatesStmtName = "app_local_states"
-	accountTotalsStmtName  = "account_totals"
+	blockHeaderStmtName   = "block_header"
+	assetCreatorStmtName  = "asset_creator"
+	appCreatorStmtName    = "app_creator"
+	accountStmtName       = "account"
+	assetHoldingStmtName  = "asset_holding"
+	assetParamsStmtName   = "asset_params"
+	appParamsStmtName     = "app_params"
+	appLocalStateStmtName = "app_local_state"
+	accountTotalsStmtName = "account_totals"
 )
 
 var statements = map[string]string{
@@ -33,13 +33,13 @@ var statements = map[string]string{
 	appCreatorStmtName: "SELECT creator FROM app WHERE index = $1 AND NOT deleted",
 	accountStmtName: "SELECT microalgos, rewardsbase, rewards_total, account_data " +
 		"FROM account WHERE addr = $1 AND NOT deleted",
-	assetHoldingsStmtName: "SELECT assetid, amount, frozen FROM account_asset " +
-		"WHERE addr = $1 AND NOT deleted",
-	assetParamsStmtName: "SELECT index, params FROM asset " +
-		"WHERE creator_addr = $1 AND NOT deleted",
-	appParamsStmtName: "SELECT index, params FROM app WHERE creator = $1 AND NOT deleted",
-	appLocalStatesStmtName: "SELECT app, localstate FROM account_app " +
-		"WHERE addr = $1 AND NOT deleted",
+	assetHoldingStmtName: "SELECT amount, frozen FROM account_asset " +
+		"WHERE addr = $1 AND assetid = $2 AND NOT deleted",
+	assetParamsStmtName: "SELECT creator_addr, params FROM asset " +
+		"WHERE index = $1 AND NOT deleted",
+	appParamsStmtName: "SELECT creator, params FROM app WHERE index = $1 AND NOT deleted",
+	appLocalStateStmtName: "SELECT localstate FROM account_app " +
+		"WHERE addr = $1 AND app = $2 AND NOT deleted",
 	accountTotalsStmtName: `SELECT v FROM metastate WHERE k = '` +
 		schema.AccountTotals + `'`,
 }
@@ -94,7 +94,7 @@ func (l LedgerForEvaluator) LatestBlockHdr() (bookkeeping.BlockHeader, error) {
 	return res, nil
 }
 
-func (l *LedgerForEvaluator) parseAccountTable(row pgx.Row) (basics.AccountData, bool /*exists*/, error) {
+func (l *LedgerForEvaluator) parseAccountTable(row pgx.Row) (ledgercore.AccountData, bool /*exists*/, error) {
 	var microalgos uint64
 	var rewardsbase uint64
 	var rewardsTotal uint64
@@ -102,17 +102,17 @@ func (l *LedgerForEvaluator) parseAccountTable(row pgx.Row) (basics.AccountData,
 
 	err := row.Scan(&microalgos, &rewardsbase, &rewardsTotal, &accountData)
 	if err == pgx.ErrNoRows {
-		return basics.AccountData{}, false, nil
+		return ledgercore.AccountData{}, false, nil
 	}
 	if err != nil {
-		return basics.AccountData{}, false, fmt.Errorf("parseAccountTable() scan row err: %w", err)
+		return ledgercore.AccountData{}, false, fmt.Errorf("parseAccountTable() scan row err: %w", err)
 	}
 
-	res := basics.AccountData{}
+	var res ledgercore.AccountData
 	if accountData != nil {
-		res, err = encoding.DecodeTrimmedAccountData(accountData)
+		res, err = encoding.DecodeTrimmedLcAccountData(accountData)
 		if err != nil {
-			return basics.AccountData{}, false,
+			return ledgercore.AccountData{}, false,
 				fmt.Errorf("parseAccountTable() decode account data err: %w", err)
 		}
 	}
@@ -124,258 +124,300 @@ func (l *LedgerForEvaluator) parseAccountTable(row pgx.Row) (basics.AccountData,
 	return res, true, nil
 }
 
-func (l *LedgerForEvaluator) parseAccountAssetTable(rows pgx.Rows) (map[basics.AssetIndex]basics.AssetHolding, error) {
-	defer rows.Close()
-	var res map[basics.AssetIndex]basics.AssetHolding
-
-	var assetid uint64
-	var amount uint64
-	var frozen bool
-
-	for rows.Next() {
-		err := rows.Scan(&assetid, &amount, &frozen)
-		if err != nil {
-			return nil, fmt.Errorf("parseAccountAssetTable() scan row err: %w", err)
-		}
-
-		if res == nil {
-			res = make(map[basics.AssetIndex]basics.AssetHolding)
-		}
-		res[basics.AssetIndex(assetid)] = basics.AssetHolding{
-			Amount: amount,
-			Frozen: frozen,
-		}
+// LookupWithoutRewards is part of go-algorand's indexerLedgerForEval interface.
+func (l LedgerForEvaluator) LookupWithoutRewards(addresses map[basics.Address]struct{}) (map[basics.Address]*ledgercore.AccountData, error) {
+	addressesArr := make([]basics.Address, 0, len(addresses))
+	for address := range addresses {
+		addressesArr = append(addressesArr, address)
 	}
 
-	err := rows.Err()
-	if err != nil {
-		return nil, fmt.Errorf("parseAccountAssetTable() scan end err: %w", err)
+	var batch pgx.Batch
+	for i := range addressesArr {
+		batch.Queue(accountStmtName, addressesArr[i][:])
 	}
 
-	return res, nil
-}
+	results := l.tx.SendBatch(context.Background(), &batch)
+	defer results.Close()
 
-func (l *LedgerForEvaluator) parseAssetTable(rows pgx.Rows) (map[basics.AssetIndex]basics.AssetParams, error) {
-	defer rows.Close()
-	var res map[basics.AssetIndex]basics.AssetParams
+	res := make(map[basics.Address]*ledgercore.AccountData, len(addresses))
+	for _, address := range addressesArr {
+		row := results.QueryRow()
 
-	var index uint64
-	var params []byte
+		lcAccountData := new(ledgercore.AccountData)
+		var exists bool
+		var err error
 
-	for rows.Next() {
-		err := rows.Scan(&index, &params)
+		*lcAccountData, exists, err = l.parseAccountTable(row)
 		if err != nil {
-			return nil, fmt.Errorf("parseAssetTable() scan row err: %w", err)
+			return nil, fmt.Errorf("LookupWithoutRewards() err: %w", err)
 		}
 
-		if res == nil {
-			res = make(map[basics.AssetIndex]basics.AssetParams)
-		}
-		res[basics.AssetIndex(index)], err = encoding.DecodeAssetParams(params)
-		if err != nil {
-			return nil, fmt.Errorf("parseAssetTable() decode params err: %w", err)
+		if exists {
+			res[address] = lcAccountData
+		} else {
+			res[address] = nil
 		}
 	}
 
-	err := rows.Err()
+	err := results.Close()
 	if err != nil {
-		return nil, fmt.Errorf("parseAssetTable() scan end err: %w", err)
+		return nil, fmt.Errorf("LookupWithoutRewards() close results err: %w", err)
 	}
 
 	return res, nil
 }
 
-func (l *LedgerForEvaluator) parseAppTable(rows pgx.Rows) (map[basics.AppIndex]basics.AppParams, error) {
-	defer rows.Close()
-	var res map[basics.AppIndex]basics.AppParams
-
-	var index uint64
-	var params []byte
-
-	for rows.Next() {
-		err := rows.Scan(&index, &params)
-		if err != nil {
-			return nil, fmt.Errorf("parseAppTable() scan row err: %w", err)
-		}
+func (l *LedgerForEvaluator) parseAccountAssetTable(row pgx.Row) (basics.AssetHolding, bool /*exists*/, error) {
+	var amount uint64
+	var frozen bool
 
-		if res == nil {
-			res = make(map[basics.AppIndex]basics.AppParams)
-		}
-		res[basics.AppIndex(index)], err = encoding.DecodeAppParams(params)
-		if err != nil {
-			return nil, fmt.Errorf("parseAppTable() decode params err: %w", err)
-		}
+	err := row.Scan(&amount, &frozen)
+	if err == pgx.ErrNoRows {
+		return basics.AssetHolding{}, false, nil
 	}
-
-	err := rows.Err()
 	if err != nil {
-		return nil, fmt.Errorf("parseAppTable() scan end err: %w", err)
+		return basics.AssetHolding{}, false,
+			fmt.Errorf("parseAccountAssetTable() scan row err: %w", err)
 	}
 
-	return res, nil
+	assetHolding := basics.AssetHolding{
+		Amount: amount,
+		Frozen: frozen,
+	}
+	return assetHolding, true, nil
 }
 
-func (l *LedgerForEvaluator) parseAccountAppTable(rows pgx.Rows) (map[basics.AppIndex]basics.AppLocalState, error) {
-	defer rows.Close()
-	var res map[basics.AppIndex]basics.AppLocalState
-
-	var app uint64
-	var localstate []byte
-
-	for rows.Next() {
-		err := rows.Scan(&app, &localstate)
-		if err != nil {
-			return nil, fmt.Errorf("parseAccountAppTable() scan row err: %w", err)
-		}
+func (l *LedgerForEvaluator) parseAssetTable(row pgx.Row) (basics.Address /*creator*/, basics.AssetParams, bool /*exists*/, error) {
+	var creatorAddr []byte
+	var params []byte
 
-		if res == nil {
-			res = make(map[basics.AppIndex]basics.AppLocalState)
-		}
-		res[basics.AppIndex(app)], err = encoding.DecodeAppLocalState(localstate)
-		if err != nil {
-			return nil, fmt.Errorf("parseAccountAppTable() decode local state err: %w", err)
-		}
+	err := row.Scan(&creatorAddr, &params)
+	if err == pgx.ErrNoRows {
+		return basics.Address{}, basics.AssetParams{}, false, nil
 	}
+	if err != nil {
+		return basics.Address{}, basics.AssetParams{}, false,
+			fmt.Errorf("parseAssetTable() scan row err: %w", err)
+	}
+
+	var creator basics.Address
+	copy(creator[:], creatorAddr)
 
-	err := rows.Err()
+	assetParams, err := encoding.DecodeAssetParams(params)
 	if err != nil {
-		return nil, fmt.Errorf("parseAccountAppTable() scan end err: %w", err)
+		return basics.Address{}, basics.AssetParams{}, false,
+			fmt.Errorf("parseAssetTable() decode params err: %w", err)
 	}
 
-	return res, nil
+	return creator, assetParams, true, nil
 }
 
-// Load rows from the account table for the given addresses except the special accounts.
-// nil is stored for those accounts that were not found. Uses batching.
-func (l *LedgerForEvaluator) loadAccountTable(addresses map[basics.Address]struct{}) (map[basics.Address]*basics.AccountData, error) {
-	addressesArr := make([]basics.Address, 0, len(addresses))
-	for address := range addresses {
-		addressesArr = append(addressesArr, address)
-	}
+func (l *LedgerForEvaluator) parseAppTable(row pgx.Row) (basics.Address /*creator*/, basics.AppParams, bool /*exists*/, error) {
+	var creatorAddr []byte
+	var params []byte
 
-	var batch pgx.Batch
-	for i := range addressesArr {
-		batch.Queue(accountStmtName, addressesArr[i][:])
+	err := row.Scan(&creatorAddr, &params)
+	if err == pgx.ErrNoRows {
+		return basics.Address{}, basics.AppParams{}, false, nil
+	}
+	if err != nil {
+		return basics.Address{}, basics.AppParams{}, false,
+			fmt.Errorf("parseAppTable() scan row err: %w", err)
 	}
 
-	results := l.tx.SendBatch(context.Background(), &batch)
-	defer results.Close()
+	var creator basics.Address
+	copy(creator[:], creatorAddr)
 
-	res := make(map[basics.Address]*basics.AccountData, len(addresses))
-	for _, address := range addressesArr {
-		row := results.QueryRow()
+	appParams, err := encoding.DecodeAppParams(params)
+	if err != nil {
+		return basics.Address{}, basics.AppParams{}, false,
+			fmt.Errorf("parseAppTable() decode params err: %w", err)
+	}
 
-		accountData := new(basics.AccountData)
-		var exists bool
-		var err error
+	return creator, appParams, true, nil
+}
 
-		*accountData, exists, err = l.parseAccountTable(row)
-		if err != nil {
-			return nil, fmt.Errorf("loadAccountTable() err: %w", err)
-		}
+func (l *LedgerForEvaluator) parseAccountAppTable(row pgx.Row) (basics.AppLocalState, bool /*exists*/, error) {
+	var localstate []byte
 
-		if exists {
-			res[address] = accountData
-		} else {
-			res[address] = nil
-		}
+	err := row.Scan(&localstate)
+	if err == pgx.ErrNoRows {
+		return basics.AppLocalState{}, false, nil
+	}
+	if err != nil {
+		return basics.AppLocalState{}, false,
+			fmt.Errorf("parseAccountAppTable() scan row err: %w", err)
 	}
 
-	err := results.Close()
+	appLocalState, err := encoding.DecodeAppLocalState(localstate)
 	if err != nil {
-		return nil, fmt.Errorf("loadAccountTable() close results err: %w", err)
+		return basics.AppLocalState{}, false,
+			fmt.Errorf("parseAccountAppTable() decode local state err: %w", err)
 	}
 
-	return res, nil
+	return appLocalState, true, nil
 }
 
-// Load all creatables for the non-nil account data from the provided map into that
-// account data. Uses batching.
-func (l *LedgerForEvaluator) loadCreatables(accountDataMap *map[basics.Address]*basics.AccountData) error {
-	var batch pgx.Batch
-
-	existingAddresses := make([]basics.Address, 0, len(*accountDataMap))
-	for address, accountData := range *accountDataMap {
-		if accountData != nil {
-			existingAddresses = append(existingAddresses, address)
+// LookupResources is part of go-algorand's indexerLedgerForEval interface.
+func (l LedgerForEvaluator) LookupResources(input map[basics.Address]map[ledger.Creatable]struct{}) (map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource, error) {
+	// Create request arrays since iterating over maps is non-deterministic.
+	type AddrID struct {
+		addr basics.Address
+		id   basics.CreatableIndex
+	}
+	// Asset holdings to request.
+	assetHoldingsReq := make([]AddrID, 0, len(input))
+	// Asset params to request.
+	assetParamsReq := make([]basics.CreatableIndex, 0, len(input))
+	// For each asset id, record for which addresses it was requested.
+	assetParamsToAddresses := make(map[basics.CreatableIndex]map[basics.Address]struct{})
+	// App local states to request.
+	appLocalStatesReq := make([]AddrID, 0, len(input))
+	// App params to request.
+	appParamsReq := make([]basics.CreatableIndex, 0, len(input))
+	// For each app id, record for which addresses it was requested.
+	appParamsToAddresses := make(map[basics.CreatableIndex]map[basics.Address]struct{})
+
+	for address, creatables := range input {
+		for creatable := range creatables {
+			switch creatable.Type {
+			case basics.AssetCreatable:
+				assetHoldingsReq = append(assetHoldingsReq, AddrID{address, creatable.Index})
+				if addresses, ok := assetParamsToAddresses[creatable.Index]; ok {
+					addresses[address] = struct{}{}
+				} else {
+					assetParamsReq = append(assetParamsReq, creatable.Index)
+					addresses = make(map[basics.Address]struct{})
+					addresses[address] = struct{}{}
+					assetParamsToAddresses[creatable.Index] = addresses
+				}
+			case basics.AppCreatable:
+				appLocalStatesReq = append(appLocalStatesReq, AddrID{address, creatable.Index})
+				if addresses, ok := appParamsToAddresses[creatable.Index]; ok {
+					addresses[address] = struct{}{}
+				} else {
+					appParamsReq = append(appParamsReq, creatable.Index)
+					addresses = make(map[basics.Address]struct{})
+					addresses[address] = struct{}{}
+					appParamsToAddresses[creatable.Index] = addresses
+				}
+			default:
+				return nil, fmt.Errorf(
+					"LookupResources() unknown creatable type %d", creatable.Type)
+			}
 		}
 	}
 
-	for i := range existingAddresses {
-		batch.Queue(assetHoldingsStmtName, existingAddresses[i][:])
+	// Prepare a batch of sql queries.
+	var batch pgx.Batch
+	for i := range assetHoldingsReq {
+		batch.Queue(
+			assetHoldingStmtName, assetHoldingsReq[i].addr[:], assetHoldingsReq[i].id)
 	}
-	for i := range existingAddresses {
-		batch.Queue(assetParamsStmtName, existingAddresses[i][:])
+	for _, cidx := range assetParamsReq {
+		batch.Queue(assetParamsStmtName, cidx)
 	}
-	for i := range existingAddresses {
-		batch.Queue(appParamsStmtName, existingAddresses[i][:])
+	for _, cidx := range appParamsReq {
+		batch.Queue(appParamsStmtName, cidx)
 	}
-	for i := range existingAddresses {
-		batch.Queue(appLocalStatesStmtName, existingAddresses[i][:])
+	for i := range appLocalStatesReq {
+		batch.Queue(
+			appLocalStateStmtName, appLocalStatesReq[i].addr[:], appLocalStatesReq[i].id)
 	}
 
+	// Execute the sql queries.
 	results := l.tx.SendBatch(context.Background(), &batch)
 	defer results.Close()
 
-	for _, address := range existingAddresses {
-		rows, err := results.Query()
-		if err != nil {
-			return fmt.Errorf("loadCreatables() query asset holdings err: %w", err)
+	// Initialize the result `res` with the same structure as `input`.
+	res := make(
+		map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource, len(input))
+	for address, creatables := range input {
+		creatablesOutput :=
+			make(map[ledger.Creatable]ledgercore.AccountResource, len(creatables))
+		res[address] = creatablesOutput
+		for creatable := range creatables {
+			creatablesOutput[creatable] = ledgercore.AccountResource{}
 		}
-		(*accountDataMap)[address].Assets, err = l.parseAccountAssetTable(rows)
+	}
+
+	// Parse sql query results in the same order the queries were made.
+	for _, addrID := range assetHoldingsReq {
+		row := results.QueryRow()
+		assetHolding, exists, err := l.parseAccountAssetTable(row)
 		if err != nil {
-			return fmt.Errorf("loadCreatables() err: %w", err)
+			return nil, fmt.Errorf("LookupResources() err: %w", err)
+		}
+		if exists {
+			creatable := ledger.Creatable{
+				Index: addrID.id,
+				Type:  basics.AssetCreatable,
+			}
+			resource := res[addrID.addr][creatable]
+			resource.AssetHolding = new(basics.AssetHolding)
+			*resource.AssetHolding = assetHolding
+			res[addrID.addr][creatable] = resource
 		}
 	}
-	for _, address := range existingAddresses {
-		rows, err := results.Query()
+	for _, cidx := range assetParamsReq {
+		row := results.QueryRow()
+		creator, assetParams, exists, err := l.parseAssetTable(row)
 		if err != nil {
-			return fmt.Errorf("loadCreatables() query asset params err: %w", err)
+			return nil, fmt.Errorf("LookupResources() err: %w", err)
 		}
-		(*accountDataMap)[address].AssetParams, err = l.parseAssetTable(rows)
-		if err != nil {
-			return fmt.Errorf("loadCreatables() err: %w", err)
+		if exists {
+			if _, ok := assetParamsToAddresses[cidx][creator]; ok {
+				creatable := ledger.Creatable{
+					Index: cidx,
+					Type:  basics.AssetCreatable,
+				}
+				resource := res[creator][creatable]
+				resource.AssetParams = new(basics.AssetParams)
+				*resource.AssetParams = assetParams
+				res[creator][creatable] = resource
+			}
 		}
 	}
-	for _, address := range existingAddresses {
-		rows, err := results.Query()
+	for _, cidx := range appParamsReq {
+		row := results.QueryRow()
+		creator, appParams, exists, err := l.parseAppTable(row)
 		if err != nil {
-			return fmt.Errorf("loadCreatables() query app params err: %w", err)
+			return nil, fmt.Errorf("LookupResources() err: %w", err)
 		}
-		(*accountDataMap)[address].AppParams, err = l.parseAppTable(rows)
-		if err != nil {
-			return fmt.Errorf("loadCreatables() err: %w", err)
+		if exists {
+			if _, ok := appParamsToAddresses[cidx][creator]; ok {
+				creatable := ledger.Creatable{
+					Index: cidx,
+					Type:  basics.AppCreatable,
+				}
+				resource := res[creator][creatable]
+				resource.AppParams = new(basics.AppParams)
+				*resource.AppParams = appParams
+				res[creator][creatable] = resource
+			}
 		}
 	}
-	for _, address := range existingAddresses {
-		rows, err := results.Query()
+	for _, addrID := range appLocalStatesReq {
+		row := results.QueryRow()
+		appLocalState, exists, err := l.parseAccountAppTable(row)
 		if err != nil {
-			return fmt.Errorf("loadCreatables() query app local states err: %w", err)
+			return nil, fmt.Errorf("LookupResources() err: %w", err)
 		}
-		(*accountDataMap)[address].AppLocalStates, err = l.parseAccountAppTable(rows)
-		if err != nil {
-			return fmt.Errorf("loadCreatables() err: %w", err)
+		if exists {
+			creatable := ledger.Creatable{
+				Index: addrID.id,
+				Type:  basics.AppCreatable,
+			}
+			resource := res[addrID.addr][creatable]
+			resource.AppLocalState = new(basics.AppLocalState)
+			*resource.AppLocalState = appLocalState
+			res[addrID.addr][creatable] = resource
 		}
 	}
 
 	err := results.Close()
 	if err != nil {
-		return fmt.Errorf("loadCreatables() close results err: %w", err)
-	}
-
-	return nil
-}
-
-// LookupWithoutRewards is part of go-algorand's indexerLedgerForEval interface.
-func (l LedgerForEvaluator) LookupWithoutRewards(addresses map[basics.Address]struct{}) (map[basics.Address]*basics.AccountData, error) {
-	res, err := l.loadAccountTable(addresses)
-	if err != nil {
-		return nil, fmt.Errorf("loadAccounts() err: %w", err)
-	}
-
-	err = l.loadCreatables(&res)
-	if err != nil {
-		return nil, fmt.Errorf("loadAccounts() err: %w", err)
+		return nil, fmt.Errorf("LookupResources() close results err: %w", err)
 	}
 
 	return res, nil
diff --git a/idb/postgres/internal/ledger_for_evaluator/ledger_for_evaluator_test.go b/idb/postgres/internal/ledger_for_evaluator/ledger_for_evaluator_test.go
index 57e195fe1..cdccf7611 100644
--- a/idb/postgres/internal/ledger_for_evaluator/ledger_for_evaluator_test.go
+++ b/idb/postgres/internal/ledger_for_evaluator/ledger_for_evaluator_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/algorand/go-algorand/crypto"
+	"github.com/algorand/go-algorand/crypto/merklesignature"
 	"github.com/algorand/go-algorand/data/basics"
 	"github.com/algorand/go-algorand/data/bookkeeping"
 	"github.com/algorand/go-algorand/ledger"
@@ -26,17 +27,8 @@ import (
 
 var readonlyRepeatableRead = pgx.TxOptions{IsoLevel: pgx.RepeatableRead, AccessMode: pgx.ReadOnly}
 
-func setupPostgres(t *testing.T) (*pgxpool.Pool, func()) {
-	db, _, shutdownFunc := pgtest.SetupPostgres(t)
-
-	_, err := db.Exec(context.Background(), schema.SetupPostgresSql)
-	require.NoError(t, err)
-
-	return db, shutdownFunc
-}
-
 func TestLedgerForEvaluatorLatestBlockHdr(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	query :=
@@ -65,7 +57,7 @@ func TestLedgerForEvaluatorLatestBlockHdr(t *testing.T) {
 }
 
 func TestLedgerForEvaluatorAccountTableBasic(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	query := `INSERT INTO account
@@ -76,26 +68,33 @@ func TestLedgerForEvaluatorAccountTableBasic(t *testing.T) {
 	voteID[0] = 2
 	var selectionID crypto.VRFVerifier
 	selectionID[0] = 3
-	accountDataWritten := basics.AccountData{
-		Status:          basics.Online,
-		VoteID:          voteID,
-		SelectionID:     selectionID,
-		VoteFirstValid:  basics.Round(4),
-		VoteLastValid:   basics.Round(5),
-		VoteKeyDilution: 6,
-		AuthAddr:        test.AccountA,
+	var stateProofID merklesignature.Verifier
+	stateProofID[0] = 10
+	accountDataFull := ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			Status:             basics.Online,
+			MicroAlgos:         basics.MicroAlgos{Raw: 4},
+			RewardsBase:        5,
+			RewardedMicroAlgos: basics.MicroAlgos{Raw: 6},
+			AuthAddr:           test.AccountA,
+		},
+		VotingData: ledgercore.VotingData{
+			VoteID:          voteID,
+			SelectionID:     selectionID,
+			StateProofID:    stateProofID,
+			VoteFirstValid:  basics.Round(7),
+			VoteLastValid:   basics.Round(8),
+			VoteKeyDilution: 9,
+		},
 	}
 
-	accountDataFull := accountDataWritten
-	accountDataFull.MicroAlgos = basics.MicroAlgos{Raw: 2}
-	accountDataFull.RewardsBase = 3
-	accountDataFull.RewardedMicroAlgos = basics.MicroAlgos{Raw: 4}
+	accountDataWritten := encoding.TrimLcAccountData(accountDataFull)
 
 	_, err := db.Exec(
 		context.Background(),
 		query, test.AccountB[:], accountDataFull.MicroAlgos.Raw, accountDataFull.RewardsBase,
 		accountDataFull.RewardedMicroAlgos.Raw,
-		encoding.EncodeTrimmedAccountData(accountDataWritten))
+		encoding.EncodeTrimmedLcAccountData(accountDataWritten))
 	require.NoError(t, err)
 
 	tx, err := db.BeginTx(context.Background(), readonlyRepeatableRead)
@@ -116,57 +115,69 @@ func TestLedgerForEvaluatorAccountTableBasic(t *testing.T) {
 	assert.Equal(t, accountDataFull, *accountDataRet)
 }
 
-func insertAccountData(db *pgxpool.Pool, account basics.Address, createdat uint64, deleted bool, data basics.AccountData) error {
-	// This could be 'upsertAccountStmtName'
-	query :=
-		"INSERT INTO account (addr, microalgos, rewardsbase, rewards_total, deleted, " +
-			"created_at, account_data) " +
-			"VALUES ($1, $2, $3, $4, $5, $6, $7)"
+func insertDeletedAccount(db *pgxpool.Pool, address basics.Address) error {
+	query := `INSERT INTO account (addr, microalgos, rewardsbase, rewards_total, deleted,
+		created_at, account_data)
+		VALUES ($1, 0, 0, 0, true, 0, 'null'::jsonb)`
+
+	_, err := db.Exec(
+		context.Background(), query, address[:])
+	return err
+}
+
+func insertAccount(db *pgxpool.Pool, address basics.Address, data ledgercore.AccountData) error {
+	query := `INSERT INTO account (addr, microalgos, rewardsbase, rewards_total, deleted,
+		created_at, account_data)
+		VALUES ($1, $2, $3, $4, false, 0, $5)`
+
 	_, err := db.Exec(
 		context.Background(), query,
-		account[:], data.MicroAlgos.Raw, data.RewardsBase, data.RewardedMicroAlgos.Raw, deleted, createdat,
-		encoding.EncodeTrimmedAccountData(data))
+		address[:], data.MicroAlgos.Raw, data.RewardsBase, data.RewardedMicroAlgos.Raw,
+		encoding.EncodeTrimmedLcAccountData(data))
 	return err
 }
 
 // TestLedgerForEvaluatorAccountTableBasicSingleAccount a table driven single account test.
 func TestLedgerForEvaluatorAccountTableSingleAccount(t *testing.T) {
 	tests := []struct {
-		name      string
-		createdAt uint64
-		deleted   bool
-		data      basics.AccountData
-		err       string
+		name    string
+		deleted bool
+		data    ledgercore.AccountData
+		err     string
 	}{
 		{
 			name: "small balance",
-			data: basics.AccountData{
-				MicroAlgos: basics.MicroAlgos{Raw: 1},
+			data: ledgercore.AccountData{
+				AccountBaseData: ledgercore.AccountBaseData{
+					MicroAlgos: basics.MicroAlgos{Raw: 1},
+				},
 			},
 		},
 		{
 			name: "max balance",
-			data: basics.AccountData{
-				MicroAlgos: basics.MicroAlgos{Raw: math.MaxInt64},
+			data: ledgercore.AccountData{
+				AccountBaseData: ledgercore.AccountBaseData{
+					MicroAlgos: basics.MicroAlgos{Raw: math.MaxInt64},
+				},
 			},
 		},
 		{
 			name: "over max balance",
-			data: basics.AccountData{
-				MicroAlgos: basics.MicroAlgos{Raw: math.MaxUint64},
+			data: ledgercore.AccountData{
+				AccountBaseData: ledgercore.AccountBaseData{
+					MicroAlgos: basics.MicroAlgos{Raw: math.MaxUint64},
+				},
 			},
-			err: fmt.Sprintf("%d is greater than maximum value for Int8", uint64(math.MaxUint64)),
+			err: fmt.Sprintf(
+				"%d is greater than maximum value for Int8", uint64(math.MaxUint64)),
 		},
 		{
 			name:    "deleted",
 			deleted: true,
-			data: basics.AccountData{
-				MicroAlgos: basics.MicroAlgos{Raw: math.MaxInt64},
-			},
 		},
 	}
 
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	for i, testcase := range tests {
@@ -184,7 +195,12 @@ func TestLedgerForEvaluatorAccountTableSingleAccount(t *testing.T) {
 				return false
 			}
 
-			err := insertAccountData(db, addr, tc.createdAt, tc.deleted, tc.data)
+			var err error
+			if tc.deleted {
+				err = insertDeletedAccount(db, addr)
+			} else {
+				err = insertAccount(db, addr, tc.data)
+			}
 			if checkError(err) {
 				return
 			}
@@ -225,7 +241,7 @@ func TestLedgerForEvaluatorAccountTableSingleAccount(t *testing.T) {
 }
 
 func TestLedgerForEvaluatorAccountTableDeleted(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	query :=
@@ -233,12 +249,14 @@ func TestLedgerForEvaluatorAccountTableDeleted(t *testing.T) {
 			"created_at, account_data) " +
 			"VALUES ($1, 2, 3, 4, true, 0, $2)"
 
-	accountData := basics.AccountData{
-		MicroAlgos: basics.MicroAlgos{Raw: 5},
+	accountData := ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			MicroAlgos: basics.MicroAlgos{Raw: 5},
+		},
 	}
 	_, err := db.Exec(
 		context.Background(), query, test.AccountB[:],
-		encoding.EncodeTrimmedAccountData(accountData))
+		encoding.EncodeTrimmedLcAccountData(accountData))
 	require.NoError(t, err)
 
 	tx, err := db.BeginTx(context.Background(), readonlyRepeatableRead)
@@ -258,7 +276,7 @@ func TestLedgerForEvaluatorAccountTableDeleted(t *testing.T) {
 }
 
 func TestLedgerForEvaluatorAccountTableMissingAccount(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	tx, err := db.BeginTx(context.Background(), readonlyRepeatableRead)
@@ -277,27 +295,34 @@ func TestLedgerForEvaluatorAccountTableMissingAccount(t *testing.T) {
 	assert.Nil(t, accountDataRet)
 }
 
-func TestLedgerForEvaluatorAccountAssetTable(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
-	defer shutdownFunc()
+func insertDeletedAccountAsset(t *testing.T, db *pgxpool.Pool, addr basics.Address, assetid uint64) {
+	query :=
+		"INSERT INTO account_asset (addr, assetid, amount, frozen, deleted, created_at) " +
+			"VALUES ($1, $2, 0, false, true, 0)"
 
-	query := `INSERT INTO account
-		(addr, microalgos, rewardsbase, rewards_total, deleted, created_at, account_data)
-		VALUES ($1, 0, 0, 0, false, 0, 'null'::jsonb)`
-	_, err := db.Exec(context.Background(), query, test.AccountA[:])
+	_, err := db.Exec(
+		context.Background(), query, addr[:], assetid)
 	require.NoError(t, err)
+}
 
-	query =
+func insertAccountAsset(t *testing.T, db *pgxpool.Pool, addr basics.Address, assetid uint64, amount uint64, frozen bool) {
+	query :=
 		"INSERT INTO account_asset (addr, assetid, amount, frozen, deleted, created_at) " +
-			"VALUES ($1, $2, $3, $4, $5, 0)"
-	_, err = db.Exec(context.Background(), query, test.AccountA[:], 1, 2, false, false)
-	require.NoError(t, err)
-	_, err = db.Exec(context.Background(), query, test.AccountA[:], 3, 4, true, false)
-	require.NoError(t, err)
-	_, err = db.Exec(context.Background(), query, test.AccountA[:], 5, 6, true, true) // deleted
-	require.NoError(t, err)
-	_, err = db.Exec(context.Background(), query, test.AccountB[:], 5, 6, true, false) // wrong account
+			"VALUES ($1, $2, $3, $4, false, 0)"
+
+	_, err := db.Exec(
+		context.Background(), query, addr[:], assetid, amount, frozen)
 	require.NoError(t, err)
+}
+
+func TestLedgerForEvaluatorAccountAssetTable(t *testing.T) {
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
+
+	insertAccountAsset(t, db, test.AccountA, 1, 2, false)
+	insertAccountAsset(t, db, test.AccountA, 3, 4, true)
+	insertDeletedAccountAsset(t, db, test.AccountA, 5)
+	insertAccountAsset(t, db, test.AccountB, 5, 6, true)
 
 	tx, err := db.BeginTx(context.Background(), readonlyRepeatableRead)
 	require.NoError(t, err)
@@ -307,59 +332,76 @@ func TestLedgerForEvaluatorAccountAssetTable(t *testing.T) {
 	require.NoError(t, err)
 	defer l.Close()
 
-	ret, err :=
-		l.LookupWithoutRewards(map[basics.Address]struct{}{test.AccountA: {}})
+	ret, err := l.LookupResources(map[basics.Address]map[ledger.Creatable]struct{}{
+		test.AccountA: {
+			{Index: 1, Type: basics.AssetCreatable}: {},
+			{Index: 3, Type: basics.AssetCreatable}: {},
+			{Index: 5, Type: basics.AssetCreatable}: {},
+			{Index: 8, Type: basics.AssetCreatable}: {},
+		},
+		test.AccountB: {
+			{Index: 5, Type: basics.AssetCreatable}: {},
+		},
+	})
 	require.NoError(t, err)
 
-	accountDataRet := ret[test.AccountA]
-	require.NotNil(t, accountDataRet)
-
-	accountDataExpected := basics.AccountData{
-		Assets: map[basics.AssetIndex]basics.AssetHolding{
-			1: {
-				Amount: 2,
-				Frozen: false,
+	expected := map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource{
+		test.AccountA: {
+			ledger.Creatable{Index: 1, Type: basics.AssetCreatable}: {
+				AssetHolding: &basics.AssetHolding{
+					Amount: 2,
+					Frozen: false,
+				},
+			},
+			ledger.Creatable{Index: 3, Type: basics.AssetCreatable}: {
+				AssetHolding: &basics.AssetHolding{
+					Amount: 4,
+					Frozen: true,
+				},
 			},
-			3: {
-				Amount: 4,
-				Frozen: true,
+			ledger.Creatable{Index: 5, Type: basics.AssetCreatable}: {},
+			ledger.Creatable{Index: 8, Type: basics.AssetCreatable}: {},
+		},
+		test.AccountB: {
+			ledger.Creatable{Index: 5, Type: basics.AssetCreatable}: {
+				AssetHolding: &basics.AssetHolding{
+					Amount: 6,
+					Frozen: true,
+				},
 			},
 		},
 	}
-	assert.Equal(t, accountDataExpected, *accountDataRet)
+	assert.Equal(t, expected, ret)
 }
 
-func TestLedgerForEvaluatorAssetTable(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
-	defer shutdownFunc()
+func insertDeletedAsset(t *testing.T, db *pgxpool.Pool, index uint64, creatorAddr basics.Address) {
+	query := `INSERT INTO asset (index, creator_addr, params, deleted, created_at)
+		VALUES ($1, $2, 'null'::jsonb, true, 0)`
 
-	query := `INSERT INTO account
-		(addr, microalgos, rewardsbase, rewards_total, deleted, created_at, account_data)
-		VALUES ($1, 0, 0, 0, false, 0, 'null'::jsonb)`
-	_, err := db.Exec(context.Background(), query, test.AccountA[:])
+	_, err := db.Exec(
+		context.Background(), query, index, creatorAddr[:])
 	require.NoError(t, err)
+}
 
-	query =
-		"INSERT INTO asset (index, creator_addr, params, deleted, created_at) " +
-			"VALUES ($1, $2, $3, $4, 0)"
-
-	_, err = db.Exec(
-		context.Background(), query, 1, test.AccountA[:],
-		encoding.EncodeAssetParams(basics.AssetParams{Manager: test.AccountB}),
-		false)
-	require.NoError(t, err)
+func insertAsset(t *testing.T, db *pgxpool.Pool, index uint64, creatorAddr basics.Address, params *basics.AssetParams) {
+	query := `INSERT INTO asset (index, creator_addr, params, deleted, created_at)
+		VALUES ($1, $2, $3, false, 0)`
 
-	_, err = db.Exec(
-		context.Background(), query, 2, test.AccountA[:],
-		encoding.EncodeAssetParams(basics.AssetParams{Manager: test.AccountC}),
-		false)
+	_, err := db.Exec(
+		context.Background(), query, index, creatorAddr[:],
+		encoding.EncodeAssetParams(*params))
 	require.NoError(t, err)
+}
 
-	_, err = db.Exec(context.Background(), query, 3, test.AccountA[:], "{}", true) // deleted
-	require.NoError(t, err)
+func TestLedgerForEvaluatorAssetTable(t *testing.T) {
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
 
-	_, err = db.Exec(context.Background(), query, 4, test.AccountD[:], "{}", false) // wrong account
-	require.NoError(t, err)
+	insertAsset(t, db, 1, test.AccountA, &basics.AssetParams{Manager: test.AccountB})
+	insertAsset(t, db, 2, test.AccountA, &basics.AssetParams{Total: 10})
+	insertDeletedAsset(t, db, 3, test.AccountA)
+	insertAsset(t, db, 4, test.AccountC, &basics.AssetParams{Total: 12})
+	insertAsset(t, db, 5, test.AccountD, &basics.AssetParams{Total: 13})
 
 	tx, err := db.BeginTx(context.Background(), readonlyRepeatableRead)
 	require.NoError(t, err)
@@ -369,65 +411,91 @@ func TestLedgerForEvaluatorAssetTable(t *testing.T) {
 	require.NoError(t, err)
 	defer l.Close()
 
-	ret, err :=
-		l.LookupWithoutRewards(map[basics.Address]struct{}{test.AccountA: {}})
+	ret, err := l.LookupResources(map[basics.Address]map[ledger.Creatable]struct{}{
+		test.AccountA: {
+			{Index: 1, Type: basics.AssetCreatable}: {},
+			{Index: 2, Type: basics.AssetCreatable}: {},
+			{Index: 3, Type: basics.AssetCreatable}: {},
+			{Index: 4, Type: basics.AssetCreatable}: {},
+			{Index: 6, Type: basics.AssetCreatable}: {},
+		},
+		test.AccountD: {
+			{Index: 5, Type: basics.AssetCreatable}: {},
+		},
+	})
 	require.NoError(t, err)
 
-	accountDataRet := ret[test.AccountA]
-	require.NotNil(t, accountDataRet)
-
-	accountDataExpected := basics.AccountData{
-		AssetParams: map[basics.AssetIndex]basics.AssetParams{
-			1: {
-				Manager: test.AccountB,
+	expected := map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource{
+		test.AccountA: {
+			ledger.Creatable{Index: 1, Type: basics.AssetCreatable}: {
+				AssetParams: &basics.AssetParams{
+					Manager: test.AccountB,
+				},
 			},
-			2: {
-				Manager: test.AccountC,
+			ledger.Creatable{Index: 2, Type: basics.AssetCreatable}: {
+				AssetParams: &basics.AssetParams{
+					Total: 10,
+				},
+			},
+			ledger.Creatable{Index: 3, Type: basics.AssetCreatable}: {},
+			ledger.Creatable{Index: 4, Type: basics.AssetCreatable}: {},
+			ledger.Creatable{Index: 6, Type: basics.AssetCreatable}: {},
+		},
+		test.AccountD: {
+			ledger.Creatable{Index: 5, Type: basics.AssetCreatable}: {
+				AssetParams: &basics.AssetParams{
+					Total: 13,
+				},
 			},
 		},
 	}
-	assert.Equal(t, accountDataExpected, *accountDataRet)
+	assert.Equal(t, expected, ret)
 }
 
-func TestLedgerForEvaluatorAppTable(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
-	defer shutdownFunc()
+func insertDeletedApp(t *testing.T, db *pgxpool.Pool, index uint64, creator basics.Address) {
+	query := `INSERT INTO app (index, creator, params, deleted, created_at)
+		VALUES ($1, $2, 'null'::jsonb, true, 0)`
 
-	query := `INSERT INTO account
-		(addr, microalgos, rewardsbase, rewards_total, deleted, created_at, account_data)
-		VALUES ($1, 0, 0, 0, false, 0, 'null'::jsonb)`
-	_, err := db.Exec(context.Background(), query, test.AccountA[:])
+	_, err := db.Exec(context.Background(), query, index, creator[:])
 	require.NoError(t, err)
+}
 
-	query =
-		"INSERT INTO app (index, creator, params, deleted, created_at) " +
-			"VALUES ($1, $2, $3, $4, 0)"
+func insertApp(t *testing.T, db *pgxpool.Pool, index uint64, creator basics.Address, params *basics.AppParams) {
+	query := `INSERT INTO app (index, creator, params, deleted, created_at)
+		VALUES ($1, $2, $3, false, 0)`
+
+	_, err := db.Exec(
+		context.Background(), query, index, creator[:], encoding.EncodeAppParams(*params))
+	require.NoError(t, err)
+}
+
+func TestLedgerForEvaluatorAppTable(t *testing.T) {
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
 
 	params1 := basics.AppParams{
 		GlobalState: map[string]basics.TealValue{
 			string([]byte{0xff}): {}, // try a non-utf8 string
 		},
 	}
-	_, err = db.Exec(
-		context.Background(), query, 1, test.AccountA[:],
-		encoding.EncodeAppParams(params1), false)
-	require.NoError(t, err)
+	insertApp(t, db, 1, test.AccountA, &params1)
 
 	params2 := basics.AppParams{
-		ApprovalProgram: []byte{1, 2, 3},
+		ApprovalProgram: []byte{1, 2, 3, 10},
 	}
-	_, err = db.Exec(
-		context.Background(), query, 2, test.AccountA[:],
-		encoding.EncodeAppParams(params2), false)
-	require.NoError(t, err)
+	insertApp(t, db, 2, test.AccountA, &params2)
 
-	_, err = db.Exec(
-		context.Background(), query, 3, test.AccountA[:], "{}", true) // deteled
-	require.NoError(t, err)
+	insertDeletedApp(t, db, 3, test.AccountA)
 
-	_, err = db.Exec(
-		context.Background(), query, 4, test.AccountB[:], "{}", false) // wrong account
-	require.NoError(t, err)
+	params4 := basics.AppParams{
+		ApprovalProgram: []byte{1, 2, 3, 12},
+	}
+	insertApp(t, db, 4, test.AccountB, &params4)
+
+	params5 := basics.AppParams{
+		ApprovalProgram: []byte{1, 2, 3, 13},
+	}
+	insertApp(t, db, 5, test.AccountC, &params5)
 
 	tx, err := db.BeginTx(context.Background(), readonlyRepeatableRead)
 	require.NoError(t, err)
@@ -437,63 +505,86 @@ func TestLedgerForEvaluatorAppTable(t *testing.T) {
 	require.NoError(t, err)
 	defer l.Close()
 
-	ret, err :=
-		l.LookupWithoutRewards(map[basics.Address]struct{}{test.AccountA: {}})
+	ret, err := l.LookupResources(map[basics.Address]map[ledger.Creatable]struct{}{
+		test.AccountA: {
+			{Index: 1, Type: basics.AppCreatable}: {},
+			{Index: 2, Type: basics.AppCreatable}: {},
+			{Index: 3, Type: basics.AppCreatable}: {},
+			{Index: 4, Type: basics.AppCreatable}: {},
+			{Index: 6, Type: basics.AppCreatable}: {},
+		},
+		test.AccountC: {
+			{Index: 5, Type: basics.AppCreatable}: {},
+		},
+	})
 	require.NoError(t, err)
 
-	accountDataRet := ret[test.AccountA]
-	require.NotNil(t, accountDataRet)
-
-	accountDataExpected := basics.AccountData{
-		AppParams: map[basics.AppIndex]basics.AppParams{
-			1: params1,
-			2: params2,
+	expected := map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource{
+		test.AccountA: {
+			ledger.Creatable{Index: 1, Type: basics.AppCreatable}: {
+				AppParams: &params1,
+			},
+			ledger.Creatable{Index: 2, Type: basics.AppCreatable}: {
+				AppParams: &params2,
+			},
+			ledger.Creatable{Index: 3, Type: basics.AppCreatable}: {},
+			ledger.Creatable{Index: 4, Type: basics.AppCreatable}: {},
+			ledger.Creatable{Index: 6, Type: basics.AppCreatable}: {},
+		},
+		test.AccountC: {
+			ledger.Creatable{Index: 5, Type: basics.AppCreatable}: {
+				AppParams: &params5,
+			},
 		},
 	}
-	assert.Equal(t, accountDataExpected, *accountDataRet)
+	assert.Equal(t, expected, ret)
 }
 
-func TestLedgerForEvaluatorAccountAppTable(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
-	defer shutdownFunc()
+func insertDeletedAccountApp(t *testing.T, db *pgxpool.Pool, addr basics.Address, app uint64) {
+	query := `INSERT INTO account_app (addr, app, localstate, deleted, created_at)
+		VALUES ($1, $2, 'null'::jsonb, true, 0)`
 
-	query := `INSERT INTO account
-		(addr, microalgos, rewardsbase, rewards_total, deleted, created_at, account_data)
-		VALUES ($1, 0, 0, 0, false, 0, 'null'::jsonb)`
-	_, err := db.Exec(context.Background(), query, test.AccountA[:])
+	_, err := db.Exec(
+		context.Background(), query, addr[:], app)
 	require.NoError(t, err)
+}
 
-	query =
-		"INSERT INTO account_app (addr, app, localstate, deleted, created_at) " +
-			"VALUES ($1, $2, $3, $4, 0)"
+func insertAccountApp(t *testing.T, db *pgxpool.Pool, addr basics.Address, app uint64, localstate *basics.AppLocalState) {
+	query := `INSERT INTO account_app (addr, app, localstate, deleted, created_at)
+		VALUES ($1, $2, $3, false, 0)`
 
-	params1 := basics.AppLocalState{
+	_, err := db.Exec(
+		context.Background(), query, addr[:], app,
+		encoding.EncodeAppLocalState(*localstate))
+	require.NoError(t, err)
+}
+
+func TestLedgerForEvaluatorAccountAppTable(t *testing.T) {
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
+
+	stateA1 := basics.AppLocalState{
 		KeyValue: map[string]basics.TealValue{
 			string([]byte{0xff}): {}, // try a non-utf8 string
 		},
 	}
-	_, err = db.Exec(
-		context.Background(), query, test.AccountA[:], 1,
-		encoding.EncodeAppLocalState(params1), false)
-	require.NoError(t, err)
+	insertAccountApp(t, db, test.AccountA, 1, &stateA1)
 
-	params2 := basics.AppLocalState{
+	stateA2 := basics.AppLocalState{
 		KeyValue: map[string]basics.TealValue{
 			"abc": {},
 		},
 	}
-	_, err = db.Exec(
-		context.Background(), query, test.AccountA[:], 2,
-		encoding.EncodeAppLocalState(params2), false)
-	require.NoError(t, err)
+	insertAccountApp(t, db, test.AccountA, 2, &stateA2)
 
-	_, err = db.Exec(
-		context.Background(), query, test.AccountA[:], 3, "{}", true) // deteled
-	require.NoError(t, err)
+	insertDeletedAccountApp(t, db, test.AccountA, 3)
 
-	_, err = db.Exec(
-		context.Background(), query, test.AccountB[:], 4, "{}", false) // wrong account
-	require.NoError(t, err)
+	stateB3 := basics.AppLocalState{
+		KeyValue: map[string]basics.TealValue{
+			"abf": {},
+		},
+	}
+	insertAccountApp(t, db, test.AccountB, 3, &stateB3)
 
 	tx, err := db.BeginTx(context.Background(), readonlyRepeatableRead)
 	require.NoError(t, err)
@@ -503,70 +594,107 @@ func TestLedgerForEvaluatorAccountAppTable(t *testing.T) {
 	require.NoError(t, err)
 	defer l.Close()
 
-	ret, err :=
-		l.LookupWithoutRewards(map[basics.Address]struct{}{test.AccountA: {}})
+	ret, err := l.LookupResources(map[basics.Address]map[ledger.Creatable]struct{}{
+		test.AccountA: {
+			{Index: 1, Type: basics.AppCreatable}: {},
+			{Index: 2, Type: basics.AppCreatable}: {},
+			{Index: 3, Type: basics.AppCreatable}: {},
+			{Index: 4, Type: basics.AppCreatable}: {},
+		},
+		test.AccountB: {
+			{Index: 3, Type: basics.AppCreatable}: {},
+		},
+	})
 	require.NoError(t, err)
 
-	accountDataRet := ret[test.AccountA]
-	require.NotNil(t, accountDataRet)
+	expected := map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource{
+		test.AccountA: {
+			ledger.Creatable{Index: 1, Type: basics.AppCreatable}: {
+				AppLocalState: &stateA1,
+			},
+			ledger.Creatable{Index: 2, Type: basics.AppCreatable}: {
+				AppLocalState: &stateA2,
+			},
+			ledger.Creatable{Index: 3, Type: basics.AppCreatable}: {},
+			ledger.Creatable{Index: 4, Type: basics.AppCreatable}: {},
+		},
+		test.AccountB: {
+			ledger.Creatable{Index: 3, Type: basics.AppCreatable}: {
+				AppLocalState: &stateB3,
+			},
+		},
+	}
+	assert.Equal(t, expected, ret)
+}
+
+func TestLedgerForEvaluatorFetchAllResourceTypes(t *testing.T) {
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
+
+	insertAccountAsset(t, db, test.AccountA, 1, 2, true)
+	insertAsset(t, db, 1, test.AccountA, &basics.AssetParams{Total: 3})
+	insertAccountApp(
+		t, db, test.AccountA, 4,
+		&basics.AppLocalState{Schema: basics.StateSchema{NumUint: 5}})
+	insertApp(t, db, 4, test.AccountA, &basics.AppParams{ExtraProgramPages: 6})
+
+	tx, err := db.BeginTx(context.Background(), readonlyRepeatableRead)
+	require.NoError(t, err)
+	defer tx.Rollback(context.Background())
+
+	l, err := ledger_for_evaluator.MakeLedgerForEvaluator(tx, basics.Round(0))
+	require.NoError(t, err)
+	defer l.Close()
 
-	accountDataExpected := basics.AccountData{
-		AppLocalStates: map[basics.AppIndex]basics.AppLocalState{
-			1: params1,
-			2: params2,
+	ret, err := l.LookupResources(map[basics.Address]map[ledger.Creatable]struct{}{
+		test.AccountA: {
+			{Index: 1, Type: basics.AssetCreatable}: {},
+			{Index: 4, Type: basics.AppCreatable}:   {},
+		},
+	})
+	require.NoError(t, err)
+
+	expected := map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource{
+		test.AccountA: {
+			ledger.Creatable{Index: 1, Type: basics.AssetCreatable}: {
+				AssetHolding: &basics.AssetHolding{
+					Amount: 2,
+					Frozen: true,
+				},
+				AssetParams: &basics.AssetParams{
+					Total: 3,
+				},
+			},
+			ledger.Creatable{Index: 4, Type: basics.AppCreatable}: {
+				AppLocalState: &basics.AppLocalState{
+					Schema: basics.StateSchema{
+						NumUint: 5,
+					},
+				},
+				AppParams: &basics.AppParams{
+					ExtraProgramPages: 6,
+				},
+			},
 		},
 	}
-	assert.Equal(t, accountDataExpected, *accountDataRet)
+	assert.Equal(t, expected, ret)
 }
 
-// Tests that queuing and reading from a batch when using PreloadAccounts()
-// is in the same order.
+// Tests that queuing and reading from a batch is in the same order.
 func TestLedgerForEvaluatorLookupMultipleAccounts(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	addAccountQuery := `INSERT INTO account
 		(addr, microalgos, rewardsbase, rewards_total, deleted, created_at, account_data)
 		VALUES ($1, 0, 0, 0, false, 0, 'null'::jsonb)`
-	addAccountAssetQuery :=
-		"INSERT INTO account_asset (addr, assetid, amount, frozen, deleted, created_at) " +
-			"VALUES ($1, $2, 0, false, false, 0)"
-	addAssetQuery :=
-		"INSERT INTO asset (index, creator_addr, params, deleted, created_at) " +
-			"VALUES ($1, $2, '{}', false, 0)"
-	addAppQuery :=
-		"INSERT INTO app (index, creator, params, deleted, created_at) " +
-			"VALUES ($1, $2, '{}', false, 0)"
-	addAccountAppQuery :=
-		"INSERT INTO account_app (addr, app, localstate, deleted, created_at) " +
-			"VALUES ($1, $2, '{}', false, 0)"
 
 	addresses := []basics.Address{
 		test.AccountA, test.AccountB, test.AccountC, test.AccountD, test.AccountE}
-	seq := []int{4, 9, 3, 6, 5, 1}
 
-	for i, address := range addresses {
+	for _, address := range addresses {
 		_, err := db.Exec(context.Background(), addAccountQuery, address[:])
 		require.NoError(t, err)
-
-		// Insert all types of creatables. Note that no creatable id is ever repeated.
-		for j := range seq {
-			_, err = db.Exec(
-				context.Background(), addAccountAssetQuery, address[:], i+10*j+100)
-			require.NoError(t, err)
-
-			_, err = db.Exec(
-				context.Background(), addAssetQuery, i+10*j+200, address[:])
-			require.NoError(t, err)
-
-			_, err = db.Exec(
-				context.Background(), addAppQuery, i+10*j+300, address[:])
-			require.NoError(t, err)
-
-			_, err = db.Exec(
-				context.Background(), addAccountAppQuery, address[:], i+10*j+400)
-			require.NoError(t, err)
-		}
 	}
 
 	tx, err := db.BeginTx(context.Background(), readonlyRepeatableRead)
@@ -587,33 +715,14 @@ func TestLedgerForEvaluatorLookupMultipleAccounts(t *testing.T) {
 	ret, err := l.LookupWithoutRewards(addressesMap)
 	require.NoError(t, err)
 
-	for i, address := range addresses {
+	for _, address := range addresses {
 		accountData, _ := ret[address]
 		require.NotNil(t, accountData)
-
-		assert.Equal(t, len(seq), len(accountData.Assets))
-		assert.Equal(t, len(seq), len(accountData.AssetParams))
-		assert.Equal(t, len(seq), len(accountData.AppParams))
-		assert.Equal(t, len(seq), len(accountData.AppLocalStates))
-
-		for j := range seq {
-			_, ok := accountData.Assets[basics.AssetIndex(i+10*j+100)]
-			assert.True(t, ok)
-
-			_, ok = accountData.AssetParams[basics.AssetIndex(i+10*j+200)]
-			assert.True(t, ok)
-
-			_, ok = accountData.AppParams[basics.AppIndex(i+10*j+300)]
-			assert.True(t, ok)
-
-			_, ok = accountData.AppLocalStates[basics.AppIndex(i+10*j+400)]
-			assert.True(t, ok)
-		}
 	}
 }
 
 func TestLedgerForEvaluatorAssetCreatorBasic(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	query :=
@@ -645,7 +754,7 @@ func TestLedgerForEvaluatorAssetCreatorBasic(t *testing.T) {
 }
 
 func TestLedgerForEvaluatorAssetCreatorDeleted(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	query :=
@@ -673,7 +782,7 @@ func TestLedgerForEvaluatorAssetCreatorDeleted(t *testing.T) {
 }
 
 func TestLedgerForEvaluatorAssetCreatorMultiple(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	creatorsMap := map[basics.AssetIndex]basics.Address{
@@ -729,7 +838,7 @@ func TestLedgerForEvaluatorAssetCreatorMultiple(t *testing.T) {
 }
 
 func TestLedgerForEvaluatorAppCreatorBasic(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	query :=
@@ -761,7 +870,7 @@ func TestLedgerForEvaluatorAppCreatorBasic(t *testing.T) {
 }
 
 func TestLedgerForEvaluatorAppCreatorDeleted(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	query :=
@@ -789,7 +898,7 @@ func TestLedgerForEvaluatorAppCreatorDeleted(t *testing.T) {
 }
 
 func TestLedgerForEvaluatorAppCreatorMultiple(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	creatorsMap := map[basics.AppIndex]basics.Address{
@@ -845,7 +954,7 @@ func TestLedgerForEvaluatorAppCreatorMultiple(t *testing.T) {
 }
 
 func TestLedgerForEvaluatorAccountTotals(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	accountTotals := ledgercore.AccountTotals{
diff --git a/idb/postgres/internal/migrations/convert_account_data/m.go b/idb/postgres/internal/migrations/convert_account_data/m.go
new file mode 100644
index 000000000..e7cb13021
--- /dev/null
+++ b/idb/postgres/internal/migrations/convert_account_data/m.go
@@ -0,0 +1,188 @@
+package convertaccountdata
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/algorand/go-algorand/data/basics"
+	"github.com/algorand/go-algorand/ledger/ledgercore"
+
+	"github.com/jackc/pgx/v4"
+
+	"github.com/algorand/indexer/idb/postgres/internal/encoding"
+)
+
+type aad struct {
+	address            basics.Address
+	trimmedAccountData basics.AccountData
+}
+
+func getAccounts(tx pgx.Tx, batchSize uint, lastAddress *basics.Address) ([]aad, error) {
+	var rows pgx.Rows
+	var err error
+	if lastAddress == nil {
+		query :=
+			`SELECT addr, account_data FROM account WHERE NOT deleted ORDER BY addr LIMIT $1`
+		rows, err = tx.Query(context.Background(), query, batchSize)
+	} else {
+		query := `SELECT addr, account_data FROM account WHERE NOT deleted AND addr > $1
+			ORDER BY addr LIMIT $2`
+		rows, err = tx.Query(context.Background(), query, (*lastAddress)[:], batchSize)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("getAccounts() query err: %w", err)
+	}
+
+	res := make([]aad, 0, batchSize)
+	for rows.Next() {
+		var addr []byte
+		var accountData []byte
+		err = rows.Scan(&addr, &accountData)
+		if err != nil {
+			return nil, fmt.Errorf("getAccounts() scan err: %w", err)
+		}
+
+		res = append(res, aad{})
+		e := &res[len(res)-1]
+		copy(e.address[:], addr)
+		e.trimmedAccountData, err = encoding.DecodeTrimmedAccountData(accountData)
+		if err != nil {
+			return nil, fmt.Errorf("getAccounts() decode err: %w", err)
+		}
+	}
+	err = rows.Err()
+	if err != nil {
+		return nil, fmt.Errorf("getAccounts() rows error err: %w", err)
+	}
+
+	return res, nil
+}
+
+func computeLcAccountData(tx pgx.Tx, accounts []aad) ([]ledgercore.AccountData, error) {
+	res := make([]ledgercore.AccountData, 0, len(accounts))
+	for i := range accounts {
+		res = append(res, ledgercore.ToAccountData(accounts[i].trimmedAccountData))
+	}
+
+	var batch pgx.Batch
+	for i := range accounts {
+		batch.Queue(
+			"SELECT COUNT(*) FROM account_asset WHERE NOT deleted AND addr = $1",
+			accounts[i].address[:])
+	}
+	for i := range accounts {
+		batch.Queue(
+			"SELECT COUNT(*) FROM asset WHERE NOT deleted AND creator_addr = $1",
+			accounts[i].address[:])
+	}
+	for i := range accounts {
+		batch.Queue(
+			"SELECT COUNT(*) FROM app WHERE NOT deleted AND creator = $1",
+			accounts[i].address[:])
+	}
+	for i := range accounts {
+		batch.Queue(
+			"SELECT COUNT(*) FROM account_app WHERE NOT deleted AND addr = $1",
+			accounts[i].address[:])
+	}
+
+	results := tx.SendBatch(context.Background(), &batch)
+	defer results.Close()
+
+	for i := range accounts {
+		err := results.QueryRow().Scan(&res[i].TotalAssets)
+		if err != nil {
+			return nil, fmt.Errorf("computeLcAccountData() scan total assets err: %w", err)
+		}
+	}
+	for i := range accounts {
+		err := results.QueryRow().Scan(&res[i].TotalAssetParams)
+		if err != nil {
+			return nil, fmt.Errorf("computeLcAccountData() scan total asset params err: %w", err)
+		}
+	}
+	for i := range accounts {
+		err := results.QueryRow().Scan(&res[i].TotalAppParams)
+		if err != nil {
+			return nil, fmt.Errorf("computeLcAccountData() scan total app params err: %w", err)
+		}
+	}
+	for i := range accounts {
+		err := results.QueryRow().Scan(&res[i].TotalAppLocalStates)
+		if err != nil {
+			return nil, fmt.Errorf("computeLcAccountData() scan total app local states err: %w", err)
+		}
+	}
+
+	err := results.Close()
+	if err != nil {
+		return nil, fmt.Errorf("computeLcAccountData() close results err: %w", err)
+	}
+
+	return res, nil
+}
+
+func writeLcAccountData(tx pgx.Tx, accounts []aad, lcAccountData []ledgercore.AccountData) error {
+	var batch pgx.Batch
+	for i := range accounts {
+		query := "UPDATE account SET account_data = $1 WHERE addr = $2"
+		batch.Queue(
+			query, encoding.EncodeTrimmedLcAccountData(lcAccountData[i]),
+			accounts[i].address[:])
+	}
+
+	results := tx.SendBatch(context.Background(), &batch)
+	// Clean the results off the connection's queue. Without this, weird things happen.
+	for i := 0; i < batch.Len(); i++ {
+		_, err := results.Exec()
+		if err != nil {
+			results.Close()
+			return fmt.Errorf("writeLcAccountData() exec err: %w", err)
+		}
+	}
+	err := results.Close()
+	if err != nil {
+		return fmt.Errorf("writeLcAccountData() close results err: %w", err)
+	}
+
+	return nil
+}
+
+func processAccounts(tx pgx.Tx, accounts []aad) error {
+	lcAccountData, err := computeLcAccountData(tx, accounts)
+	if err != nil {
+		return fmt.Errorf("processAccounts() err: %w", err)
+	}
+
+	err = writeLcAccountData(tx, accounts, lcAccountData)
+	if err != nil {
+		return fmt.Errorf("processAccounts() err: %w", err)
+	}
+
+	return nil
+}
+
+// RunMigration executes the migration core functionality.
+func RunMigration(tx pgx.Tx, batchSize uint) error {
+	accounts, err := getAccounts(tx, batchSize, nil)
+	if err != nil {
+		return fmt.Errorf("RunMigration() err: %w", err)
+	}
+	err = processAccounts(tx, accounts)
+	if err != nil {
+		return fmt.Errorf("RunMigration() err: %w", err)
+	}
+
+	for uint(len(accounts)) >= batchSize {
+		accounts, err = getAccounts(tx, batchSize, &accounts[len(accounts)-1].address)
+		if err != nil {
+			return fmt.Errorf("RunMigration() err: %w", err)
+		}
+		err = processAccounts(tx, accounts)
+		if err != nil {
+			return fmt.Errorf("RunMigration() err: %w", err)
+		}
+	}
+
+	return nil
+}
diff --git a/idb/postgres/internal/migrations/convert_account_data/m_test.go b/idb/postgres/internal/migrations/convert_account_data/m_test.go
new file mode 100644
index 000000000..ba0665ba2
--- /dev/null
+++ b/idb/postgres/internal/migrations/convert_account_data/m_test.go
@@ -0,0 +1,270 @@
+package convertaccountdata_test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/algorand/go-algorand/data/basics"
+	"github.com/algorand/go-algorand/ledger/ledgercore"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/jackc/pgx/v4"
+	"github.com/jackc/pgx/v4/pgxpool"
+
+	"github.com/algorand/indexer/idb/postgres/internal/encoding"
+	cad "github.com/algorand/indexer/idb/postgres/internal/migrations/convert_account_data"
+	pgtest "github.com/algorand/indexer/idb/postgres/internal/testing"
+	pgutil "github.com/algorand/indexer/idb/postgres/internal/util"
+)
+
+func makeAddress(i int) basics.Address {
+	var address basics.Address
+	address[0] = byte(i)
+	return address
+}
+
+func insertAccount(t *testing.T, db *pgxpool.Pool, address basics.Address, trimmedAccountData *basics.AccountData) {
+	query := `INSERT INTO account (addr, microalgos, rewardsbase, rewards_total, deleted,
+		created_at, account_data) VALUES ($1, 0, 0, 0, false, 0, $2)`
+	_, err := db.Exec(
+		context.Background(), query, address[:],
+		encoding.EncodeTrimmedAccountData(*trimmedAccountData))
+	require.NoError(t, err)
+}
+
+func insertDeletedAccount(t *testing.T, db *pgxpool.Pool, address basics.Address) {
+	query := `INSERT INTO account (addr, microalgos, rewardsbase, rewards_total, deleted,
+		created_at, account_data) VALUES ($1, 0, 0, 0, true, 0, 'null'::jsonb)`
+	_, err := db.Exec(context.Background(), query, address[:])
+	require.NoError(t, err)
+}
+
+func checkAccount(t *testing.T, db *pgxpool.Pool, address basics.Address, accountData *ledgercore.AccountData) {
+	query := "SELECT account_data FROM account WHERE addr = $1"
+	row := db.QueryRow(context.Background(), query, address[:])
+
+	var buf []byte
+	err := row.Scan(&buf)
+	require.NoError(t, err)
+
+	ret, err := encoding.DecodeTrimmedLcAccountData(buf)
+	require.NoError(t, err)
+
+	assert.Equal(t, accountData, &ret)
+}
+
+func checkDeletedAccount(t *testing.T, db *pgxpool.Pool, address basics.Address) {
+	query := "SELECT account_data FROM account WHERE addr = $1"
+	row := db.QueryRow(context.Background(), query, address[:])
+
+	var buf []byte
+	err := row.Scan(&buf)
+	require.NoError(t, err)
+
+	assert.Equal(t, []byte("null"), buf)
+}
+
+func insertAccountAsset(t *testing.T, db *pgxpool.Pool, address basics.Address, assetid uint64, deleted bool) {
+	query := `INSERT INTO account_asset (addr, assetid, amount, frozen, deleted,
+		created_at) VALUES ($1, $2, 0, false, $3, 0)`
+	_, err := db.Exec(context.Background(), query, address[:], assetid, deleted)
+	require.NoError(t, err)
+}
+
+func insertAsset(t *testing.T, db *pgxpool.Pool, assetid uint64, address basics.Address, deleted bool) {
+	query := `INSERT INTO asset (index, creator_addr, params, deleted, created_at)
+		VALUES ($1, $2, 'null'::jsonb, $3, 0)`
+	_, err := db.Exec(context.Background(), query, assetid, address[:], deleted)
+	require.NoError(t, err)
+}
+
+func insertApp(t *testing.T, db *pgxpool.Pool, appid uint64, address basics.Address, deleted bool) {
+	query := `INSERT INTO app (index, creator, params, deleted, created_at)
+		VALUES ($1, $2, 'null'::jsonb, $3, 0)`
+	_, err := db.Exec(context.Background(), query, appid, address[:], deleted)
+	require.NoError(t, err)
+}
+
+func insertAccountApp(t *testing.T, db *pgxpool.Pool, address basics.Address, appid uint64, deleted bool) {
+	query := `INSERT INTO account_app (addr, app, localstate, deleted, created_at)
+		VALUES ($1, $2, 'null'::jsonb, $3, 0)`
+	_, err := db.Exec(context.Background(), query, address[:], appid, deleted)
+	require.NoError(t, err)
+}
+
+func TestBasic(t *testing.T) {
+	for _, i := range []int{1, 2, 3, 4} {
+		t.Run(fmt.Sprint(i), func(t *testing.T) {
+			db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+			defer shutdownFunc()
+
+			insertAccount(t, db, makeAddress(1), &basics.AccountData{VoteKeyDilution: 1})
+			insertDeletedAccount(t, db, makeAddress(2))
+			insertAccount(t, db, makeAddress(3), &basics.AccountData{VoteKeyDilution: 3})
+
+			f := func(tx pgx.Tx) error {
+				return cad.RunMigration(tx, 1)
+			}
+			err := pgutil.TxWithRetry(db, pgx.TxOptions{IsoLevel: pgx.Serializable}, f, nil)
+			require.NoError(t, err)
+
+			checkAccount(
+				t, db, makeAddress(1),
+				&ledgercore.AccountData{VotingData: ledgercore.VotingData{VoteKeyDilution: 1}})
+			checkDeletedAccount(t, db, makeAddress(2))
+			checkAccount(
+				t, db, makeAddress(3),
+				&ledgercore.AccountData{VotingData: ledgercore.VotingData{VoteKeyDilution: 3}})
+		})
+	}
+}
+
+func TestAccountAssetCount(t *testing.T) {
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
+
+	insertAccount(t, db, makeAddress(1), &basics.AccountData{VoteKeyDilution: 1})
+	for i := uint64(2); i < 10; i++ {
+		insertAccountAsset(t, db, makeAddress(1), i, i%2 == 0)
+	}
+
+	f := func(tx pgx.Tx) error {
+		return cad.RunMigration(tx, 1)
+	}
+	err := pgutil.TxWithRetry(db, pgx.TxOptions{IsoLevel: pgx.Serializable}, f, nil)
+	require.NoError(t, err)
+
+	expected := ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			TotalAssets: 4,
+		},
+		VotingData: ledgercore.VotingData{
+			VoteKeyDilution: 1,
+		},
+	}
+	checkAccount(t, db, makeAddress(1), &expected)
+}
+
+func TestAssetCount(t *testing.T) {
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
+
+	insertAccount(t, db, makeAddress(1), &basics.AccountData{VoteKeyDilution: 1})
+	for i := uint64(2); i < 10; i++ {
+		insertAsset(t, db, i, makeAddress(1), i%2 == 0)
+	}
+
+	f := func(tx pgx.Tx) error {
+		return cad.RunMigration(tx, 1)
+	}
+	err := pgutil.TxWithRetry(db, pgx.TxOptions{IsoLevel: pgx.Serializable}, f, nil)
+	require.NoError(t, err)
+
+	expected := ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			TotalAssetParams: 4,
+		},
+		VotingData: ledgercore.VotingData{
+			VoteKeyDilution: 1,
+		},
+	}
+	checkAccount(t, db, makeAddress(1), &expected)
+}
+
+func TestAppCount(t *testing.T) {
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
+
+	insertAccount(t, db, makeAddress(1), &basics.AccountData{VoteKeyDilution: 1})
+	for i := uint64(2); i < 10; i++ {
+		insertApp(t, db, i, makeAddress(1), i%2 == 0)
+	}
+
+	f := func(tx pgx.Tx) error {
+		return cad.RunMigration(tx, 1)
+	}
+	err := pgutil.TxWithRetry(db, pgx.TxOptions{IsoLevel: pgx.Serializable}, f, nil)
+	require.NoError(t, err)
+
+	expected := ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			TotalAppParams: 4,
+		},
+		VotingData: ledgercore.VotingData{
+			VoteKeyDilution: 1,
+		},
+	}
+	checkAccount(t, db, makeAddress(1), &expected)
+}
+
+func TestAccountAppCount(t *testing.T) {
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
+
+	insertAccount(t, db, makeAddress(1), &basics.AccountData{VoteKeyDilution: 1})
+	for i := uint64(2); i < 10; i++ {
+		insertAccountApp(t, db, makeAddress(1), i, i%2 == 0)
+	}
+
+	f := func(tx pgx.Tx) error {
+		return cad.RunMigration(tx, 1)
+	}
+	err := pgutil.TxWithRetry(db, pgx.TxOptions{IsoLevel: pgx.Serializable}, f, nil)
+	require.NoError(t, err)
+
+	expected := ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			TotalAppLocalStates: 4,
+		},
+		VotingData: ledgercore.VotingData{
+			VoteKeyDilution: 1,
+		},
+	}
+	checkAccount(t, db, makeAddress(1), &expected)
+}
+
+func TestAllResourcesMultipleAccounts(t *testing.T) {
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
+
+	numAccounts := 14
+
+	for i := 0; i < numAccounts; i++ {
+		insertAccount(t, db, makeAddress(i), &basics.AccountData{VoteKeyDilution: uint64(i)})
+		for j := uint64(20); j < 30; j++ {
+			insertAccountAsset(t, db, makeAddress(i), j, j%2 == 0)
+		}
+		for j := uint64(30); j < 50; j++ {
+			insertAsset(t, db, uint64(i)*1000+j, makeAddress(i), j%2 == 0)
+		}
+		for j := uint64(50); j < 80; j++ {
+			insertApp(t, db, uint64(i)*1000+j, makeAddress(i), j%2 == 0)
+		}
+		for j := uint64(80); j < 120; j++ {
+			insertAccountApp(t, db, makeAddress(i), j, j%2 == 0)
+		}
+	}
+
+	f := func(tx pgx.Tx) error {
+		return cad.RunMigration(tx, 5)
+	}
+	err := pgutil.TxWithRetry(db, pgx.TxOptions{IsoLevel: pgx.Serializable}, f, nil)
+	require.NoError(t, err)
+
+	for i := 0; i < numAccounts; i++ {
+		expected := ledgercore.AccountData{
+			AccountBaseData: ledgercore.AccountBaseData{
+				TotalAssets:         5,
+				TotalAssetParams:    10,
+				TotalAppParams:      15,
+				TotalAppLocalStates: 20,
+			},
+			VotingData: ledgercore.VotingData{
+				VoteKeyDilution: uint64(i),
+			},
+		}
+		checkAccount(t, db, makeAddress(i), &expected)
+	}
+}
diff --git a/idb/postgres/internal/schema/setup_postgres.sql b/idb/postgres/internal/schema/setup_postgres.sql
index fb3d63824..9337c0e10 100644
--- a/idb/postgres/internal/schema/setup_postgres.sql
+++ b/idb/postgres/internal/schema/setup_postgres.sql
@@ -49,7 +49,7 @@ CREATE TABLE IF NOT EXISTS account (
   created_at bigint NOT NULL, -- round that the account is first used
   closed_at bigint, -- round that the account was last closed
   keytype varchar(8), -- "sig", "msig", "lsig", or NULL if unknown
-  account_data jsonb NOT NULL -- trimmed AccountData that excludes the fields above and the four creatable maps; SQL 'NOT NULL' is held though the json string will be "null" iff account is deleted
+  account_data jsonb NOT NULL -- trimmed ledgercore.AccountData that excludes the fields above; SQL 'NOT NULL' is held though the json string will be "null" iff account is deleted
 );
 
 -- data.basics.AccountData Assets[asset id] AssetHolding{}
diff --git a/idb/postgres/internal/schema/setup_postgres_sql.go b/idb/postgres/internal/schema/setup_postgres_sql.go
index acad7851b..3d5fb0a2a 100644
--- a/idb/postgres/internal/schema/setup_postgres_sql.go
+++ b/idb/postgres/internal/schema/setup_postgres_sql.go
@@ -53,7 +53,7 @@ CREATE TABLE IF NOT EXISTS account (
   created_at bigint NOT NULL, -- round that the account is first used
   closed_at bigint, -- round that the account was last closed
   keytype varchar(8), -- "sig", "msig", "lsig", or NULL if unknown
-  account_data jsonb NOT NULL -- trimmed AccountData that excludes the fields above and the four creatable maps; SQL 'NOT NULL' is held though the json string will be "null" iff account is deleted
+  account_data jsonb NOT NULL -- trimmed ledgercore.AccountData that excludes the fields above; SQL 'NOT NULL' is held though the json string will be "null" iff account is deleted
 );
 
 -- data.basics.AccountData Assets[asset id] AssetHolding{}
diff --git a/idb/postgres/internal/testing/testing.go b/idb/postgres/internal/testing/testing.go
index 433225353..34f049ad5 100644
--- a/idb/postgres/internal/testing/testing.go
+++ b/idb/postgres/internal/testing/testing.go
@@ -10,6 +10,8 @@ import (
 	"github.com/orlangure/gnomock"
 	"github.com/orlangure/gnomock/preset/postgres"
 	"github.com/stretchr/testify/require"
+
+	"github.com/algorand/indexer/idb/postgres/internal/schema"
 )
 
 var testpg = flag.String(
@@ -61,3 +63,14 @@ func SetupPostgres(t *testing.T) (*pgxpool.Pool, string, func()) {
 
 	return db, connStr, shutdownFunc
 }
+
+// SetupPostgresWithSchema is equivalent to SetupPostgres() but also creates the
+// indexer schema.
+func SetupPostgresWithSchema(t *testing.T) (*pgxpool.Pool, string, func()) {
+	db, connStr, shutdownFunc := SetupPostgres(t)
+
+	_, err := db.Exec(context.Background(), schema.SetupPostgresSql)
+	require.NoError(t, err)
+
+	return db, connStr, shutdownFunc
+}
diff --git a/idb/postgres/internal/writer/writer.go b/idb/postgres/internal/writer/writer.go
index 0ba5e491f..9d61efae6 100644
--- a/idb/postgres/internal/writer/writer.go
+++ b/idb/postgres/internal/writer/writer.go
@@ -178,36 +178,7 @@ type optionalSigTypeDelta struct {
 	value   sigTypeDelta
 }
 
-func writeAccount(round basics.Round, address basics.Address, accountData basics.AccountData, sigtypeDelta optionalSigTypeDelta, batch *pgx.Batch) {
-	// Update `asset` table.
-	for assetid, params := range accountData.AssetParams {
-		batch.Queue(
-			upsertAssetStmtName,
-			uint64(assetid), address[:], encoding.EncodeAssetParams(params), uint64(round))
-	}
-
-	// Update `account_asset` table.
-	for assetid, holding := range accountData.Assets {
-		batch.Queue(
-			upsertAccountAssetStmtName,
-			address[:], uint64(assetid), strconv.FormatUint(holding.Amount, 10),
-			holding.Frozen, uint64(round))
-	}
-
-	// Update `app` table.
-	for appid, params := range accountData.AppParams {
-		batch.Queue(
-			upsertAppStmtName,
-			uint64(appid), address[:], encoding.EncodeAppParams(params), uint64(round))
-	}
-
-	// Update `account_app` table.
-	for appid, state := range accountData.AppLocalStates {
-		batch.Queue(
-			upsertAccountAppStmtName,
-			address[:], uint64(appid), encoding.EncodeAppLocalState(state), uint64(round))
-	}
-
+func writeAccount(round basics.Round, address basics.Address, accountData ledgercore.AccountData, sigtypeDelta optionalSigTypeDelta, batch *pgx.Batch) {
 	sigtypeFunc := func(delta sigTypeDelta) *idb.SigType {
 		if !delta.present {
 			return nil
@@ -218,7 +189,6 @@ func writeAccount(round basics.Round, address basics.Address, accountData basics
 		return res
 	}
 
-	// Update `account` table.
 	if accountData.IsZero() {
 		// Delete account.
 		if sigtypeDelta.present {
@@ -231,7 +201,7 @@ func writeAccount(round basics.Round, address basics.Address, accountData basics
 	} else {
 		// Update account.
 		accountDataJSON :=
-			encoding.EncodeTrimmedAccountData(encoding.TrimAccountData(accountData))
+			encoding.EncodeTrimmedLcAccountData(encoding.TrimLcAccountData(accountData))
 
 		if sigtypeDelta.present {
 			batch.Queue(
@@ -249,53 +219,75 @@ func writeAccount(round basics.Round, address basics.Address, accountData basics
 	}
 }
 
-func writeAccounts(round basics.Round, accountDeltas ledgercore.AccountDeltas, sigtypeDeltas map[basics.Address]sigTypeDelta, batch *pgx.Batch) {
-	// Update `account` table.
-	for i := 0; i < accountDeltas.Len(); i++ {
-		address, accountData := accountDeltas.GetByIdx(i)
-
-		var sigtypeDelta optionalSigTypeDelta
-		sigtypeDelta.value, sigtypeDelta.present = sigtypeDeltas[address]
-
-		writeAccount(round, address, accountData, sigtypeDelta, batch)
+func writeAssetResource(round basics.Round, resource *ledgercore.AssetResourceRecord, batch *pgx.Batch) {
+	if resource.Params.Deleted {
+		batch.Queue(deleteAssetStmtName, resource.Aidx, resource.Addr[:], round)
+	} else {
+		if resource.Params.Params != nil {
+			batch.Queue(
+				upsertAssetStmtName, resource.Aidx, resource.Addr[:],
+				encoding.EncodeAssetParams(*resource.Params.Params), round)
+		}
 	}
-}
 
-func writeDeletedCreatables(round basics.Round, creatables map[basics.CreatableIndex]ledgercore.ModifiedCreatable, batch *pgx.Batch) {
-	for index, creatable := range creatables {
-		// If deleted.
-		if !creatable.Created {
-			creator := new(basics.Address)
-			*creator = creatable.Creator
-
-			if creatable.Ctype == basics.AssetCreatable {
-				batch.Queue(deleteAssetStmtName, uint64(index), creator[:], uint64(round))
-			} else {
-				batch.Queue(deleteAppStmtName, uint64(index), creator[:], uint64(round))
-			}
+	if resource.Holding.Deleted {
+		batch.Queue(deleteAccountAssetStmtName, resource.Addr[:], resource.Aidx, round)
+	} else {
+		if resource.Holding.Holding != nil {
+			batch.Queue(
+				upsertAccountAssetStmtName, resource.Addr[:], resource.Aidx,
+				strconv.FormatUint(resource.Holding.Holding.Amount, 10),
+				resource.Holding.Holding.Frozen, round)
 		}
 	}
 }
 
-func writeDeletedAssetHoldings(round basics.Round, modifiedAssetHoldings map[ledgercore.AccountAsset]bool, batch *pgx.Batch) {
-	for aa, created := range modifiedAssetHoldings {
-		if !created {
-			address := new(basics.Address)
-			*address = aa.Address
+func writeAppResource(round basics.Round, resource *ledgercore.AppResourceRecord, batch *pgx.Batch) {
+	if resource.Params.Deleted {
+		batch.Queue(deleteAppStmtName, resource.Aidx, resource.Addr[:], round)
+	} else {
+		if resource.Params.Params != nil {
+			batch.Queue(
+				upsertAppStmtName, resource.Aidx, resource.Addr[:],
+				encoding.EncodeAppParams(*resource.Params.Params), round)
+		}
+	}
 
+	if resource.State.Deleted {
+		batch.Queue(deleteAccountAppStmtName, resource.Addr[:], resource.Aidx, round)
+	} else {
+		if resource.State.LocalState != nil {
 			batch.Queue(
-				deleteAccountAssetStmtName, address[:], uint64(aa.Asset), uint64(round))
+				upsertAccountAppStmtName, resource.Addr[:], resource.Aidx,
+				encoding.EncodeAppLocalState(*resource.State.LocalState), round)
 		}
 	}
 }
 
-func writeDeletedAppLocalStates(round basics.Round, modifiedAppLocalStates map[ledgercore.AccountApp]bool, batch *pgx.Batch) {
-	for aa, created := range modifiedAppLocalStates {
-		if !created {
-			address := new(basics.Address)
-			*address = aa.Address
+func writeAccountDeltas(round basics.Round, accountDeltas *ledgercore.AccountDeltas, sigtypeDeltas map[basics.Address]sigTypeDelta, batch *pgx.Batch) {
+	// Update `account` table.
+	for i := 0; i < accountDeltas.Len(); i++ {
+		address, accountData := accountDeltas.GetByIdx(i)
 
-			batch.Queue(deleteAccountAppStmtName, address[:], uint64(aa.App), uint64(round))
+		var sigtypeDelta optionalSigTypeDelta
+		sigtypeDelta.value, sigtypeDelta.present = sigtypeDeltas[address]
+
+		writeAccount(round, address, accountData, sigtypeDelta, batch)
+	}
+
+	// Update `asset` and `account_asset` tables.
+	{
+		assetResources := accountDeltas.GetAllAssetResources()
+		for i := range assetResources {
+			writeAssetResource(round, &assetResources[i], batch)
+		}
+	}
+
+	// Update `app` and `account_app` tables.
+	{
+		appResources := accountDeltas.GetAllAppResources()
+		for i := range appResources {
+			writeAppResource(round, &appResources[i], batch)
 		}
 	}
 }
@@ -345,11 +337,8 @@ func (w *Writer) AddBlock(block *bookkeeping.Block, modifiedTxns []transactions.
 		if err != nil {
 			return fmt.Errorf("AddBlock() err: %w", err)
 		}
-		writeAccounts(block.Round(), delta.Accts, sigTypeDeltas, &batch)
+		writeAccountDeltas(block.Round(), &delta.Accts, sigTypeDeltas, &batch)
 	}
-	writeDeletedCreatables(block.Round(), delta.Creatables, &batch)
-	writeDeletedAssetHoldings(block.Round(), delta.ModifiedAssetHoldings, &batch)
-	writeDeletedAppLocalStates(block.Round(), delta.ModifiedAppLocalStates, &batch)
 	batch.Queue(updateAccountTotalsStmtName, encoding.EncodeAccountTotals(&delta.Totals))
 
 	results := w.tx.SendBatch(context.Background(), &batch)
diff --git a/idb/postgres/internal/writer/writer_test.go b/idb/postgres/internal/writer/writer_test.go
index 70d57441e..3b0902c0e 100644
--- a/idb/postgres/internal/writer/writer_test.go
+++ b/idb/postgres/internal/writer/writer_test.go
@@ -29,15 +29,6 @@ import (
 
 var serializable = pgx.TxOptions{IsoLevel: pgx.Serializable}
 
-func setupPostgres(t *testing.T) (*pgxpool.Pool, func()) {
-	db, _, shutdownFunc := pgtest.SetupPostgres(t)
-
-	_, err := db.Exec(context.Background(), schema.SetupPostgresSql)
-	require.NoError(t, err)
-
-	return db, shutdownFunc
-}
-
 // makeTx is a helper to simplify calling TxWithRetry
 func makeTx(db *pgxpool.Pool, f func(tx pgx.Tx) error) error {
 	return pgutil.TxWithRetry(db, serializable, f, nil)
@@ -105,7 +96,7 @@ func txnParticipationQuery(db *pgxpool.Pool, query string) ([]txnParticipationRo
 }
 
 func TestWriterBlockHeaderTableBasic(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
@@ -146,7 +137,7 @@ func TestWriterBlockHeaderTableBasic(t *testing.T) {
 }
 
 func TestWriterSpecialAccounts(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	block := test.MakeGenesisBlock()
@@ -178,7 +169,7 @@ func TestWriterSpecialAccounts(t *testing.T) {
 }
 
 func TestWriterTxnTableBasic(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	block := bookkeeping.Block{
@@ -267,7 +258,7 @@ func TestWriterTxnTableBasic(t *testing.T) {
 // Test that asset close amount is written even if it is missing in the apply data
 // in the block (it is present in the "modified transactions").
 func TestWriterTxnTableAssetCloseAmount(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	block := bookkeeping.Block{
@@ -412,7 +403,7 @@ func TestWriterTxnParticipationTable(t *testing.T) {
 
 	for _, testcase := range tests {
 		t.Run(testcase.name, func(t *testing.T) {
-			db, shutdownFunc := setupPostgres(t)
+			db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 			defer shutdownFunc()
 
 			block := makeBlockFunc()
@@ -436,7 +427,7 @@ func TestWriterTxnParticipationTable(t *testing.T) {
 
 // Create a new account and then delete it.
 func TestWriterAccountTableBasic(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var voteID crypto.OneTimeSignatureVerifier
@@ -452,17 +443,21 @@ func TestWriterAccountTableBasic(t *testing.T) {
 	block.BlockHeader.Round = 4
 
 	var delta ledgercore.StateDelta
-	delta.Accts.Upsert(test.AccountA, basics.AccountData{
-		Status:             basics.Online,
-		MicroAlgos:         basics.MicroAlgos{Raw: 5},
-		RewardsBase:        6,
-		RewardedMicroAlgos: basics.MicroAlgos{Raw: 7},
-		VoteID:             voteID,
-		SelectionID:        selectionID,
-		VoteFirstValid:     7,
-		VoteLastValid:      8,
-		VoteKeyDilution:    9,
-		AuthAddr:           authAddr,
+	delta.Accts.Upsert(test.AccountA, ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			Status:             basics.Online,
+			MicroAlgos:         basics.MicroAlgos{Raw: 5},
+			RewardsBase:        6,
+			RewardedMicroAlgos: basics.MicroAlgos{Raw: 7},
+			AuthAddr:           authAddr,
+		},
+		VotingData: ledgercore.VotingData{
+			VoteID:          voteID,
+			SelectionID:     selectionID,
+			VoteFirstValid:  7,
+			VoteLastValid:   8,
+			VoteKeyDilution: 9,
+		},
 	})
 
 	f := func(tx pgx.Tx) error {
@@ -510,16 +505,9 @@ func TestWriterAccountTableBasic(t *testing.T) {
 	assert.Nil(t, closedAt)
 	assert.Nil(t, keytype)
 	{
-		accountDataRead, err := encoding.DecodeTrimmedAccountData(accountData)
+		accountDataRead, err := encoding.DecodeTrimmedLcAccountData(accountData)
 		require.NoError(t, err)
-
-		assert.Equal(t, expectedAccountData.Status, accountDataRead.Status)
-		assert.Equal(t, expectedAccountData.VoteID, accountDataRead.VoteID)
-		assert.Equal(t, expectedAccountData.SelectionID, accountDataRead.SelectionID)
-		assert.Equal(t, expectedAccountData.VoteFirstValid, accountDataRead.VoteFirstValid)
-		assert.Equal(t, expectedAccountData.VoteLastValid, accountDataRead.VoteLastValid)
-		assert.Equal(t, expectedAccountData.VoteKeyDilution, accountDataRead.VoteKeyDilution)
-		assert.Equal(t, expectedAccountData.AuthAddr, accountDataRead.AuthAddr)
+		assert.Equal(t, encoding.TrimLcAccountData(expectedAccountData), accountDataRead)
 	}
 
 	assert.False(t, rows.Next())
@@ -528,7 +516,7 @@ func TestWriterAccountTableBasic(t *testing.T) {
 	// Now delete this account.
 	block.BlockHeader.Round++
 	delta.Accts = ledgercore.AccountDeltas{}
-	delta.Accts.Upsert(test.AccountA, basics.AccountData{})
+	delta.Accts.Upsert(test.AccountA, ledgercore.AccountData{})
 
 	err = pgutil.TxWithRetry(db, serializable, f, nil)
 	require.NoError(t, err)
@@ -554,9 +542,9 @@ func TestWriterAccountTableBasic(t *testing.T) {
 	assert.Nil(t, keytype)
 	assert.Equal(t, []byte("null"), accountData)
 	{
-		accountData, err := encoding.DecodeTrimmedAccountData(accountData)
+		accountData, err := encoding.DecodeTrimmedLcAccountData(accountData)
 		require.NoError(t, err)
-		assert.Equal(t, basics.AccountData{}, accountData)
+		assert.Equal(t, ledgercore.AccountData{}, accountData)
 	}
 
 	assert.False(t, rows.Next())
@@ -565,14 +553,14 @@ func TestWriterAccountTableBasic(t *testing.T) {
 
 // Simulate the scenario where an account is created and deleted in the same round.
 func TestWriterAccountTableCreateDeleteSameRound(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
 	block.BlockHeader.Round = 4
 
 	var delta ledgercore.StateDelta
-	delta.Accts.Upsert(test.AccountA, basics.AccountData{})
+	delta.Accts.Upsert(test.AccountA, ledgercore.AccountData{})
 
 	f := func(tx pgx.Tx) error {
 		w, err := writer.MakeWriter(tx)
@@ -617,9 +605,9 @@ func TestWriterAccountTableCreateDeleteSameRound(t *testing.T) {
 	assert.Nil(t, keytype)
 	assert.Equal(t, []byte("null"), accountData)
 	{
-		accountData, err := encoding.DecodeTrimmedAccountData(accountData)
+		accountData, err := encoding.DecodeTrimmedLcAccountData(accountData)
 		require.NoError(t, err)
-		assert.Equal(t, basics.AccountData{}, accountData)
+		assert.Equal(t, ledgercore.AccountData{}, accountData)
 	}
 
 	assert.False(t, rows.Next())
@@ -627,7 +615,7 @@ func TestWriterAccountTableCreateDeleteSameRound(t *testing.T) {
 }
 
 func TestWriterDeleteAccountDoesNotDeleteKeytype(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	block := bookkeeping.Block{
@@ -651,8 +639,10 @@ func TestWriterDeleteAccountDoesNotDeleteKeytype(t *testing.T) {
 	require.NoError(t, err)
 
 	var delta ledgercore.StateDelta
-	delta.Accts.Upsert(test.AccountA, basics.AccountData{
-		MicroAlgos: basics.MicroAlgos{Raw: 5},
+	delta.Accts.Upsert(test.AccountA, ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			MicroAlgos: basics.MicroAlgos{Raw: 5},
+		},
 	})
 
 	f := func(tx pgx.Tx) error {
@@ -678,7 +668,7 @@ func TestWriterDeleteAccountDoesNotDeleteKeytype(t *testing.T) {
 	// Now delete this account.
 	block.BlockHeader.Round = basics.Round(5)
 	delta.Accts = ledgercore.AccountDeltas{}
-	delta.Accts.Upsert(test.AccountA, basics.AccountData{})
+	delta.Accts.Upsert(test.AccountA, ledgercore.AccountData{})
 
 	err = pgutil.TxWithRetry(db, serializable, f, nil)
 	require.NoError(t, err)
@@ -690,7 +680,7 @@ func TestWriterDeleteAccountDoesNotDeleteKeytype(t *testing.T) {
 }
 
 func TestWriterAccountAssetTableBasic(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
@@ -701,14 +691,10 @@ func TestWriterAccountAssetTableBasic(t *testing.T) {
 		Amount: 4,
 		Frozen: true,
 	}
-	accountData := basics.AccountData{
-		MicroAlgos: basics.MicroAlgos{Raw: 5},
-		Assets: map[basics.AssetIndex]basics.AssetHolding{
-			assetID: assetHolding,
-		},
-	}
 	var delta ledgercore.StateDelta
-	delta.Accts.Upsert(test.AccountA, accountData)
+	delta.Accts.UpsertAssetResource(
+		test.AccountA, assetID, ledgercore.AssetParamsDelta{},
+		ledgercore.AssetHoldingDelta{Holding: &assetHolding})
 
 	f := func(tx pgx.Tx) error {
 		w, err := writer.MakeWriter(tx)
@@ -753,12 +739,10 @@ func TestWriterAccountAssetTableBasic(t *testing.T) {
 	// Now delete the asset.
 	block.BlockHeader.Round++
 
-	delta.ModifiedAssetHoldings = map[ledgercore.AccountAsset]bool{
-		{Address: test.AccountA, Asset: assetID}: false,
-	}
-	accountData.Assets = nil
 	delta.Accts = ledgercore.AccountDeltas{}
-	delta.Accts.Upsert(test.AccountA, accountData)
+	delta.Accts.UpsertAssetResource(
+		test.AccountA, assetID, ledgercore.AssetParamsDelta{},
+		ledgercore.AssetHoldingDelta{Deleted: true})
 
 	err = pgutil.TxWithRetry(db, serializable, f, nil)
 	require.NoError(t, err)
@@ -786,18 +770,17 @@ func TestWriterAccountAssetTableBasic(t *testing.T) {
 
 // Simulate a scenario where an asset holding is added and deleted in the same round.
 func TestWriterAccountAssetTableCreateDeleteSameRound(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
 	block.BlockHeader.Round = basics.Round(1)
 
 	assetID := basics.AssetIndex(3)
-	delta := ledgercore.StateDelta{
-		ModifiedAssetHoldings: map[ledgercore.AccountAsset]bool{
-			{Address: test.AccountA, Asset: assetID}: false,
-		},
-	}
+	var delta ledgercore.StateDelta
+	delta.Accts.UpsertAssetResource(
+		test.AccountA, assetID, ledgercore.AssetParamsDelta{},
+		ledgercore.AssetHoldingDelta{Deleted: true})
 
 	f := func(tx pgx.Tx) error {
 		w, err := writer.MakeWriter(tx)
@@ -834,7 +817,7 @@ func TestWriterAccountAssetTableCreateDeleteSameRound(t *testing.T) {
 }
 
 func TestWriterAccountAssetTableLargeAmount(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
@@ -845,12 +828,9 @@ func TestWriterAccountAssetTableLargeAmount(t *testing.T) {
 		Amount: math.MaxUint64,
 	}
 	var delta ledgercore.StateDelta
-	delta.Accts.Upsert(test.AccountA, basics.AccountData{
-		MicroAlgos: basics.MicroAlgos{Raw: 5},
-		Assets: map[basics.AssetIndex]basics.AssetHolding{
-			assetID: assetHolding,
-		},
-	})
+	delta.Accts.UpsertAssetResource(
+		test.AccountA, assetID, ledgercore.AssetParamsDelta{},
+		ledgercore.AssetHoldingDelta{Holding: &assetHolding})
 
 	f := func(tx pgx.Tx) error {
 		w, err := writer.MakeWriter(tx)
@@ -874,7 +854,7 @@ func TestWriterAccountAssetTableLargeAmount(t *testing.T) {
 }
 
 func TestWriterAssetTableBasic(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
@@ -885,14 +865,10 @@ func TestWriterAssetTableBasic(t *testing.T) {
 		Total:   99999,
 		Manager: test.AccountB,
 	}
-	accountData := basics.AccountData{
-		MicroAlgos: basics.MicroAlgos{Raw: 5},
-		AssetParams: map[basics.AssetIndex]basics.AssetParams{
-			assetID: assetParams,
-		},
-	}
 	var delta ledgercore.StateDelta
-	delta.Accts.Upsert(test.AccountA, accountData)
+	delta.Accts.UpsertAssetResource(
+		test.AccountA, assetID, ledgercore.AssetParamsDelta{Params: &assetParams},
+		ledgercore.AssetHoldingDelta{})
 
 	f := func(tx pgx.Tx) error {
 		w, err := writer.MakeWriter(tx)
@@ -939,16 +915,10 @@ func TestWriterAssetTableBasic(t *testing.T) {
 	// Now delete the asset.
 	block.BlockHeader.Round++
 
-	delta.Creatables = map[basics.CreatableIndex]ledgercore.ModifiedCreatable{
-		basics.CreatableIndex(assetID): {
-			Ctype:   basics.AssetCreatable,
-			Created: false,
-			Creator: test.AccountA,
-		},
-	}
-	accountData.AssetParams = nil
 	delta.Accts = ledgercore.AccountDeltas{}
-	delta.Accts.Upsert(test.AccountA, accountData)
+	delta.Accts.UpsertAssetResource(
+		test.AccountA, assetID, ledgercore.AssetParamsDelta{Deleted: true},
+		ledgercore.AssetHoldingDelta{})
 
 	err = pgutil.TxWithRetry(db, serializable, f, nil)
 	require.NoError(t, err)
@@ -980,22 +950,17 @@ func TestWriterAssetTableBasic(t *testing.T) {
 
 // Simulate a scenario where an asset is added and deleted in the same round.
 func TestWriterAssetTableCreateDeleteSameRound(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
 	block.BlockHeader.Round = basics.Round(1)
 
 	assetID := basics.AssetIndex(3)
-	delta := ledgercore.StateDelta{
-		Creatables: map[basics.CreatableIndex]ledgercore.ModifiedCreatable{
-			basics.CreatableIndex(assetID): {
-				Ctype:   basics.AssetCreatable,
-				Created: false,
-				Creator: test.AccountA,
-			},
-		},
-	}
+	var delta ledgercore.StateDelta
+	delta.Accts.UpsertAssetResource(
+		test.AccountA, assetID, ledgercore.AssetParamsDelta{Deleted: true},
+		ledgercore.AssetHoldingDelta{})
 
 	f := func(tx pgx.Tx) error {
 		w, err := writer.MakeWriter(tx)
@@ -1035,7 +1000,7 @@ func TestWriterAssetTableCreateDeleteSameRound(t *testing.T) {
 }
 
 func TestWriterAppTableBasic(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
@@ -1050,14 +1015,10 @@ func TestWriterAppTableBasic(t *testing.T) {
 			},
 		},
 	}
-	accountData := basics.AccountData{
-		MicroAlgos: basics.MicroAlgos{Raw: 5},
-		AppParams: map[basics.AppIndex]basics.AppParams{
-			appID: appParams,
-		},
-	}
 	var delta ledgercore.StateDelta
-	delta.Accts.Upsert(test.AccountA, accountData)
+	delta.Accts.UpsertAppResource(
+		test.AccountA, appID, ledgercore.AppParamsDelta{Params: &appParams},
+		ledgercore.AppLocalStateDelta{})
 
 	f := func(tx pgx.Tx) error {
 		w, err := writer.MakeWriter(tx)
@@ -1104,16 +1065,10 @@ func TestWriterAppTableBasic(t *testing.T) {
 	// Now delete the app.
 	block.BlockHeader.Round++
 
-	delta.Creatables = map[basics.CreatableIndex]ledgercore.ModifiedCreatable{
-		basics.CreatableIndex(appID): {
-			Ctype:   basics.AppCreatable,
-			Created: false,
-			Creator: test.AccountA,
-		},
-	}
-	accountData.AppParams = nil
 	delta.Accts = ledgercore.AccountDeltas{}
-	delta.Accts.Upsert(test.AccountA, accountData)
+	delta.Accts.UpsertAppResource(
+		test.AccountA, appID, ledgercore.AppParamsDelta{Deleted: true},
+		ledgercore.AppLocalStateDelta{})
 
 	err = pgutil.TxWithRetry(db, serializable, f, nil)
 	require.NoError(t, err)
@@ -1145,22 +1100,17 @@ func TestWriterAppTableBasic(t *testing.T) {
 
 // Simulate a scenario where an app is added and deleted in the same round.
 func TestWriterAppTableCreateDeleteSameRound(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
 	block.BlockHeader.Round = basics.Round(1)
 
 	appID := basics.AppIndex(3)
-	delta := ledgercore.StateDelta{
-		Creatables: map[basics.CreatableIndex]ledgercore.ModifiedCreatable{
-			basics.CreatableIndex(appID): {
-				Ctype:   basics.AppCreatable,
-				Created: false,
-				Creator: test.AccountA,
-			},
-		},
-	}
+	var delta ledgercore.StateDelta
+	delta.Accts.UpsertAppResource(
+		test.AccountA, appID, ledgercore.AppParamsDelta{Deleted: true},
+		ledgercore.AppLocalStateDelta{})
 
 	f := func(tx pgx.Tx) error {
 		w, err := writer.MakeWriter(tx)
@@ -1201,7 +1151,7 @@ func TestWriterAppTableCreateDeleteSameRound(t *testing.T) {
 }
 
 func TestWriterAccountAppTableBasic(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
@@ -1215,14 +1165,10 @@ func TestWriterAccountAppTableBasic(t *testing.T) {
 			},
 		},
 	}
-	accountData := basics.AccountData{
-		MicroAlgos: basics.MicroAlgos{Raw: 5},
-		AppLocalStates: map[basics.AppIndex]basics.AppLocalState{
-			appID: appLocalState,
-		},
-	}
 	var delta ledgercore.StateDelta
-	delta.Accts.Upsert(test.AccountA, accountData)
+	delta.Accts.UpsertAppResource(
+		test.AccountA, appID, ledgercore.AppParamsDelta{},
+		ledgercore.AppLocalStateDelta{LocalState: &appLocalState})
 
 	f := func(tx pgx.Tx) error {
 		w, err := writer.MakeWriter(tx)
@@ -1269,12 +1215,10 @@ func TestWriterAccountAppTableBasic(t *testing.T) {
 	// Now delete the app.
 	block.BlockHeader.Round++
 
-	delta.ModifiedAppLocalStates = map[ledgercore.AccountApp]bool{
-		{Address: test.AccountA, App: appID}: false,
-	}
-	accountData.AppLocalStates = nil
 	delta.Accts = ledgercore.AccountDeltas{}
-	delta.Accts.Upsert(test.AccountA, accountData)
+	delta.Accts.UpsertAppResource(
+		test.AccountA, appID, ledgercore.AppParamsDelta{},
+		ledgercore.AppLocalStateDelta{Deleted: true})
 
 	err = pgutil.TxWithRetry(db, serializable, f, nil)
 	require.NoError(t, err)
@@ -1306,18 +1250,17 @@ func TestWriterAccountAppTableBasic(t *testing.T) {
 
 // Simulate a scenario where an account app is added and deleted in the same round.
 func TestWriterAccountAppTableCreateDeleteSameRound(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	var block bookkeeping.Block
 	block.BlockHeader.Round = basics.Round(1)
 
 	appID := basics.AppIndex(3)
-	delta := ledgercore.StateDelta{
-		ModifiedAppLocalStates: map[ledgercore.AccountApp]bool{
-			{Address: test.AccountA, App: appID}: false,
-		},
-	}
+	var delta ledgercore.StateDelta
+	delta.Accts.UpsertAppResource(
+		test.AccountA, appID, ledgercore.AppParamsDelta{},
+		ledgercore.AppLocalStateDelta{Deleted: true})
 
 	f := func(tx pgx.Tx) error {
 		w, err := writer.MakeWriter(tx)
@@ -1357,7 +1300,7 @@ func TestWriterAccountAppTableCreateDeleteSameRound(t *testing.T) {
 }
 
 func TestAddBlockInvalidInnerAsset(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	callWithBadInner := test.MakeCreateAppTxn(test.AccountA)
@@ -1391,7 +1334,7 @@ func TestAddBlockInvalidInnerAsset(t *testing.T) {
 }
 
 func TestWriterAddBlockInnerTxnsAssetCreate(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	// App call with inner txns, should be intra 0, 1, 2, 3, 4
@@ -1529,7 +1472,7 @@ func TestWriterAddBlockInnerTxnsAssetCreate(t *testing.T) {
 }
 
 func TestWriterAccountTotals(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	// Set empty account totals.
@@ -1567,7 +1510,7 @@ func TestWriterAccountTotals(t *testing.T) {
 }
 
 func TestWriterAddBlock0(t *testing.T) {
-	db, shutdownFunc := setupPostgres(t)
+	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
 	defer shutdownFunc()
 
 	block := test.MakeGenesisBlock()
diff --git a/idb/postgres/postgres.go b/idb/postgres/postgres.go
index 8a3d20784..6fc9b44d5 100644
--- a/idb/postgres/postgres.go
+++ b/idb/postgres/postgres.go
@@ -21,7 +21,6 @@ import (
 	"github.com/algorand/go-algorand/data/transactions"
 	"github.com/algorand/go-algorand/ledger"
 	"github.com/algorand/go-algorand/ledger/ledgercore"
-	"github.com/algorand/go-algorand/protocol"
 
 	"github.com/jackc/pgconn"
 	"github.com/jackc/pgerrcode"
@@ -179,75 +178,60 @@ func (db *IndexerDb) init(opts idb.IndexerDbOptions) (chan struct{}, error) {
 	return db.runAvailableMigrations()
 }
 
-// Returns all addresses referenced in `block`.
-func getBlockAddresses(block *bookkeeping.Block) map[basics.Address]struct{} {
-	// Reserve a reasonable memory size for the map.
-	res := make(map[basics.Address]struct{}, len(block.Payset)+2)
+// Preload asset and app creators.
+func prepareCreators(l *ledger_for_evaluator.LedgerForEvaluator, payset transactions.Payset) (map[basics.AssetIndex]ledger.FoundAddress, map[basics.AppIndex]ledger.FoundAddress, error) {
+	assetsReq, appsReq := accounting.MakePreloadCreatorsRequest(payset)
 
-	res[block.FeeSink] = struct{}{}
-	res[block.RewardsPool] = struct{}{}
-	for _, stib := range block.Payset {
-		addFunc := func(address basics.Address) {
-			res[address] = struct{}{}
-		}
-		accounting.GetTransactionParticipants(&stib.SignedTxnWithAD, true, addFunc)
+	assets, err := l.GetAssetCreator(assetsReq)
+	if err != nil {
+		return nil, nil, fmt.Errorf("prepareCreators() err: %w", err)
+	}
+	apps, err := l.GetAppCreator(appsReq)
+	if err != nil {
+		return nil, nil, fmt.Errorf("prepareCreators() err: %w", err)
 	}
 
-	return res
+	return assets, apps, nil
 }
 
-func prepareEvalResources(l *ledger_for_evaluator.LedgerForEvaluator, block *bookkeeping.Block) (ledger.EvalForIndexerResources, error) {
-	addresses := getBlockAddresses(block)
-	assets := make(map[basics.AssetIndex]struct{})
-	apps := make(map[basics.AppIndex]struct{})
+// Preload account data and account resources.
+func prepareAccountsResources(l *ledger_for_evaluator.LedgerForEvaluator, payset transactions.Payset, assetCreators map[basics.AssetIndex]ledger.FoundAddress, appCreators map[basics.AppIndex]ledger.FoundAddress) (map[basics.Address]*ledgercore.AccountData, map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource, error) {
+	addressesReq, resourcesReq :=
+		accounting.MakePreloadAccountsResourcesRequest(payset, assetCreators, appCreators)
 
-	for _, stib := range block.Payset {
-		switch stib.Txn.Type {
-		case protocol.AssetConfigTx:
-			if stib.Txn.ConfigAsset != 0 {
-				assets[stib.Txn.ConfigAsset] = struct{}{}
-			}
-		case protocol.AssetTransferTx:
-			if stib.Txn.XferAsset != 0 {
-				assets[stib.Txn.XferAsset] = struct{}{}
-			}
-		case protocol.AssetFreezeTx:
-			if stib.Txn.FreezeAsset != 0 {
-				assets[stib.Txn.FreezeAsset] = struct{}{}
-			}
-		case protocol.ApplicationCallTx:
-			if stib.Txn.ApplicationID != 0 {
-				apps[stib.Txn.ApplicationID] = struct{}{}
-			}
-		}
+	accounts, err := l.LookupWithoutRewards(addressesReq)
+	if err != nil {
+		return nil, nil, fmt.Errorf("prepareAccountsResources() err: %w", err)
 	}
-
-	res := ledger.EvalForIndexerResources{
-		Accounts: nil,
-		Creators: make(map[ledger.Creatable]ledger.FoundAddress),
+	resources, err := l.LookupResources(resourcesReq)
+	if err != nil {
+		return nil, nil, fmt.Errorf("prepareAccountsResources() err: %w", err)
 	}
 
-	assetCreators, err := l.GetAssetCreator(assets)
+	return accounts, resources, nil
+}
+
+// Preload all resources (account data, account resources, asset/app creators) for the
+// evaluator.
+func prepareEvalResources(l *ledger_for_evaluator.LedgerForEvaluator, block *bookkeeping.Block) (ledger.EvalForIndexerResources, error) {
+	assetCreators, appCreators, err := prepareCreators(l, block.Payset)
 	if err != nil {
 		return ledger.EvalForIndexerResources{},
 			fmt.Errorf("prepareEvalResources() err: %w", err)
 	}
+
+	res := ledger.EvalForIndexerResources{
+		Accounts:  nil,
+		Resources: nil,
+		Creators:  make(map[ledger.Creatable]ledger.FoundAddress),
+	}
+
 	for index, foundAddress := range assetCreators {
 		creatable := ledger.Creatable{
 			Index: basics.CreatableIndex(index),
 			Type:  basics.AssetCreatable,
 		}
 		res.Creators[creatable] = foundAddress
-
-		if foundAddress.Exists {
-			addresses[foundAddress.Address] = struct{}{}
-		}
-	}
-
-	appCreators, err := l.GetAppCreator(apps)
-	if err != nil {
-		return ledger.EvalForIndexerResources{},
-			fmt.Errorf("prepareEvalResources() err: %w", err)
 	}
 	for index, foundAddress := range appCreators {
 		creatable := ledger.Creatable{
@@ -255,13 +239,9 @@ func prepareEvalResources(l *ledger_for_evaluator.LedgerForEvaluator, block *boo
 			Type:  basics.AppCreatable,
 		}
 		res.Creators[creatable] = foundAddress
-
-		if foundAddress.Exists {
-			addresses[foundAddress.Address] = struct{}{}
-		}
 	}
 
-	res.Accounts, err = l.LookupWithoutRewards(addresses)
+	res.Accounts, res.Resources, err = prepareAccountsResources(l, block.Payset, assetCreators, appCreators)
 	if err != nil {
 		return ledger.EvalForIndexerResources{},
 			fmt.Errorf("prepareEvalResources() err: %w", err)
@@ -447,15 +427,16 @@ func (db *IndexerDb) LoadGenesis(genesis bookkeeping.Genesis) error {
 			if len(alloc.State.AssetParams) > 0 || len(alloc.State.Assets) > 0 {
 				return fmt.Errorf("LoadGenesis() genesis account[%d] has unhandled asset", ai)
 			}
+			accountData := ledgercore.ToAccountData(alloc.State)
 			_, err = tx.Exec(
 				context.Background(), setAccountStatementName,
 				addr[:], alloc.State.MicroAlgos.Raw,
-				encoding.EncodeTrimmedAccountData(encoding.TrimAccountData(alloc.State)), 0)
+				encoding.EncodeTrimmedLcAccountData(encoding.TrimLcAccountData(accountData)), 0)
 			if err != nil {
 				return fmt.Errorf("LoadGenesis() error setting genesis account[%d], %w", ai, err)
 			}
 
-			totals.AddAccount(proto, alloc.State, &ot)
+			totals.AddAccount(proto, accountData, &ot)
 		}
 
 		err = db.setMetastate(
@@ -1126,37 +1107,22 @@ func (db *IndexerDb) yieldAccountsThread(req *getAccountsRequest) {
 		var localStateClosedBytes []byte
 		var localStateDeletedBytes []byte
 
-		var err error
-
-		if req.opts.IncludeAssetHoldings && req.opts.IncludeAssetParams {
-			err = req.rows.Scan(
-				&addr, &microalgos, &rewardstotal, &createdat, &closedat, &deleted, &rewardsbase, &keytype, &accountDataJSONStr,
-				&holdingAssetids, &holdingAmount, &holdingFrozen, &holdingCreatedBytes, &holdingClosedBytes, &holdingDeletedBytes,
-				&assetParamsIds, &assetParamsStr, &assetParamsCreatedBytes, &assetParamsClosedBytes, &assetParamsDeletedBytes,
-				&appParamIndexes, &appParams, &appCreatedBytes, &appClosedBytes, &appDeletedBytes, &localStateAppIds, &localStates,
-				&localStateCreatedBytes, &localStateClosedBytes, &localStateDeletedBytes,
-			)
-		} else if req.opts.IncludeAssetHoldings {
-			err = req.rows.Scan(
-				&addr, &microalgos, &rewardstotal, &createdat, &closedat, &deleted, &rewardsbase, &keytype, &accountDataJSONStr,
-				&holdingAssetids, &holdingAmount, &holdingFrozen, &holdingCreatedBytes, &holdingClosedBytes, &holdingDeletedBytes,
-				&appParamIndexes, &appParams, &appCreatedBytes, &appClosedBytes, &appDeletedBytes, &localStateAppIds, &localStates,
-				&localStateCreatedBytes, &localStateClosedBytes, &localStateDeletedBytes,
-			)
-		} else if req.opts.IncludeAssetParams {
-			err = req.rows.Scan(
-				&addr, &microalgos, &rewardstotal, &createdat, &closedat, &deleted, &rewardsbase, &keytype, &accountDataJSONStr,
-				&assetParamsIds, &assetParamsStr, &assetParamsCreatedBytes, &assetParamsClosedBytes, &assetParamsDeletedBytes,
-				&appParamIndexes, &appParams, &appCreatedBytes, &appClosedBytes, &appDeletedBytes, &localStateAppIds, &localStates,
-				&localStateCreatedBytes, &localStateClosedBytes, &localStateDeletedBytes,
-			)
-		} else {
-			err = req.rows.Scan(
-				&addr, &microalgos, &rewardstotal, &createdat, &closedat, &deleted, &rewardsbase, &keytype, &accountDataJSONStr,
-				&appParamIndexes, &appParams, &appCreatedBytes, &appClosedBytes, &appDeletedBytes, &localStateAppIds, &localStates,
-				&localStateCreatedBytes, &localStateClosedBytes, &localStateDeletedBytes,
-			)
+		// build list of columns to scan using include options like buildAccountQuery
+		cols := []interface{}{&addr, &microalgos, &rewardstotal, &createdat, &closedat, &deleted, &rewardsbase, &keytype, &accountDataJSONStr}
+		if req.opts.IncludeAssetHoldings {
+			cols = append(cols, &holdingAssetids, &holdingAmount, &holdingFrozen, &holdingCreatedBytes, &holdingClosedBytes, &holdingDeletedBytes)
+		}
+		if req.opts.IncludeAssetParams {
+			cols = append(cols, &assetParamsIds, &assetParamsStr, &assetParamsCreatedBytes, &assetParamsClosedBytes, &assetParamsDeletedBytes)
+		}
+		if req.opts.IncludeAppParams {
+			cols = append(cols, &appParamIndexes, &appParams, &appCreatedBytes, &appClosedBytes, &appDeletedBytes)
 		}
+		if req.opts.IncludeAppLocalState {
+			cols = append(cols, &localStateAppIds, &localStates, &localStateCreatedBytes, &localStateClosedBytes, &localStateDeletedBytes)
+		}
+
+		err := req.rows.Scan(cols...)
 		if err != nil {
 			err = fmt.Errorf("account scan err %v", err)
 			req.out <- idb.AccountRow{Error: err}
@@ -1182,8 +1148,8 @@ func (db *IndexerDb) yieldAccountsThread(req *getAccountsRequest) {
 		}
 
 		{
-			var ad basics.AccountData
-			ad, err = encoding.DecodeTrimmedAccountData(accountDataJSONStr)
+			var ad ledgercore.AccountData
+			ad, err = encoding.DecodeTrimmedLcAccountData(accountDataJSONStr)
 			if err != nil {
 				err = fmt.Errorf("account decode err (%s) %v", accountDataJSONStr, err)
 				req.out <- idb.AccountRow{Error: err}
@@ -1229,6 +1195,11 @@ func (db *IndexerDb) yieldAccountsThread(req *getAccountsRequest) {
 			if ad.TotalExtraAppPages != 0 {
 				account.AppsTotalExtraPages = uint64Ptr(uint64(ad.TotalExtraAppPages))
 			}
+
+			account.TotalAppsOptedIn = ad.TotalAppLocalStates
+			account.TotalCreatedApps = ad.TotalAppParams
+			account.TotalAssetsOptedIn = ad.TotalAssets
+			account.TotalCreatedAssets = ad.TotalAssetParams
 		}
 
 		if account.Status == "NotParticipating" {
@@ -1324,7 +1295,7 @@ func (db *IndexerDb) yieldAccountsThread(req *getAccountsRequest) {
 					OptedOutAtRound: holdingClosed[i],
 					OptedInAtRound:  holdingCreated[i],
 					Deleted:         holdingDeleted[i],
-				} // TODO: set Creator to asset creator addr string
+				}
 				av = append(av, tah)
 			}
 			account.Assets = new([]models.AssetHolding)
@@ -1713,8 +1684,19 @@ func (db *IndexerDb) GetAccounts(ctx context.Context, opts idb.AccountQueryOptio
 		return out, round
 	}
 
+	// Enforce max combined # of app & asset resources per account limit, if set
+	if opts.MaxResources != 0 {
+		err = db.checkAccountResourceLimit(ctx, tx, opts)
+		if err != nil {
+			out <- idb.AccountRow{Error: err}
+			close(out)
+			tx.Rollback(ctx)
+			return out, round
+		}
+	}
+
 	// Construct query for fetching accounts...
-	query, whereArgs := db.buildAccountQuery(opts)
+	query, whereArgs := db.buildAccountQuery(opts, false)
 	req := &getAccountsRequest{
 		opts:        opts,
 		blockheader: blockheader,
@@ -1738,9 +1720,114 @@ func (db *IndexerDb) GetAccounts(ctx context.Context, opts idb.AccountQueryOptio
 	return out, round
 }
 
-func (db *IndexerDb) buildAccountQuery(opts idb.AccountQueryOptions) (query string, whereArgs []interface{}) {
+func (db *IndexerDb) checkAccountResourceLimit(ctx context.Context, tx pgx.Tx, opts idb.AccountQueryOptions) error {
+	// skip check if no resources are requested
+	if !opts.IncludeAssetHoldings && !opts.IncludeAssetParams && !opts.IncludeAppLocalState && !opts.IncludeAppParams {
+		return nil
+	}
+
+	// make a copy of the filters requested
+	o := opts
+	var countOnly bool
+
+	if opts.IncludeDeleted {
+		// if IncludeDeleted is set, need to construct a query (preserving filters) to count deleted values that would be returned from
+		// asset, app, account_asset, account_app
+		countOnly = true
+	} else {
+		// if IncludeDeleted is not set, query AccountData with no resources (preserving filters), to read ad.TotalX counts inside
+		o.IncludeAssetHoldings = false
+		o.IncludeAssetParams = false
+		o.IncludeAppLocalState = false
+		o.IncludeAppParams = false
+	}
+
+	query, whereArgs := db.buildAccountQuery(o, countOnly)
+	rows, err := tx.Query(ctx, query, whereArgs...)
+	if err != nil {
+		return fmt.Errorf("account limit query %#v err %v", query, err)
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var addr []byte
+		var microalgos uint64
+		var rewardstotal uint64
+		var createdat sql.NullInt64
+		var closedat sql.NullInt64
+		var deleted sql.NullBool
+		var rewardsbase uint64
+		var keytype *string
+		var accountDataJSONStr []byte
+		var holdingCount, assetCount, appCount, lsCount uint64
+		cols := []interface{}{&addr, &microalgos, &rewardstotal, &createdat, &closedat, &deleted, &rewardsbase, &keytype, &accountDataJSONStr}
+		if countOnly {
+			if o.IncludeAssetHoldings {
+				cols = append(cols, &holdingCount)
+			}
+			if o.IncludeAssetParams {
+				cols = append(cols, &assetCount)
+			}
+			if o.IncludeAppParams {
+				cols = append(cols, &appCount)
+			}
+			if o.IncludeAppLocalState {
+				cols = append(cols, &lsCount)
+			}
+		}
+		err := rows.Scan(cols...)
+		if err != nil {
+			return fmt.Errorf("account limit scan err %v", err)
+		}
+
+		var ad ledgercore.AccountData
+		ad, err = encoding.DecodeTrimmedLcAccountData(accountDataJSONStr)
+		if err != nil {
+			return fmt.Errorf("account limit decode err (%s) %v", accountDataJSONStr, err)
+		}
+
+		// check limit against filters (only count what would be returned)
+		var resultCount, totalAssets, totalAssetParams, totalAppLocalStates, totalAppParams uint64
+		if countOnly {
+			totalAssets = holdingCount
+			totalAssetParams = assetCount
+			totalAppLocalStates = lsCount
+			totalAppParams = appCount
+		} else {
+			totalAssets = ad.TotalAssets
+			totalAssetParams = ad.TotalAssetParams
+			totalAppLocalStates = ad.TotalAppLocalStates
+			totalAppParams = ad.TotalAppParams
+		}
+		if opts.IncludeAssetHoldings {
+			resultCount += totalAssets
+		}
+		if opts.IncludeAssetParams {
+			resultCount += totalAssetParams
+		}
+		if opts.IncludeAppLocalState {
+			resultCount += totalAppLocalStates
+		}
+		if opts.IncludeAppParams {
+			resultCount += totalAppParams
+		}
+		if resultCount > opts.MaxResources {
+			var aaddr basics.Address
+			copy(aaddr[:], addr)
+			return idb.MaxAPIResourcesPerAccountError{
+				Address:             aaddr,
+				TotalAppLocalStates: totalAppLocalStates,
+				TotalAppParams:      totalAppParams,
+				TotalAssets:         totalAssets,
+				TotalAssetParams:    totalAssetParams,
+			}
+		}
+	}
+	return nil
+}
+
+func (db *IndexerDb) buildAccountQuery(opts idb.AccountQueryOptions, countOnly bool) (query string, whereArgs []interface{}) {
 	// Construct query for fetching accounts...
-	const maxWhereParts = 14
+	const maxWhereParts = 9
 	whereParts := make([]string, 0, maxWhereParts)
 	whereArgs = make([]interface{}, 0, maxWhereParts)
 	partNumber := 1
@@ -1790,7 +1877,7 @@ func (db *IndexerDb) buildAccountQuery(opts idb.AccountQueryOptions) (query stri
 		partNumber++
 	}
 	if !opts.IncludeDeleted {
-		whereParts = append(whereParts, "coalesce(a.deleted, false) = false")
+		whereParts = append(whereParts, "NOT a.deleted")
 	}
 	if len(opts.EqualToAuthAddr) > 0 {
 		whereParts = append(whereParts, fmt.Sprintf("a.account_data ->> 'spend' = $%d", partNumber))
@@ -1814,42 +1901,91 @@ func (db *IndexerDb) buildAccountQuery(opts idb.AccountQueryOptions) (query stri
 	if opts.Limit != 0 {
 		query += fmt.Sprintf(" LIMIT %d", opts.Limit)
 	}
-	// TODO: asset holdings and asset params are optional, but practically always used. Either make them actually always on, or make app-global and app-local clauses also optional (they are currently always on).
+
 	withClauses = append(withClauses, "qaccounts AS ("+query+")")
 	query = "WITH " + strings.Join(withClauses, ", ")
-	if opts.IncludeDeleted {
-		if opts.IncludeAssetHoldings {
-			query += `, qaa AS (SELECT xa.addr, json_agg(aa.assetid) as haid, json_agg(aa.amount) as hamt, json_agg(aa.frozen) as hf, json_agg(aa.created_at) as holding_created_at, json_agg(aa.closed_at) as holding_closed_at, json_agg(coalesce(aa.deleted, false)) as holding_deleted FROM account_asset aa JOIN qaccounts xa ON aa.addr = xa.addr GROUP BY 1)`
+
+	// build nested selects for querying app/asset data associated with an address
+	if opts.IncludeAssetHoldings {
+		var where, selectCols string
+		if !opts.IncludeDeleted {
+			where = ` WHERE NOT aa.deleted`
 		}
-		if opts.IncludeAssetParams {
-			query += `, qap AS (SELECT ya.addr, json_agg(ap.index) as paid, json_agg(ap.params) as pp, json_agg(ap.created_at) as asset_created_at, json_agg(ap.closed_at) as asset_closed_at, json_agg(ap.deleted) as asset_deleted FROM asset ap JOIN qaccounts ya ON ap.creator_addr = ya.addr GROUP BY 1)`
+		if countOnly {
+			selectCols = `count(*) as holding_count`
+		} else {
+			selectCols = `json_agg(aa.assetid) as haid, json_agg(aa.amount) as hamt, json_agg(aa.frozen) as hf, json_agg(aa.created_at) as holding_created_at, json_agg(aa.closed_at) as holding_closed_at, json_agg(aa.deleted) as holding_deleted`
 		}
-		// app
-		query += `, qapp AS (SELECT app.creator as addr, json_agg(app.index) as papps, json_agg(app.params) as ppa, json_agg(app.created_at) as app_created_at, json_agg(app.closed_at) as app_closed_at, json_agg(app.deleted) as app_deleted FROM app JOIN qaccounts ON qaccounts.addr = app.creator GROUP BY 1)`
-		// app localstate
-		query += `, qls AS (SELECT la.addr, json_agg(la.app) as lsapps, json_agg(la.localstate) as lsls, json_agg(la.created_at) as ls_created_at, json_agg(la.closed_at) as ls_closed_at, json_agg(la.deleted) as ls_deleted FROM account_app la JOIN qaccounts ON qaccounts.addr = la.addr GROUP BY 1)`
-	} else {
-		if opts.IncludeAssetHoldings {
-			query += `, qaa AS (SELECT xa.addr, json_agg(aa.assetid) as haid, json_agg(aa.amount) as hamt, json_agg(aa.frozen) as hf, json_agg(aa.created_at) as holding_created_at, json_agg(aa.closed_at) as holding_closed_at, json_agg(coalesce(aa.deleted, false)) as holding_deleted FROM account_asset aa JOIN qaccounts xa ON aa.addr = xa.addr WHERE coalesce(aa.deleted, false) = false GROUP BY 1)`
+		query += `, qaa AS (SELECT xa.addr, ` + selectCols + ` FROM account_asset aa JOIN qaccounts xa ON aa.addr = xa.addr` + where + ` GROUP BY 1)`
+	}
+	if opts.IncludeAssetParams {
+		var where, selectCols string
+		if !opts.IncludeDeleted {
+			where = ` WHERE NOT ap.deleted`
 		}
-		if opts.IncludeAssetParams {
-			query += `, qap AS (SELECT ya.addr, json_agg(ap.index) as paid, json_agg(ap.params) as pp, json_agg(ap.created_at) as asset_created_at, json_agg(ap.closed_at) as asset_closed_at, json_agg(ap.deleted) as asset_deleted FROM asset ap JOIN qaccounts ya ON ap.creator_addr = ya.addr WHERE coalesce(ap.deleted, false) = false GROUP BY 1)`
+		if countOnly {
+			selectCols = `count(*) as asset_count`
+		} else {
+			selectCols = `json_agg(ap.index) as paid, json_agg(ap.params) as pp, json_agg(ap.created_at) as asset_created_at, json_agg(ap.closed_at) as asset_closed_at, json_agg(ap.deleted) as asset_deleted`
+		}
+		query += `, qap AS (SELECT ya.addr, ` + selectCols + ` FROM asset ap JOIN qaccounts ya ON ap.creator_addr = ya.addr` + where + ` GROUP BY 1)`
+	}
+	if opts.IncludeAppParams {
+		var where, selectCols string
+		if !opts.IncludeDeleted {
+			where = ` WHERE NOT app.deleted`
+		}
+		if countOnly {
+			selectCols = `count(*) as app_count`
+		} else {
+			selectCols = `json_agg(app.index) as papps, json_agg(app.params) as ppa, json_agg(app.created_at) as app_created_at, json_agg(app.closed_at) as app_closed_at, json_agg(app.deleted) as app_deleted`
 		}
-		// app
-		query += `, qapp AS (SELECT app.creator as addr, json_agg(app.index) as papps, json_agg(app.params) as ppa, json_agg(app.created_at) as app_created_at, json_agg(app.closed_at) as app_closed_at, json_agg(app.deleted) as app_deleted FROM app JOIN qaccounts ON qaccounts.addr = app.creator WHERE coalesce(app.deleted, false) = false GROUP BY 1)`
-		// app localstate
-		query += `, qls AS (SELECT la.addr, json_agg(la.app) as lsapps, json_agg(la.localstate) as lsls, json_agg(la.created_at) as ls_created_at, json_agg(la.closed_at) as ls_closed_at, json_agg(la.deleted) as ls_deleted FROM account_app la JOIN qaccounts ON qaccounts.addr = la.addr WHERE coalesce(la.deleted, false) = false GROUP BY 1)`
+		query += `, qapp AS (SELECT app.creator as addr, ` + selectCols + ` FROM app JOIN qaccounts ON qaccounts.addr = app.creator` + where + ` GROUP BY 1)`
+	}
+	if opts.IncludeAppLocalState {
+		var where, selectCols string
+		if !opts.IncludeDeleted {
+			where = ` WHERE NOT la.deleted`
+		}
+		if countOnly {
+			selectCols = `count(*) as app_count`
+		} else {
+			selectCols = `json_agg(la.app) as lsapps, json_agg(la.localstate) as lsls, json_agg(la.created_at) as ls_created_at, json_agg(la.closed_at) as ls_closed_at, json_agg(la.deleted) as ls_deleted`
+		}
+		query += `, qls AS (SELECT la.addr, ` + selectCols + ` FROM account_app la JOIN qaccounts ON qaccounts.addr = la.addr` + where + ` GROUP BY 1)`
 	}
 
 	// query results
 	query += ` SELECT za.addr, za.microalgos, za.rewards_total, za.created_at, za.closed_at, za.deleted, za.rewardsbase, za.keytype, za.account_data`
 	if opts.IncludeAssetHoldings {
-		query += `, qaa.haid, qaa.hamt, qaa.hf, qaa.holding_created_at, qaa.holding_closed_at, qaa.holding_deleted`
+		if countOnly {
+			query += `, qaa.holding_count`
+		} else {
+			query += `, qaa.haid, qaa.hamt, qaa.hf, qaa.holding_created_at, qaa.holding_closed_at, qaa.holding_deleted`
+		}
 	}
 	if opts.IncludeAssetParams {
-		query += `, qap.paid, qap.pp, qap.asset_created_at, qap.asset_closed_at, qap.asset_deleted`
+		if countOnly {
+			query += `, qap.asset_count`
+		} else {
+			query += `, qap.paid, qap.pp, qap.asset_created_at, qap.asset_closed_at, qap.asset_deleted`
+		}
+	}
+	if opts.IncludeAppParams {
+		if countOnly {
+			query += `, qapp.app_count`
+		} else {
+			query += `, qapp.papps, qapp.ppa, qapp.app_created_at, qapp.app_closed_at, qapp.app_deleted`
+		}
+	}
+	if opts.IncludeAppLocalState {
+		if countOnly {
+			query += `, qls.ls_count`
+		} else {
+			query += `, qls.lsapps, qls.lsls, qls.ls_created_at, qls.ls_closed_at, qls.ls_deleted`
+		}
 	}
-	query += `, qapp.papps, qapp.ppa, qapp.app_created_at, qapp.app_closed_at, qapp.app_deleted, qls.lsapps, qls.lsls, qls.ls_created_at, qls.ls_closed_at, qls.ls_deleted FROM qaccounts za`
+	query += ` FROM qaccounts za`
 
 	// join everything together
 	if opts.IncludeAssetHoldings {
@@ -1858,7 +1994,13 @@ func (db *IndexerDb) buildAccountQuery(opts idb.AccountQueryOptions) (query stri
 	if opts.IncludeAssetParams {
 		query += ` LEFT JOIN qap ON za.addr = qap.addr`
 	}
-	query += " LEFT JOIN qapp ON za.addr = qapp.addr LEFT JOIN qls ON qls.addr = za.addr ORDER BY za.addr ASC;"
+	if opts.IncludeAppParams {
+		query += ` LEFT JOIN qapp ON za.addr = qapp.addr`
+	}
+	if opts.IncludeAppLocalState {
+		query += ` LEFT JOIN qls ON za.addr = qls.addr`
+	}
+	query += ` ORDER BY za.addr ASC;`
 	return query, whereArgs
 }
 
@@ -1901,7 +2043,7 @@ func (db *IndexerDb) Assets(ctx context.Context, filter idb.AssetsQuery) (<-chan
 		partNumber++
 	}
 	if !filter.IncludeDeleted {
-		whereParts = append(whereParts, "coalesce(a.deleted, false) = false")
+		whereParts = append(whereParts, "NOT a.deleted")
 	}
 	if len(whereParts) > 0 {
 		whereStr := strings.Join(whereParts, " AND ")
@@ -1993,6 +2135,16 @@ func (db *IndexerDb) AssetBalances(ctx context.Context, abq idb.AssetBalanceQuer
 		whereArgs = append(whereArgs, abq.AssetID)
 		partNumber++
 	}
+	if abq.AssetIDGT != 0 {
+		whereParts = append(whereParts, fmt.Sprintf("aa.assetid > $%d", partNumber))
+		whereArgs = append(whereArgs, abq.AssetIDGT)
+		partNumber++
+	}
+	if abq.Address != nil {
+		whereParts = append(whereParts, fmt.Sprintf("aa.addr = $%d", partNumber))
+		whereArgs = append(whereArgs, abq.Address)
+		partNumber++
+	}
 	if abq.AmountGT != nil {
 		whereParts = append(whereParts, fmt.Sprintf("aa.amount > $%d", partNumber))
 		whereArgs = append(whereArgs, *abq.AmountGT)
@@ -2009,13 +2161,14 @@ func (db *IndexerDb) AssetBalances(ctx context.Context, abq idb.AssetBalanceQuer
 		partNumber++
 	}
 	if !abq.IncludeDeleted {
-		whereParts = append(whereParts, "coalesce(aa.deleted, false) = false")
+		whereParts = append(whereParts, "NOT aa.deleted")
 	}
 	query := `SELECT addr, assetid, amount, frozen, created_at, closed_at, deleted FROM account_asset aa`
 	if len(whereParts) > 0 {
 		query += " WHERE " + strings.Join(whereParts, " AND ")
 	}
-	query += " ORDER BY addr ASC"
+	query += " ORDER BY addr, assetid ASC"
+
 	if abq.Limit > 0 {
 		query += fmt.Sprintf(" LIMIT %d", abq.Limit)
 	}
@@ -2085,40 +2238,40 @@ func (db *IndexerDb) yieldAssetBalanceThread(rows pgx.Rows, out chan<- idb.Asset
 }
 
 // Applications is part of idb.IndexerDB
-func (db *IndexerDb) Applications(ctx context.Context, filter *models.SearchForApplicationsParams) (<-chan idb.ApplicationRow, uint64) {
+func (db *IndexerDb) Applications(ctx context.Context, filter idb.ApplicationQuery) (<-chan idb.ApplicationRow, uint64) {
 	out := make(chan idb.ApplicationRow, 1)
-	if filter == nil {
-		out <- idb.ApplicationRow{Error: fmt.Errorf("no arguments provided to application search")}
-		close(out)
-		return out, 0
-	}
 
 	query := `SELECT index, creator, params, created_at, closed_at, deleted FROM app `
 
-	const maxWhereParts = 30
+	const maxWhereParts = 4
 	whereParts := make([]string, 0, maxWhereParts)
 	whereArgs := make([]interface{}, 0, maxWhereParts)
 	partNumber := 1
-	if filter.ApplicationId != nil {
+	if filter.ApplicationID != 0 {
 		whereParts = append(whereParts, fmt.Sprintf("index = $%d", partNumber))
-		whereArgs = append(whereArgs, *filter.ApplicationId)
+		whereArgs = append(whereArgs, filter.ApplicationID)
+		partNumber++
+	}
+	if filter.Address != nil {
+		whereParts = append(whereParts, fmt.Sprintf("creator = $%d", partNumber))
+		whereArgs = append(whereArgs, filter.Address)
 		partNumber++
 	}
-	if filter.Next != nil {
+	if filter.ApplicationIDGreaterThan != 0 {
 		whereParts = append(whereParts, fmt.Sprintf("index > $%d", partNumber))
-		whereArgs = append(whereArgs, *filter.Next)
+		whereArgs = append(whereArgs, filter.ApplicationIDGreaterThan)
 		partNumber++
 	}
-	if filter.IncludeAll == nil || !(*filter.IncludeAll) {
-		whereParts = append(whereParts, "coalesce(deleted, false) = false")
+	if !filter.IncludeDeleted {
+		whereParts = append(whereParts, "NOT deleted")
 	}
 	if len(whereParts) > 0 {
 		whereStr := strings.Join(whereParts, " AND ")
 		query += " WHERE " + whereStr
 	}
 	query += " ORDER BY 1"
-	if filter.Limit != nil {
-		query += fmt.Sprintf(" LIMIT %d", *filter.Limit)
+	if filter.Limit != 0 {
+		query += fmt.Sprintf(" LIMIT %d", filter.Limit)
 	}
 
 	tx, err := db.db.BeginTx(ctx, readonlyRepeatableRead)
@@ -2174,7 +2327,7 @@ func (db *IndexerDb) yieldApplicationsThread(rows pgx.Rows, out chan idb.Applica
 		rec.Application.Deleted = deleted
 		ap, err := encoding.DecodeAppParams(paramsjson)
 		if err != nil {
-			rec.Error = fmt.Errorf("app=%d json err, %v", index, err)
+			rec.Error = fmt.Errorf("app=%d json err: %w", index, err)
 			out <- rec
 			break
 		}
@@ -2208,6 +2361,113 @@ func (db *IndexerDb) yieldApplicationsThread(rows pgx.Rows, out chan idb.Applica
 	}
 }
 
+// AppLocalState is part of idb.IndexerDB
+func (db *IndexerDb) AppLocalState(ctx context.Context, filter idb.ApplicationQuery) (<-chan idb.AppLocalStateRow, uint64) {
+	out := make(chan idb.AppLocalStateRow, 1)
+
+	query := `SELECT app, addr, localstate, created_at, closed_at, deleted FROM account_app `
+
+	const maxWhereParts = 4
+	whereParts := make([]string, 0, maxWhereParts)
+	whereArgs := make([]interface{}, 0, maxWhereParts)
+	partNumber := 1
+	if filter.ApplicationID != 0 {
+		whereParts = append(whereParts, fmt.Sprintf("app = $%d", partNumber))
+		whereArgs = append(whereArgs, filter.ApplicationID)
+		partNumber++
+	}
+	if filter.Address != nil {
+		whereParts = append(whereParts, fmt.Sprintf("addr = $%d", partNumber))
+		whereArgs = append(whereArgs, filter.Address)
+		partNumber++
+	}
+	if filter.ApplicationIDGreaterThan != 0 {
+		whereParts = append(whereParts, fmt.Sprintf("app > $%d", partNumber))
+		whereArgs = append(whereArgs, filter.ApplicationIDGreaterThan)
+		partNumber++
+	}
+	if !filter.IncludeDeleted {
+		whereParts = append(whereParts, "NOT deleted")
+	}
+	if len(whereParts) > 0 {
+		whereStr := strings.Join(whereParts, " AND ")
+		query += " WHERE " + whereStr
+	}
+	query += " ORDER BY 1"
+	if filter.Limit != 0 {
+		query += fmt.Sprintf(" LIMIT %d", filter.Limit)
+	}
+
+	tx, err := db.db.BeginTx(ctx, readonlyRepeatableRead)
+	if err != nil {
+		out <- idb.AppLocalStateRow{Error: err}
+		close(out)
+		return out, 0
+	}
+
+	round, err := db.getMaxRoundAccounted(ctx, tx)
+	if err != nil {
+		out <- idb.AppLocalStateRow{Error: err}
+		close(out)
+		tx.Rollback(ctx)
+		return out, round
+	}
+
+	rows, err := tx.Query(ctx, query, whereArgs...)
+	if err != nil {
+		out <- idb.AppLocalStateRow{Error: err}
+		close(out)
+		tx.Rollback(ctx)
+		return out, round
+	}
+
+	go func() {
+		db.yieldAppLocalStateThread(rows, out)
+		close(out)
+		tx.Rollback(ctx)
+	}()
+	return out, round
+}
+
+func (db *IndexerDb) yieldAppLocalStateThread(rows pgx.Rows, out chan idb.AppLocalStateRow) {
+	defer rows.Close()
+
+	for rows.Next() {
+		var index uint64
+		var address []byte
+		var statejson []byte
+		var created *uint64
+		var closed *uint64
+		var deleted *bool
+		err := rows.Scan(&index, &address, &statejson, &created, &closed, &deleted)
+		if err != nil {
+			out <- idb.AppLocalStateRow{Error: err}
+			break
+		}
+		var rec idb.AppLocalStateRow
+		rec.AppLocalState.Id = index
+		rec.AppLocalState.OptedInAtRound = created
+		rec.AppLocalState.ClosedOutAtRound = closed
+		rec.AppLocalState.Deleted = deleted
+
+		ls, err := encoding.DecodeAppLocalState(statejson)
+		if err != nil {
+			rec.Error = fmt.Errorf("app=%d json err: %w", index, err)
+			out <- rec
+			break
+		}
+		rec.AppLocalState.Schema = models.ApplicationStateSchema{
+			NumByteSlice: ls.Schema.NumByteSlice,
+			NumUint:      ls.Schema.NumUint,
+		}
+		rec.AppLocalState.KeyValue = tealKeyValueToModel(ls.KeyValue)
+		out <- rec
+	}
+	if err := rows.Err(); err != nil {
+		out <- idb.AppLocalStateRow{Error: err}
+	}
+}
+
 // Health is part of idb.IndexerDB
 func (db *IndexerDb) Health(ctx context.Context) (idb.Health, error) {
 	migrationRequired := false
@@ -2279,41 +2539,32 @@ func (db *IndexerDb) GetSpecialAccounts(ctx context.Context) (transactions.Speci
 	return accounts, nil
 }
 
-// GetAccountData returns account data for the given addresses. For accounts that are
-// not found, empty AccountData is returned. This function is only used for debugging.
-func (db *IndexerDb) GetAccountData(addresses []basics.Address) (map[basics.Address]basics.AccountData, error) {
+// GetAccountState returns account data and account resources for the given input.
+// For accounts that are not found, empty AccountData is returned.
+// This function is only used for debugging.
+func (db *IndexerDb) GetAccountState(addressesReq map[basics.Address]struct{}, resourcesReq map[basics.Address]map[ledger.Creatable]struct{}) (map[basics.Address]*ledgercore.AccountData, map[basics.Address]map[ledger.Creatable]ledgercore.AccountResource, error) {
 	tx, err := db.db.BeginTx(context.Background(), readonlyRepeatableRead)
 	if err != nil {
-		return nil, fmt.Errorf("GetAccountData() begin tx err: %w", err)
+		return nil, nil, fmt.Errorf("GetAccountState() begin tx err: %w", err)
 	}
 	defer tx.Rollback(context.Background())
 
 	l, err := ledger_for_evaluator.MakeLedgerForEvaluator(tx, basics.Round(0))
 	if err != nil {
-		return nil, fmt.Errorf("GetAccountData() err: %w", err)
+		return nil, nil, fmt.Errorf("GetAccountState() err: %w", err)
 	}
 	defer l.Close()
 
-	addressesMap := make(map[basics.Address]struct{}, len(addresses))
-	for _, address := range addresses {
-		addressesMap[address] = struct{}{}
-	}
-
-	accountDataMap, err := l.LookupWithoutRewards(addressesMap)
+	accounts, err := l.LookupWithoutRewards(addressesReq)
 	if err != nil {
-		return nil, fmt.Errorf("GetAccountData() err: %w", err)
+		return nil, nil, fmt.Errorf("GetAccountState() err: %w", err)
 	}
-
-	res := make(map[basics.Address]basics.AccountData, len(accountDataMap))
-	for address, accountData := range accountDataMap {
-		if accountData == nil {
-			res[address] = basics.AccountData{}
-		} else {
-			res[address] = *accountData
-		}
+	resources, err := l.LookupResources(resourcesReq)
+	if err != nil {
+		return nil, nil, fmt.Errorf("GetAccountState() err: %w", err)
 	}
 
-	return res, nil
+	return accounts, resources, nil
 }
 
 // GetNetworkState is part of idb.IndexerDB
diff --git a/idb/postgres/postgres_integration_test.go b/idb/postgres/postgres_integration_test.go
index 5fbf67877..deff7e28a 100644
--- a/idb/postgres/postgres_integration_test.go
+++ b/idb/postgres/postgres_integration_test.go
@@ -407,7 +407,7 @@ func TestRekeyBasic(t *testing.T) {
 	err = row.Scan(&accountDataStr)
 	assert.NoError(t, err, "querying account data")
 
-	ad, err := encoding.DecodeTrimmedAccountData(accountDataStr)
+	ad, err := encoding.DecodeTrimmedLcAccountData(accountDataStr)
 	require.NoError(t, err, "failed to parse account data json")
 	assert.Equal(t, test.AccountB, ad.AuthAddr)
 }
@@ -444,7 +444,7 @@ func TestRekeyToItself(t *testing.T) {
 	err = row.Scan(&accountDataStr)
 	assert.NoError(t, err, "querying account data")
 
-	ad, err := encoding.DecodeTrimmedAccountData(accountDataStr)
+	ad, err := encoding.DecodeTrimmedLcAccountData(accountDataStr)
 	require.NoError(t, err, "failed to parse account data json")
 	assert.Equal(t, basics.Address{}, ad.AuthAddr)
 }
@@ -479,7 +479,7 @@ func TestRekeyThreeTimesInSameRound(t *testing.T) {
 	err = row.Scan(&accountDataStr)
 	assert.NoError(t, err, "querying account data")
 
-	ad, err := encoding.DecodeTrimmedAccountData(accountDataStr)
+	ad, err := encoding.DecodeTrimmedLcAccountData(accountDataStr)
 	require.NoError(t, err, "failed to parse account data json")
 	assert.Equal(t, test.AccountC, ad.AuthAddr)
 }
@@ -860,10 +860,10 @@ func TestAppExtraPages(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, uint32(1), ap.ExtraProgramPages)
 
-	var filter generated.SearchForApplicationsParams
+	var filter idb.ApplicationQuery
 	var aidx uint64 = uint64(index)
-	filter.ApplicationId = &aidx
-	appRows, _ := db.Applications(context.Background(), &filter)
+	filter.ApplicationID = aidx
+	appRows, _ := db.Applications(context.Background(), filter)
 	num := 0
 	for row := range appRows {
 		require.NoError(t, row.Error)
@@ -873,7 +873,7 @@ func TestAppExtraPages(t *testing.T) {
 	}
 	require.Equal(t, 1, num)
 
-	rows, _ := db.GetAccounts(context.Background(), idb.AccountQueryOptions{EqualToAddress: test.AccountA[:]})
+	rows, _ := db.GetAccounts(context.Background(), idb.AccountQueryOptions{EqualToAddress: test.AccountA[:], IncludeAppParams: true})
 	num = 0
 	var createdApps *[]generated.Application
 	for row := range rows {
@@ -881,6 +881,7 @@ func TestAppExtraPages(t *testing.T) {
 		num++
 		require.NotNil(t, row.Account.AppsTotalExtraPages, "we should have this field")
 		require.Equal(t, uint64(1), *row.Account.AppsTotalExtraPages)
+		require.Equal(t, uint64(1), row.Account.TotalCreatedApps)
 		createdApps = row.Account.CreatedApps
 	}
 	require.Equal(t, 1, num)
@@ -978,6 +979,7 @@ func TestLargeAssetAmount(t *testing.T) {
 		require.NoError(t, row.Error)
 		require.NotNil(t, row.Account.Assets)
 		require.Equal(t, 1, len(*row.Account.Assets))
+		require.Equal(t, uint64(1), row.Account.TotalAssetsOptedIn)
 		assert.Equal(t, uint64(math.MaxUint64), (*row.Account.Assets)[0].Amount)
 	}
 }
@@ -1143,6 +1145,7 @@ func TestNonDisplayableUTF8(t *testing.T) {
 				require.NoError(t, acct.Error)
 				require.NotNil(t, acct.Account.CreatedAssets)
 				require.Len(t, *acct.Account.CreatedAssets, 1)
+				require.Equal(t, uint64(1), acct.Account.TotalCreatedAssets)
 
 				asset := (*acct.Account.CreatedAssets)[0]
 				if testcase.ExpectedAssetName == "" {
@@ -1502,12 +1505,11 @@ func TestAddBlockCreateDeleteAppSameRound(t *testing.T) {
 	err = db.AddBlock(&block)
 	require.NoError(t, err)
 
-	yes := true
-	opts := generated.SearchForApplicationsParams{
-		ApplicationId: &appid,
-		IncludeAll:    &yes,
+	opts := idb.ApplicationQuery{
+		ApplicationID:  appid,
+		IncludeDeleted: true,
 	}
-	rowsCh, _ := db.Applications(context.Background(), &opts)
+	rowsCh, _ := db.Applications(context.Background(), opts)
 
 	row, ok := <-rowsCh
 	require.True(t, ok)
@@ -1538,8 +1540,9 @@ func TestAddBlockAppOptInOutSameRound(t *testing.T) {
 	require.NoError(t, err)
 
 	opts := idb.AccountQueryOptions{
-		EqualToAddress: test.AccountB[:],
-		IncludeDeleted: true,
+		EqualToAddress:       test.AccountB[:],
+		IncludeDeleted:       true,
+		IncludeAppLocalState: true,
 	}
 	rowsCh, _ := db.GetAccounts(context.Background(), opts)
 
@@ -1557,6 +1560,24 @@ func TestAddBlockAppOptInOutSameRound(t *testing.T) {
 	assert.Equal(t, uint64(1), *localState.OptedInAtRound)
 	require.NotNil(t, localState.ClosedOutAtRound)
 	assert.Equal(t, uint64(1), *localState.ClosedOutAtRound)
+	require.Equal(t, uint64(0), row.Account.TotalAppsOptedIn)
+
+	q := idb.ApplicationQuery{
+		ApplicationID:  appid,
+		IncludeDeleted: true,
+	}
+	lsRows, _ := db.AppLocalState(context.Background(), q)
+	lsRow, ok := <-lsRows
+	require.True(t, ok)
+	require.NoError(t, lsRow.Error)
+	ls := lsRow.AppLocalState
+	require.Equal(t, appid, ls.Id)
+	require.NotNil(t, ls.Deleted)
+	assert.True(t, *ls.Deleted)
+	require.NotNil(t, ls.OptedInAtRound)
+	assert.Equal(t, uint64(1), *ls.OptedInAtRound)
+	require.NotNil(t, ls.ClosedOutAtRound)
+	assert.Equal(t, uint64(1), *ls.ClosedOutAtRound)
 }
 
 // TestSearchForInnerTransactionReturnsRootTransaction checks that the parent
diff --git a/idb/postgres/postgres_migrations.go b/idb/postgres/postgres_migrations.go
index 2618f1698..53b162e3d 100644
--- a/idb/postgres/postgres_migrations.go
+++ b/idb/postgres/postgres_migrations.go
@@ -14,6 +14,7 @@ import (
 	"github.com/algorand/indexer/idb"
 	"github.com/algorand/indexer/idb/migration"
 	"github.com/algorand/indexer/idb/postgres/internal/encoding"
+	cad "github.com/algorand/indexer/idb/postgres/internal/migrations/convert_account_data"
 	"github.com/algorand/indexer/idb/postgres/internal/schema"
 	"github.com/algorand/indexer/idb/postgres/internal/types"
 )
@@ -48,6 +49,7 @@ func init() {
 		{upgradeNotSupported, true, "change import state format"},
 		{upgradeNotSupported, true, "notify the user that upgrade is not supported"},
 		{dropTxnBytesColumn, true, "drop txnbytes column"},
+		{convertAccountData, true, "convert account.account_data column"},
 	}
 }
 
@@ -86,20 +88,6 @@ func needsMigration(state types.MigrationState) bool {
 	return state.NextMigration < len(migrations)
 }
 
-// upsertMigrationState updates the migration state, and optionally increments
-// the next counter with an existing transaction.
-// If `tx` is nil, use a normal query.
-//lint:ignore U1000 this function might be used in a future migration
-func upsertMigrationState(db *IndexerDb, tx pgx.Tx, state *types.MigrationState) error {
-	migrationStateJSON := encoding.EncodeMigrationState(state)
-	err := db.setMetastate(tx, schema.MigrationMetastateKey, string(migrationStateJSON))
-	if err != nil {
-		return fmt.Errorf("upsertMigrationState() err: %w", err)
-	}
-
-	return nil
-}
-
 // Returns an error object and a channel that gets closed when blocking migrations
 // finish running successfully.
 func (db *IndexerDb) runAvailableMigrations() (chan struct{}, error) {
@@ -171,6 +159,17 @@ func (db *IndexerDb) getMigrationState(ctx context.Context, tx pgx.Tx) (types.Mi
 	return state, nil
 }
 
+// If `tx` is nil, use a normal query.
+func (db *IndexerDb) setMigrationState(tx pgx.Tx, state *types.MigrationState) error {
+	err := db.setMetastate(
+		tx, schema.MigrationMetastateKey, string(encoding.EncodeMigrationState(state)))
+	if err != nil {
+		return fmt.Errorf("setMigrationState() err: %w", err)
+	}
+
+	return nil
+}
+
 // sqlMigration executes a sql statements as the entire migration.
 //lint:ignore U1000 this function might be used in a future migration
 func sqlMigration(db *IndexerDb, state *types.MigrationState, sqlLines []string) error {
@@ -224,3 +223,29 @@ func dropTxnBytesColumn(db *IndexerDb, migrationState *types.MigrationState) err
 	return sqlMigration(
 		db, migrationState, []string{"ALTER TABLE txn DROP COLUMN txnbytes"})
 }
+
+func convertAccountData(db *IndexerDb, migrationState *types.MigrationState) error {
+	newMigrationState := *migrationState
+	newMigrationState.NextMigration++
+
+	f := func(tx pgx.Tx) error {
+		err := cad.RunMigration(tx, 10000)
+		if err != nil {
+			return fmt.Errorf("convertAccountData() err: %w", err)
+		}
+
+		err = db.setMigrationState(tx, &newMigrationState)
+		if err != nil {
+			return fmt.Errorf("convertAccountData() err: %w", err)
+		}
+
+		return nil
+	}
+	err := db.txWithRetry(serializable, f)
+	if err != nil {
+		return fmt.Errorf("convertAccountData() err: %w", err)
+	}
+
+	*migrationState = newMigrationState
+	return nil
+}
diff --git a/idb/postgres/postgres_migrations_test.go b/idb/postgres/postgres_migrations_test.go
new file mode 100644
index 000000000..3a0a98e79
--- /dev/null
+++ b/idb/postgres/postgres_migrations_test.go
@@ -0,0 +1,34 @@
+package postgres
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	pgtest "github.com/algorand/indexer/idb/postgres/internal/testing"
+	"github.com/algorand/indexer/idb/postgres/internal/types"
+)
+
+func TestConvertAccountDataIncrementsMigrationNumber(t *testing.T) {
+	pdb, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+	defer shutdownFunc()
+
+	db := IndexerDb{db: pdb}
+	defer db.Close()
+
+	migrationState := types.MigrationState{
+		NextMigration: 5,
+	}
+	err := db.setMigrationState(nil, &migrationState)
+	require.NoError(t, err)
+
+	err = convertAccountData(&db, &migrationState)
+	require.NoError(t, err)
+
+	migrationState, err = db.getMigrationState(context.Background(), nil)
+	require.NoError(t, err)
+
+	assert.Equal(t, types.MigrationState{NextMigration: 6}, migrationState)
+}
diff --git a/idb/postgres/postgres_rand_test.go b/idb/postgres/postgres_rand_test.go
index 078a5b631..e4fd44be8 100644
--- a/idb/postgres/postgres_rand_test.go
+++ b/idb/postgres/postgres_rand_test.go
@@ -8,26 +8,144 @@ import (
 	"github.com/algorand/go-algorand/data/basics"
 	"github.com/algorand/go-algorand/data/bookkeeping"
 	"github.com/algorand/go-algorand/data/transactions"
+	"github.com/algorand/go-algorand/ledger"
 	"github.com/algorand/go-algorand/ledger/ledgercore"
 	ledgerforevaluator "github.com/algorand/indexer/idb/postgres/internal/ledger_for_evaluator"
 	"github.com/algorand/indexer/idb/postgres/internal/writer"
 	"github.com/algorand/indexer/util/test"
 	"github.com/jackc/pgx/v4"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
+func generateAddress(t *testing.T) basics.Address {
+	var res basics.Address
+
+	_, err := rand.Read(res[:])
+	require.NoError(t, err)
+
+	return res
+}
+
+func generateAccountData() ledgercore.AccountData {
+	// Return empty account data with probability 50%.
+	if rand.Uint32()%2 == 0 {
+		return ledgercore.AccountData{}
+	}
+
+	const numCreatables = 20
+
+	res := ledgercore.AccountData{
+		AccountBaseData: ledgercore.AccountBaseData{
+			MicroAlgos: basics.MicroAlgos{Raw: uint64(rand.Int63())},
+		},
+	}
+
+	return res
+}
+
+// Write random account data for many random accounts, then read it and compare.
+// Tests in particular that batch writing and reading is done in the same order
+// and that there are no problems around passing account address pointers to the postgres
+// driver which could be the same pointer if we are not careful.
+func TestWriteReadAccountData(t *testing.T) {
+	db, shutdownFunc := setupIdb(t, test.MakeGenesis(), test.MakeGenesisBlock())
+	defer shutdownFunc()
+
+	addresses := make(map[basics.Address]struct{})
+	var delta ledgercore.StateDelta
+	for i := 0; i < 1000; i++ {
+		address := generateAddress(t)
+
+		addresses[address] = struct{}{}
+		delta.Accts.Upsert(address, generateAccountData())
+	}
+
+	f := func(tx pgx.Tx) error {
+		w, err := writer.MakeWriter(tx)
+		require.NoError(t, err)
+
+		err = w.AddBlock(&bookkeeping.Block{}, transactions.Payset{}, delta)
+		require.NoError(t, err)
+
+		w.Close()
+		return nil
+	}
+	err := db.txWithRetry(serializable, f)
+	require.NoError(t, err)
+
+	tx, err := db.db.BeginTx(context.Background(), serializable)
+	require.NoError(t, err)
+	defer tx.Rollback(context.Background())
+
+	l, err := ledgerforevaluator.MakeLedgerForEvaluator(tx, basics.Round(0))
+	require.NoError(t, err)
+	defer l.Close()
+
+	ret, err := l.LookupWithoutRewards(addresses)
+	require.NoError(t, err)
+
+	for address := range addresses {
+		expected, ok := delta.Accts.GetData(address)
+		require.True(t, ok)
+
+		ret, ok := ret[address]
+		require.True(t, ok)
+
+		if ret == nil {
+			require.True(t, expected.IsZero())
+		} else {
+			require.Equal(t, &expected, ret)
+		}
+	}
+}
+
 func generateAssetParams() basics.AssetParams {
 	return basics.AssetParams{
 		Total: rand.Uint64(),
 	}
 }
 
+func generateAssetParamsDelta() ledgercore.AssetParamsDelta {
+	var res ledgercore.AssetParamsDelta
+
+	r := rand.Uint32() % 3
+	switch r {
+	case 0:
+		res.Deleted = true
+	case 1:
+		res.Params = new(basics.AssetParams)
+		*res.Params = generateAssetParams()
+	case 2:
+		// do nothing
+	}
+
+	return res
+}
+
 func generateAssetHolding() basics.AssetHolding {
 	return basics.AssetHolding{
 		Amount: rand.Uint64(),
 	}
 }
 
+func generateAssetHoldingDelta() ledgercore.AssetHoldingDelta {
+	var res ledgercore.AssetHoldingDelta
+
+	r := rand.Uint32() % 3
+	switch r {
+	case 0:
+		res.Deleted = true
+	case 1:
+		res.Holding = new(basics.AssetHolding)
+		*res.Holding = generateAssetHolding()
+	case 2:
+		// do nothing
+	}
+
+	return res
+}
+
 func generateAppParams(t *testing.T) basics.AppParams {
 	p := make([]byte, 100)
 	_, err := rand.Read(p)
@@ -38,6 +156,23 @@ func generateAppParams(t *testing.T) basics.AppParams {
 	}
 }
 
+func generateAppParamsDelta(t *testing.T) ledgercore.AppParamsDelta {
+	var res ledgercore.AppParamsDelta
+
+	r := rand.Uint32() % 3
+	switch r {
+	case 0:
+		res.Deleted = true
+	case 1:
+		res.Params = new(basics.AppParams)
+		*res.Params = generateAppParams(t)
+	case 2:
+		// do nothing
+	}
+
+	return res
+}
+
 func generateAppLocalState(t *testing.T) basics.AppLocalState {
 	k := make([]byte, 100)
 	_, err := rand.Read(k)
@@ -56,61 +191,61 @@ func generateAppLocalState(t *testing.T) basics.AppLocalState {
 	}
 }
 
-func generateAccountData(t *testing.T) basics.AccountData {
-	// Return empty account data with probability 50%.
-	if rand.Uint32()%2 == 0 {
-		return basics.AccountData{}
-	}
-
-	const numCreatables = 20
-
-	res := basics.AccountData{
-		MicroAlgos:     basics.MicroAlgos{Raw: uint64(rand.Int63())},
-		AssetParams:    make(map[basics.AssetIndex]basics.AssetParams),
-		Assets:         make(map[basics.AssetIndex]basics.AssetHolding),
-		AppLocalStates: make(map[basics.AppIndex]basics.AppLocalState),
-		AppParams:      make(map[basics.AppIndex]basics.AppParams),
-	}
+func generateAppLocalStateDelta(t *testing.T) ledgercore.AppLocalStateDelta {
+	var res ledgercore.AppLocalStateDelta
 
-	for i := 0; i < numCreatables; i++ {
-		{
-			index := basics.AssetIndex(rand.Int63())
-			res.AssetParams[index] = generateAssetParams()
-		}
-		{
-			index := basics.AssetIndex(rand.Int63())
-			res.Assets[index] = generateAssetHolding()
-		}
-		{
-			index := basics.AppIndex(rand.Int63())
-			res.AppLocalStates[index] = generateAppLocalState(t)
-		}
-		{
-			index := basics.AppIndex(rand.Int63())
-			res.AppParams[index] = generateAppParams(t)
-		}
+	r := rand.Uint32() % 3
+	switch r {
+	case 0:
+		res.Deleted = true
+	case 1:
+		res.LocalState = new(basics.AppLocalState)
+		*res.LocalState = generateAppLocalState(t)
+	case 2:
+		// do nothing
 	}
 
 	return res
 }
 
-// Write random account data for many random accounts, then read it and compare.
+// Write random assets and apps, then read it and compare.
 // Tests in particular that batch writing and reading is done in the same order
 // and that there are no problems around passing account address pointers to the postgres
 // driver which could be the same pointer if we are not careful.
-func TestWriteReadAccountData(t *testing.T) {
+func TestWriteReadResources(t *testing.T) {
 	db, shutdownFunc := setupIdb(t, test.MakeGenesis(), test.MakeGenesisBlock())
 	defer shutdownFunc()
 
-	addresses := make(map[basics.Address]struct{})
+	resources := make(map[basics.Address]map[ledger.Creatable]struct{})
 	var delta ledgercore.StateDelta
 	for i := 0; i < 1000; i++ {
-		var address basics.Address
-		_, err := rand.Read(address[:])
-		require.NoError(t, err)
+		address := generateAddress(t)
+		assetIndex := basics.AssetIndex(rand.Int63())
+		appIndex := basics.AppIndex(rand.Int63())
 
-		addresses[address] = struct{}{}
-		delta.Accts.Upsert(address, generateAccountData(t))
+		{
+			c := make(map[ledger.Creatable]struct{})
+			resources[address] = c
+
+			creatable := ledger.Creatable{
+				Index: basics.CreatableIndex(assetIndex),
+				Type:  basics.AssetCreatable,
+			}
+			c[creatable] = struct{}{}
+
+			creatable = ledger.Creatable{
+				Index: basics.CreatableIndex(appIndex),
+				Type:  basics.AppCreatable,
+			}
+			c[creatable] = struct{}{}
+		}
+
+		delta.Accts.UpsertAssetResource(
+			address, assetIndex, generateAssetParamsDelta(),
+			generateAssetHoldingDelta())
+		delta.Accts.UpsertAppResource(
+			address, appIndex, generateAppParamsDelta(t),
+			generateAppLocalStateDelta(t))
 	}
 
 	f := func(tx pgx.Tx) error {
@@ -134,20 +269,35 @@ func TestWriteReadAccountData(t *testing.T) {
 	require.NoError(t, err)
 	defer l.Close()
 
-	ret, err := l.LookupWithoutRewards(addresses)
+	ret, err := l.LookupResources(resources)
 	require.NoError(t, err)
 
-	for address := range addresses {
-		expected, ok := delta.Accts.Get(address)
-		require.True(t, ok)
-
+	for address, creatables := range resources {
 		ret, ok := ret[address]
 		require.True(t, ok)
 
-		if ret == nil {
-			require.True(t, expected.IsZero())
-		} else {
-			require.Equal(t, &expected, ret)
+		for creatable := range creatables {
+			ret, ok := ret[creatable]
+			require.True(t, ok)
+
+			switch creatable.Type {
+			case basics.AssetCreatable:
+				assetParamsDelta, _ :=
+					delta.Accts.GetAssetParams(address, basics.AssetIndex(creatable.Index))
+				assert.Equal(t, assetParamsDelta.Params, ret.AssetParams)
+
+				assetHoldingDelta, _ :=
+					delta.Accts.GetAssetHolding(address, basics.AssetIndex(creatable.Index))
+				assert.Equal(t, assetHoldingDelta.Holding, ret.AssetHolding)
+			case basics.AppCreatable:
+				appParamsDelta, _ :=
+					delta.Accts.GetAppParams(address, basics.AppIndex(creatable.Index))
+				assert.Equal(t, appParamsDelta.Params, ret.AppParams)
+
+				appLocalStateDelta, _ :=
+					delta.Accts.GetAppLocalState(address, basics.AppIndex(creatable.Index))
+				assert.Equal(t, appLocalStateDelta.LocalState, ret.AppLocalState)
+			}
 		}
 	}
 }
diff --git a/misc/Dockerfile b/misc/Dockerfile
index bdff1f0c7..fff8a9985 100644
--- a/misc/Dockerfile
+++ b/misc/Dockerfile
@@ -6,7 +6,7 @@ RUN echo "Go image: $GO_IMAGE"
 # Misc dependencies
 ENV HOME /opt    
 ENV DEBIAN_FRONTEND noninteractive    
-RUN apt-get update && apt-get install -y apt-utils curl git git-core bsdmainutils python3 python3-pip make bash libtool libboost-all-dev libffi-dev
+RUN apt-get update && apt-get install -y apt-utils curl git git-core bsdmainutils python3 python3-pip make bash libtool libboost-math-dev libffi-dev
 
 # Install algod nightly binaries to the path
 RUN mkdir -p /opt/algorand/{bin,data}
diff --git a/misc/parity/reports/algod2indexer_dropped.yml b/misc/parity/reports/algod2indexer_dropped.yml
index aa395e102..3186ec820 100644
--- a/misc/parity/reports/algod2indexer_dropped.yml
+++ b/misc/parity/reports/algod2indexer_dropped.yml
@@ -26,6 +26,9 @@ DryrunTxnResult:
 ErrorResponse:
 - INDEXER: null
 - ALGOD: '{"description":"An error respo...'
+AccountsErrorResponse:
+- INDEXER: null
+- ALGOD: '{"description":"An error respo...'
 ParticipationKey:
 - INDEXER: null
 - ALGOD: '{"description":"Represents a p...'
diff --git a/misc/parity/reports/algod2indexer_full.yml b/misc/parity/reports/algod2indexer_full.yml
index 8f7f3e03a..65b27c8b4 100644
--- a/misc/parity/reports/algod2indexer_full.yml
+++ b/misc/parity/reports/algod2indexer_full.yml
@@ -100,6 +100,9 @@ DryrunTxnResult:
 ErrorResponse:
 - INDEXER: null
 - ALGOD: '{"description":"An error respo...'
+AccountsErrorResponse:
+- INDEXER: null
+- ALGOD: '{"description":"An error respo...'
 HealthCheck:
 - INDEXER: '{"description":"A health check...'
 - ALGOD: null
diff --git a/test/common.sh b/test/common.sh
index d72f09423..0e1a7c31a 100755
--- a/test/common.sh
+++ b/test/common.sh
@@ -492,7 +492,6 @@ function create_delete_tests() {
       '{
         "amount": 0,
         "asset-id": 135,
-        "creator": "",
         "deleted": true,
         "is-frozen": false,
         "opted-in-at-round": 25,
diff --git a/third_party/go-algorand b/third_party/go-algorand
index b56953f44..09b6c38e1 160000
--- a/third_party/go-algorand
+++ b/third_party/go-algorand
@@ -1 +1 @@
-Subproject commit b56953f449670398ee3ff850ed847b6e17d4e6af
+Subproject commit 09b6c38e12622e2bac3ed7f2013873e716f80003

From d83723113ea0ee555076b96bdf97675741646615 Mon Sep 17 00:00:00 2001
From: DevOps Service <devops-service@algorand.com>
Date: Thu, 10 Mar 2022 19:50:20 +0000
Subject: [PATCH 25/29] Bump version to 2.10.0-rc1

---
 .version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.version b/.version
index c8e38b614..77cb44310 100644
--- a/.version
+++ b/.version
@@ -1 +1 @@
-2.9.0
+2.10.0-rc1

From 4966aa3e4f86d496457686f6120d508c483ce733 Mon Sep 17 00:00:00 2001
From: Will Winder <wwinder.unh@gmail.com>
Date: Tue, 15 Mar 2022 10:53:55 -0400
Subject: [PATCH 26/29] Fix validator threads variable. (#927)

---
 cmd/validator/core/command.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/validator/core/command.go b/cmd/validator/core/command.go
index a5180f674..aa3531f05 100644
--- a/cmd/validator/core/command.go
+++ b/cmd/validator/core/command.go
@@ -42,7 +42,7 @@ func init() {
 	ValidatorCmd.Flags().IntVarP(&config.RetryDelayMS, "retry-delay", "", 1000, "Time in milliseconds to sleep between retries.")
 	ValidatorCmd.Flags().StringVar(&addr, "addr", "", "If provided validate a single address instead of reading Stdin.")
 	ValidatorCmd.Flags().IntVar(&threads, "threads", 4, "Number of worker threads to initialize.")
-	ValidatorCmd.Flags().IntVar(&threads, "processor", 0, "Choose compare algorithm [0 = Struct, 1 = Reflection]")
+	ValidatorCmd.Flags().IntVar(&processorNum, "processor", 0, "Choose compare algorithm [0 = Struct, 1 = Reflection]")
 	ValidatorCmd.Flags().BoolVar(&printCurl, "print-commands", false, "Print curl commands, including tokens, to query algod and indexer.")
 }
 

From 44a75e814ba6633e0698a51553104f08b0769ae2 Mon Sep 17 00:00:00 2001
From: AlgoStephenAkiki <85183435+AlgoStephenAkiki@users.noreply.github.com>
Date: Wed, 16 Mar 2022 11:03:24 -0400
Subject: [PATCH 27/29] Update indirect go module. (#932)

---
 go.mod | 2 +-
 go.sum | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/go.mod b/go.mod
index fd43de5d5..590488324 100644
--- a/go.mod
+++ b/go.mod
@@ -26,6 +26,6 @@ require (
 	github.com/stretchr/testify v1.7.0
 	github.com/vektra/mockery v1.1.2 // indirect
 	golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 // indirect
-	golang.org/x/tools v0.1.9 // indirect
+	golang.org/x/tools v0.1.10 // indirect
 	gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776
 )
diff --git a/go.sum b/go.sum
index 1d3384e6d..5a73497b0 100644
--- a/go.sum
+++ b/go.sum
@@ -812,6 +812,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38=
 golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3 h1:kQgndtyPBW/JIYERgdxfwMYh3AVStj88WQTlNDi2a+o=
+golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -1013,6 +1015,8 @@ golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc
 golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/tools v0.1.9 h1:j9KsMiaP1c3B0OTQGth0/k+miLGTgLsAFUCrF2vLcF8=
 golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
+golang.org/x/tools v0.1.10 h1:QjFRCZxdOhBJ/UNgnBZLbNV13DlbnK0quyivTnXJM20=
+golang.org/x/tools v0.1.10/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E=
 golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

From 21e8a98fd0e9204273ffeb0e53272a987765caf5 Mon Sep 17 00:00:00 2001
From: DevOps Service <devops-service@algorand.com>
Date: Thu, 17 Mar 2022 21:43:31 +0000
Subject: [PATCH 28/29] Bump version to 2.10.0

---
 .version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.version b/.version
index 77cb44310..10c2c0c3d 100644
--- a/.version
+++ b/.version
@@ -1 +1 @@
-2.10.0-rc1
+2.10.0

From 46a10993bd5028e1564b8ae87e528e050782a1fa Mon Sep 17 00:00:00 2001
From: Will Winder <wwinder.unh@gmail.com>
Date: Fri, 18 Mar 2022 18:18:00 -0400
Subject: [PATCH 29/29] Set max account API resource limit to 1000. (#933)

Co-authored-by: chris erway <51567+cce@users.noreply.github.com>
---
 api/handlers_e2e_test.go       | 23 ++++++++++++++++++-----
 cmd/algorand-indexer/daemon.go |  2 +-
 idb/postgres/postgres.go       | 12 ++++++------
 test/README.md                 |  2 +-
 test/common.sh                 |  4 ++--
 5 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/api/handlers_e2e_test.go b/api/handlers_e2e_test.go
index 9d675dc06..596eabf65 100644
--- a/api/handlers_e2e_test.go
+++ b/api/handlers_e2e_test.go
@@ -32,6 +32,8 @@ import (
 )
 
 var defaultOpts = ExtraOptions{
+	MaxAPIResourcesPerAccount: 1000,
+
 	MaxTransactionsLimit:     10000,
 	DefaultTransactionsLimit: 1000,
 
@@ -260,10 +262,11 @@ func TestAccountExcludeParameters(t *testing.T) {
 	//////////
 
 	testCases := []struct {
-		address   basics.Address
-		exclude   []string
-		check     func(*testing.T, generated.AccountResponse)
-		errStatus int
+		address        basics.Address
+		exclude        []string
+		check          func(*testing.T, generated.AccountResponse)
+		errStatus      int
+		includeDeleted bool
 	}{{
 		address: test.AccountA,
 		exclude: []string{"all"},
@@ -281,6 +284,15 @@ func TestAccountExcludeParameters(t *testing.T) {
 			require.NotNil(t, r.Account.Assets)
 			require.NotNil(t, r.Account.AppsLocalState)
 		}}, {
+		address:        test.AccountA,
+		exclude:        []string{},
+		includeDeleted: true,
+		check: func(t *testing.T, r generated.AccountResponse) {
+			require.NotNil(t, r.Account.CreatedAssets)
+			require.NotNil(t, r.Account.CreatedApps)
+			require.NotNil(t, r.Account.Assets)
+			require.NotNil(t, r.Account.AppsLocalState)
+		}}, {
 		address: test.AccountA,
 		check: func(t *testing.T, r generated.AccountResponse) {
 			require.NotNil(t, r.Account.CreatedAssets)
@@ -346,7 +358,7 @@ func TestAccountExcludeParameters(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(fmt.Sprintf("exclude %v", tc.exclude), func(t *testing.T) {
 			c, api, rec := setupReq("/v2/accounts/:account-id", "account-id", tc.address.String())
-			err := api.LookupAccountByID(c, tc.address.String(), generated.LookupAccountByIDParams{Exclude: &tc.exclude})
+			err := api.LookupAccountByID(c, tc.address.String(), generated.LookupAccountByIDParams{IncludeAll: &tc.includeDeleted, Exclude: &tc.exclude})
 			require.NoError(t, err)
 			if tc.errStatus != 0 {
 				require.Equal(t, tc.errStatus, rec.Code)
@@ -522,6 +534,7 @@ func TestAccountMaxResultsLimit(t *testing.T) {
 		includeDeleted bool
 		errStatus      int
 	}{
+		{address: test.AccountA, exclude: []string{}, errStatus: http.StatusBadRequest},
 		{address: test.AccountA, exclude: []string{"all"}},
 		{address: test.AccountA, exclude: []string{"created-assets", "created-apps", "apps-local-state", "assets"}},
 		{address: test.AccountA, exclude: []string{"assets", "created-apps"}},
diff --git a/cmd/algorand-indexer/daemon.go b/cmd/algorand-indexer/daemon.go
index dba0b3ff5..1d9f86c03 100644
--- a/cmd/algorand-indexer/daemon.go
+++ b/cmd/algorand-indexer/daemon.go
@@ -179,7 +179,7 @@ func init() {
 		daemonCmd.Flags().MarkHidden("enable-all-parameters")
 	}
 
-	daemonCmd.Flags().Uint32VarP(&maxAPIResourcesPerAccount, "max-api-resources-per-account", "", 0, "set the maximum total number of resources (created assets, created apps, asset holdings, and application local state) per account that will be allowed in REST API lookupAccountByID and searchForAccounts responses before returning a 400 Bad Request. Set zero for no limit (default: unlimited)")
+	daemonCmd.Flags().Uint32VarP(&maxAPIResourcesPerAccount, "max-api-resources-per-account", "", 1000, "set the maximum total number of resources (created assets, created apps, asset holdings, and application local state) per account that will be allowed in REST API lookupAccountByID and searchForAccounts responses before returning a 400 Bad Request. Set zero for no limit")
 
 	daemonCmd.Flags().Uint32VarP(&maxTransactionsLimit, "max-transactions-limit", "", 10000, "set the maximum allowed Limit parameter for querying transactions")
 	daemonCmd.Flags().Uint32VarP(&defaultTransactionsLimit, "default-transactions-limit", "", 1000, "set the default Limit parameter for querying transactions, if none is provided")
diff --git a/idb/postgres/postgres.go b/idb/postgres/postgres.go
index 6fc9b44d5..9a8950e3a 100644
--- a/idb/postgres/postgres.go
+++ b/idb/postgres/postgres.go
@@ -1758,7 +1758,7 @@ func (db *IndexerDb) checkAccountResourceLimit(ctx context.Context, tx pgx.Tx, o
 		var rewardsbase uint64
 		var keytype *string
 		var accountDataJSONStr []byte
-		var holdingCount, assetCount, appCount, lsCount uint64
+		var holdingCount, assetCount, appCount, lsCount sql.NullInt64
 		cols := []interface{}{&addr, &microalgos, &rewardstotal, &createdat, &closedat, &deleted, &rewardsbase, &keytype, &accountDataJSONStr}
 		if countOnly {
 			if o.IncludeAssetHoldings {
@@ -1788,10 +1788,10 @@ func (db *IndexerDb) checkAccountResourceLimit(ctx context.Context, tx pgx.Tx, o
 		// check limit against filters (only count what would be returned)
 		var resultCount, totalAssets, totalAssetParams, totalAppLocalStates, totalAppParams uint64
 		if countOnly {
-			totalAssets = holdingCount
-			totalAssetParams = assetCount
-			totalAppLocalStates = lsCount
-			totalAppParams = appCount
+			totalAssets = uint64(holdingCount.Int64)
+			totalAssetParams = uint64(assetCount.Int64)
+			totalAppLocalStates = uint64(lsCount.Int64)
+			totalAppParams = uint64(appCount.Int64)
 		} else {
 			totalAssets = ad.TotalAssets
 			totalAssetParams = ad.TotalAssetParams
@@ -1948,7 +1948,7 @@ func (db *IndexerDb) buildAccountQuery(opts idb.AccountQueryOptions, countOnly b
 			where = ` WHERE NOT la.deleted`
 		}
 		if countOnly {
-			selectCols = `count(*) as app_count`
+			selectCols = `count(*) as ls_count`
 		} else {
 			selectCols = `json_agg(la.app) as lsapps, json_agg(la.localstate) as lsls, json_agg(la.created_at) as ls_created_at, json_agg(la.closed_at) as ls_closed_at, json_agg(la.deleted) as ls_deleted`
 		}
diff --git a/test/README.md b/test/README.md
index f5944c4df..4301ef1cd 100644
--- a/test/README.md
+++ b/test/README.md
@@ -49,7 +49,7 @@ sql_test `<description>` `<database>` `<query>` `<substring>`
 
 # Debugging
 
-You'll need to break before the `algorand-indexer import` call and startup your debugger in import mode.
+Add true to the end of the `algorand-indexer import` call, use the provided command to initialize indexer.
 
 It may be useful to edit one of the entry point scripts to make sure the dataset you're interested in is loaded first.
 
diff --git a/test/common.sh b/test/common.sh
index 0e1a7c31a..4a1e3bc73 100755
--- a/test/common.sh
+++ b/test/common.sh
@@ -441,12 +441,12 @@ function create_delete_tests() {
       '"created-at-round": 13' \
       '"deleted-at-round": 37'
 
-    rest_test "[rest - account/application] account with a deleted application" \
+    rest_test "[rest - account/application] account with a deleted application excluded" \
       "/v2/accounts/XNMIHFHAZ2GE3XUKISNMOYKNFDOJXBJMVHRSXVVVIK3LNMT22ET2TA4N4I?pretty" \
       200 \
       false \
       '"id": 82'
-    rest_test "[rest - account/application] account with a deleted application" \
+    rest_test "[rest - account/application] account with a deleted application included" \
       "/v2/accounts/XNMIHFHAZ2GE3XUKISNMOYKNFDOJXBJMVHRSXVVVIK3LNMT22ET2TA4N4I?pretty&include-all=true" \
       200 \
       true \