diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index 722806bac..000000000
--- a/.gitmodules
+++ /dev/null
@@ -1,4 +0,0 @@
-[submodule "go-algorand"]
-	path = third_party/go-algorand
-	url = https://github.com/algorand/go-algorand
-	branch = rel/nightly
diff --git a/Makefile b/Makefile
index 8abbcc396..08b084e40 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,4 @@
 SRCPATH		:= $(shell pwd)
-OS_TYPE		?= $(shell $(SRCPATH)/mule/scripts/ostype.sh)
-ARCH		?= $(shell $(SRCPATH)/mule/scripts/archtype.sh)
 ifeq ($(OS_TYPE), darwin)
 ifeq ($(ARCH), arm64)
 export CPATH=/opt/homebrew/include
@@ -56,19 +54,10 @@ e2e: cmd/algorand-indexer/algorand-indexer
 e2e-filter-test: cmd/algorand-indexer/algorand-indexer
 	cd e2e_tests/docker/indexer-filtered/ && docker-compose build --build-arg GO_IMAGE=${GO_IMAGE} && docker-compose up --exit-code-from e2e-read
 
-deploy:
-	mule/deploy.sh
-
-sign:
-	mule/sign.sh
-
-test-package:
-	mule/e2e.sh
-
 test-generate:
 	test/test_generate.py
 
 indexer-v-algod:
 	pytest -sv misc/parity
 
-.PHONY: all test e2e integration fmt lint deploy sign test-package package fakepackage cmd/algorand-indexer/algorand-indexer idb/mocks/IndexerDb.go indexer-v-algod
+.PHONY: all test e2e integration fmt lint package fakepackage cmd/algorand-indexer/algorand-indexer idb/mocks/IndexerDb.go indexer-v-algod
diff --git a/cmd/algorand-indexer/daemon.go b/cmd/algorand-indexer/daemon.go
index d724601ee..6c19150dd 100644
--- a/cmd/algorand-indexer/daemon.go
+++ b/cmd/algorand-indexer/daemon.go
@@ -30,7 +30,7 @@ type daemonConfig struct {
 	tokenString               string
 	writeTimeout              time.Duration
 	readTimeout               time.Duration
-	maxConn                   uint32
+	maxConns                  int32
 	maxAPIResourcesPerAccount uint32
 	maxTransactionsLimit      uint32
 	defaultTransactionsLimit  uint32
@@ -74,7 +74,7 @@ func DaemonCmd() *cobra.Command {
 	cfg.flags.StringVarP(&cfg.metricsMode, "metrics-mode", "", "OFF", "configure the /metrics endpoint to [ON, OFF, VERBOSE]")
 	cfg.flags.DurationVarP(&cfg.writeTimeout, "write-timeout", "", 30*time.Second, "set the maximum duration to wait before timing out writes to a http response, breaking connection")
 	cfg.flags.DurationVarP(&cfg.readTimeout, "read-timeout", "", 5*time.Second, "set the maximum duration for reading the entire request")
-	cfg.flags.Uint32VarP(&cfg.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")
+	cfg.flags.Int32VarP(&cfg.maxConns, "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")
 
 	cfg.flags.StringVar(&cfg.suppliedAPIConfigFile, "api-config-file", "", "supply an API config file to enable/disable parameters")
 	cfg.flags.BoolVar(&cfg.enableAllParameters, "enable-all-parameters", false, "override default configuration and enable all parameters. Can't be used with --api-config-file")
@@ -279,7 +279,7 @@ func runDaemon(daemonConfig *daemonConfig) error {
 	opts := idb.IndexerDbOptions{}
 	opts.ReadOnly = true
 
-	opts.MaxConn = daemonConfig.maxConn
+	opts.MaxConns = daemonConfig.maxConns
 	opts.IndexerDatadir = daemonConfig.indexerDataDir
 
 	db, _, err := indexerDbFromFlags(opts)
diff --git a/idb/idb.go b/idb/idb.go
index c91b1c0b7..dab97230a 100644
--- a/idb/idb.go
+++ b/idb/idb.go
@@ -411,7 +411,7 @@ type IndexerDbOptions struct {
 	// Maximum connection number for connection pool
 	// This means the total number of active queries that can be running
 	// concurrently can never be more than this
-	MaxConn uint32
+	MaxConns int32
 
 	IndexerDatadir string
 	AlgodDataDir   string
diff --git a/idb/postgres/indexerDb.go b/idb/postgres/indexerDb.go
new file mode 100644
index 000000000..8045c99f6
--- /dev/null
+++ b/idb/postgres/indexerDb.go
@@ -0,0 +1,70 @@
+package postgres
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/jackc/pgx/v4"
+	"github.com/jackc/pgx/v4/pgxpool"
+	log "github.com/sirupsen/logrus"
+
+	"github.com/algorand/indexer/v3/idb/migration"
+)
+
+// const useExperimentalTxnInsertion = false
+// const useExperimentalWithIntraBugfix = true
+
+var serializable = pgx.TxOptions{IsoLevel: pgx.Serializable} // be a real ACID database
+var readonlyRepeatableRead = pgx.TxOptions{IsoLevel: pgx.RepeatableRead, AccessMode: pgx.ReadOnly}
+
+// in actuality, for postgres the following is no weaker than ReadCommitted:
+// https://www.postgresql.org/docs/current/transaction-iso.html
+// TODO: change this to pgs.ReadCommitted
+// var uncommitted = pgx.TxOptions{IsoLevel: pgx.ReadUncommitted}
+
+
+
+// var experimentalCommitLevel = uncommitted // serializable // uncommitted
+
+// IndexerDb is an idb.IndexerDB implementation
+type IndexerDb struct {
+	readonly bool
+	log      *log.Logger
+
+	db             *pgxpool.Pool
+	migration      *migration.Migration
+	accountingLock sync.Mutex
+
+	TuningParams
+}
+
+// TuningParams are database interaction settings that can be
+// fine tuned to improve performance based on a specific hardware deployment
+// and workload characteristics.
+type TuningParams struct {
+	PgxOpts   pgx.TxOptions
+	BatchSize uint32
+}
+
+// defaultTuningParams returns a TuningParams object with default values.
+func defaultTuningParams() TuningParams{
+	return TuningParams{
+		PgxOpts:   serializable,
+		BatchSize: 2500,
+	}
+}
+
+func shortName(isoLevel pgx.TxIsoLevel) string {
+	switch isoLevel {
+	case pgx.Serializable:
+		return "S"
+	case pgx.RepeatableRead:
+		return "RR"
+	case pgx.ReadCommitted:
+		return "RC"
+	case pgx.ReadUncommitted:
+		return "RU"
+	default:
+		return fmt.Sprintf("unknown_%s", isoLevel)
+	}
+}
\ No newline at end of file
diff --git a/idb/postgres/internal/testing/testing.go b/idb/postgres/internal/testing/testing.go
index 1f24bd6b0..52f838250 100644
--- a/idb/postgres/internal/testing/testing.go
+++ b/idb/postgres/internal/testing/testing.go
@@ -17,6 +17,13 @@ import (
 
 var testpg string
 
+var knownPgImages = map[string]struct{}{
+	"13-alpine": {},
+	"14":        {},
+	"15":        {},
+	"16beta3":   {},
+}
+
 func init() {
 	flag.StringVar(&testpg, "test-pg", "", "postgres connection string; resets the database")
 	if testpg == "" {
@@ -28,7 +35,7 @@ func init() {
 
 // SetupPostgres starts a gnomock postgres DB then returns the database object,
 // the connection string and a shutdown function.
-func SetupPostgres(t *testing.T) (*pgxpool.Pool, string, func()) {
+func SetupPostgres(t testing.TB) (*pgxpool.Pool, string, func()) {
 	if testpg != "" {
 		// use non-docker Postgresql
 		connStr := testpg
@@ -47,8 +54,16 @@ func SetupPostgres(t *testing.T) (*pgxpool.Pool, string, func()) {
 		return db, connStr, shutdownFunc
 	}
 
+	return SetupGnomockPgWithVersion(t, "13-alpine")
+}
+
+func SetupGnomockPgWithVersion(t testing.TB, pgImage string) (*pgxpool.Pool, string, func()) {
+	if _, ok := knownPgImages[pgImage]; !ok {
+		t.Fatalf("SetupGnomockPgWithVersion(): unrecognized postgres Docker image for gnomock preset: %s", pgImage)
+	}
+
 	p := postgres.Preset(
-		postgres.WithVersion("13-alpine"),
+		postgres.WithVersion(pgImage),
 		postgres.WithUser("gnomock", "gnomick"),
 		postgres.WithDatabase("mydb"),
 	)
@@ -61,6 +76,16 @@ func SetupPostgres(t *testing.T) (*pgxpool.Pool, string, func()) {
 		"gnomock", "gnomick", "mydb",
 	)
 
+	// config, err := pgxpool.ParseConfig(connStr)
+	// require.NoError(t, err, "Error parsing connection string: %s", connStr)
+
+	// if maxConns != nil {
+	// 	config.MaxConns = *maxConns
+	// }
+	
+	// db, err := pgxpool.ConnectConfig(context.Background(), config)
+	// require.NoError(t, err, "Error creating connection pool via config: %#v", config)
+
 	db, err := pgxpool.Connect(context.Background(), connStr)
 	require.NoError(t, err, "Error opening postgres connection")
 
diff --git a/idb/postgres/internal/writer/write_txn.go b/idb/postgres/internal/writer/write_txn.go
index 4a6be5f0b..001a30e37 100644
--- a/idb/postgres/internal/writer/write_txn.go
+++ b/idb/postgres/internal/writer/write_txn.go
@@ -64,7 +64,7 @@ func transactionAssetID(stxnad *types.SignedTxnWithAD, intra uint, block *types.
 
 // Traverses the inner transaction tree and writes database rows
 // to `outCh`. It performs a preorder traversal to correctly compute
-// the intra round offset, the offset for the next transaction is returned.
+// the intra round offset for the next transaction is returned.
 func yieldInnerTransactions(ctx context.Context, stxnad *types.SignedTxnWithAD, block *types.Block, intra, rootIntra uint, rootTxid string, outCh chan []interface{}) (uint, error) {
 	for _, itxn := range stxnad.ApplyData.EvalDelta.InnerTxns {
 		txn := &itxn.Txn
@@ -109,10 +109,59 @@ func yieldInnerTransactions(ctx context.Context, stxnad *types.SignedTxnWithAD,
 	return intra, nil
 }
 
+// // Writes database rows for transactions (including inner transactions) to `outCh`.
+// func yieldTransactionsW(ctx context.Context, block *types.Block, start uint64, payset []types.SignedTxnInBlock, outCh chan []interface{}) error {
+// 	// This is a bug. We've lost context of the txn counter at this point,
+// 	// and we're actually supplying the index in the payset:
+// 	intra := uint(start)
+// 	for idx, stib := range payset {
+// 		var stxnad types.SignedTxnWithAD
+// 		var err error
+// 		// This function makes sure to set correct genesis information so we can get the
+// 		// correct transaction hash.
+// 		stxnad.SignedTxn, stxnad.ApplyData, err = util.DecodeSignedTxn(block.BlockHeader, stib)
+// 		if err != nil {
+// 			return fmt.Errorf("yieldTransactions() decode signed txn err: %w", err)
+// 		}
+
+// 		txn := &stxnad.Txn
+// 		typeenum, ok := idb.GetTypeEnum(types.TxType(txn.Type))
+// 		if !ok {
+// 			return fmt.Errorf("yieldTransactions() get type enum")
+// 		}
+// 		assetid, err := transactionAssetID(&stxnad, intra, block)
+// 		if err != nil {
+// 			return err
+// 		}
+// 		id := crypto.TransactionIDString(*txn)
+
+// 		extra := idb.TxnExtra{
+// 			AssetCloseAmount: payset[idx].ApplyData.AssetClosingAmount,
+// 		}
+// 		row := []interface{}{
+// 			uint64(block.Round), intra, int(typeenum), assetid, id,
+// 			encoding.EncodeSignedTxnWithAD(stxnad),
+// 			encoding.EncodeTxnExtra(&extra)}
+// 		select {
+// 		case <-ctx.Done():
+// 			return fmt.Errorf("yieldTransactions() ctx.Err(): %w", ctx.Err())
+// 		case outCh <- row:
+// 		}
+
+// 		intra, err = yieldInnerTransactions(
+// 			ctx, &stib.SignedTxnWithAD, block, intra+1, intra, id, outCh)
+// 		if err != nil {
+// 			return fmt.Errorf("yieldTransactions() adding inner: %w", err)
+// 		}
+// 	}
+
+// 	return nil
+// }
+
 // Writes database rows for transactions (including inner transactions) to `outCh`.
-func yieldTransactions(ctx context.Context, block *types.Block, modifiedTxns []types.SignedTxnInBlock, outCh chan []interface{}) error {
-	intra := uint(0)
-	for idx, stib := range block.Payset {
+func yieldTransactions(ctx context.Context, block *types.Block, payset []types.SignedTxnInBlock, start uint, outCh chan []interface{}) error {
+	intra := start
+	for idx, stib := range payset {
 		var stxnad types.SignedTxnWithAD
 		var err error
 		// This function makes sure to set correct genesis information so we can get the
@@ -134,7 +183,7 @@ func yieldTransactions(ctx context.Context, block *types.Block, modifiedTxns []t
 		id := crypto.TransactionIDString(*txn)
 
 		extra := idb.TxnExtra{
-			AssetCloseAmount: modifiedTxns[idx].ApplyData.AssetClosingAmount,
+			AssetCloseAmount: payset[idx].ApplyData.AssetClosingAmount,
 		}
 		row := []interface{}{
 			uint64(block.Round), intra, int(typeenum), assetid, id,
@@ -156,16 +205,62 @@ func yieldTransactions(ctx context.Context, block *types.Block, modifiedTxns []t
 	return nil
 }
 
+// // Writes database rows for transactions (including inner transactions) to `outCh`.
+// func yieldTransactionsOLD(ctx context.Context, block *types.Block, modifiedTxns []types.SignedTxnInBlock, outCh chan []interface{}) error {
+// 	intra := uint(0)
+// 	for idx, stib := range block.Payset {
+// 		var stxnad types.SignedTxnWithAD
+// 		var err error
+// 		// This function makes sure to set correct genesis information so we can get the
+// 		// correct transaction hash.
+// 		stxnad.SignedTxn, stxnad.ApplyData, err = util.DecodeSignedTxn(block.BlockHeader, stib)
+// 		if err != nil {
+// 			return fmt.Errorf("yieldTransactions() decode signed txn err: %w", err)
+// 		}
+// 		txn := &stxnad.Txn
+// 		typeenum, ok := idb.GetTypeEnum(types.TxType(txn.Type))
+// 		if !ok {
+// 			return fmt.Errorf("yieldTransactions() get type enum")
+// 		}
+// 		assetid, err := transactionAssetID(&stxnad, intra, block)
+// 		if err != nil {
+// 			return err
+// 		}
+// 		id := crypto.TransactionIDString(*txn)
+
+// 		extra := idb.TxnExtra{
+// 			AssetCloseAmount: modifiedTxns[idx].ApplyData.AssetClosingAmount,
+// 		}
+// 		row := []interface{}{
+// 			uint64(block.Round), intra, int(typeenum), assetid, id,
+// 			encoding.EncodeSignedTxnWithAD(stxnad),
+// 			encoding.EncodeTxnExtra(&extra)}
+// 		select {
+// 		case <-ctx.Done():
+// 			return fmt.Errorf("yieldTransactions() ctx.Err(): %w", ctx.Err())
+// 		case outCh <- row:
+// 		}
+// 		intra, err = yieldInnerTransactions(
+// 			ctx, &stib.SignedTxnWithAD, block, intra+1, intra, id, outCh)
+// 		if err != nil {
+// 			return fmt.Errorf("yieldTransactions() adding inner: %w", err)
+// 		}
+// 	}
+// 	return nil
+// }
+
 // AddTransactions adds transactions from `block` to the database.
 // `modifiedTxns` contains enhanced apply data generated by evaluator.
-func AddTransactions(block *types.Block, modifiedTxns []types.SignedTxnInBlock, tx pgx.Tx) error {
+// `block` is used for decoding the transaction according to the active
+// protocol
+func AddTransactions(tx pgx.Tx, block *types.Block, payset []types.SignedTxnInBlock, left IndexAndIntra) error {
 	ctx, cancelFunc := context.WithCancel(context.Background())
 	defer cancelFunc()
 
 	ch := make(chan []interface{}, 1024)
 	var err0 error
 	go func() {
-		err0 = yieldTransactions(ctx, block, modifiedTxns, ch)
+		err0 = yieldTransactions(ctx, block, payset, left.Intra, ch)
 		close(ch)
 	}()
 
@@ -187,3 +282,110 @@ func AddTransactions(block *types.Block, modifiedTxns []types.SignedTxnInBlock,
 
 	return nil
 }
+
+// AddTransactionsW adds transactions from `block` to the database.
+// `modifiedTxns` contains enhanced apply data generated by evaluator.
+// `block` is used for decoding the transaction according to the active
+// protocol
+// func AddTransactionsW(block *types.Block, start uint64, payset []types.SignedTxnInBlock, tx pgx.Tx) error {
+// 	ctx, cancelFunc := context.WithCancel(context.Background())
+// 	defer cancelFunc()
+
+// 	ch := make(chan []interface{}, 1024)
+// 	var err0 error
+// 	go func() {
+// 		err0 = yieldTransactionsW(ctx, block, start, payset, ch)
+// 		close(ch)
+// 	}()
+
+// 	_, err1 := tx.CopyFrom(
+// 		context.Background(),
+// 		pgx.Identifier{"txn"},
+// 		[]string{"round", "intra", "typeenum", "asset", "txid", "txn", "extra"},
+// 		copyFromChannel(ch))
+// 	if err1 != nil {
+// 		// Exiting here will call `cancelFunc` which will cause the goroutine above to exit.
+// 		return fmt.Errorf("addTransactions() copy from err: %w", err1)
+// 	}
+
+// 	// CopyFrom() exited successfully, so `ch` has been closed, so `err0` has been
+// 	// written to, and we can read it without worrying about data races.
+// 	if err0 != nil {
+// 		return fmt.Errorf("addTransactions() err: %w", err0)
+// 	}
+
+// 	return nil
+// }
+
+// AddTransactionsOLD adds transactions from `block` to the database.
+// `modifiedTxns` contains enhanced apply data generated by evaluator.
+// func AddTransactionsOLD(block *types.Block, modifiedTxns []types.SignedTxnInBlock, tx pgx.Tx) error {
+// 	ctx, cancelFunc := context.WithCancel(context.Background())
+// 	defer cancelFunc()
+
+// 	ch := make(chan []interface{}, 1024)
+// 	var err0 error
+// 	go func() {
+// 		err0 = yieldTransactionsOLD(ctx, block, modifiedTxns, ch)
+// 		close(ch)
+// 	}()
+
+// 	_, err1 := tx.CopyFrom(
+// 		context.Background(),
+// 		pgx.Identifier{"txn"},
+// 		[]string{"round", "intra", "typeenum", "asset", "txid", "txn", "extra"},
+// 		copyFromChannel(ch))
+// 	if err1 != nil {
+// 		// Exiting here will call `cancelFunc` which will cause the goroutine above to exit.
+// 		return fmt.Errorf("addTransactionsOLD() copy from err: %w", err1)
+// 	}
+// 	// CopyFrom() exited successfully, so `ch` has been closed, so `err0` has been
+// 	// written to, and we can read it without worrying about data races.
+// 	if err0 != nil {
+// 		return fmt.Errorf("addTransactionsOLD() err: %w", err0)
+// 	}
+// 	return nil
+// }
+
+type IndexAndIntra struct {
+	Index int
+	Intra uint
+}
+
+// innerTxnTreeSize computes the number of transactions in the inner transaction tree.
+// Since the root is the original transaction, we start at 1 even if there are no
+// inner transactions.
+func innerTxnTreeSize(stxnad *types.SignedTxnWithAD) (size uint) {
+	size++
+	for _, itxn := range stxnad.ApplyData.EvalDelta.InnerTxns {
+		size += innerTxnTreeSize(&itxn)
+	}
+	return
+}
+
+// CutBatches takes the payset returns a list of batches.
+// TODO: should we respect transaction group boundaries?
+func CutBatches(payset []types.SignedTxnInBlock, batchMinSize uint) []IndexAndIntra {
+	cuts := make([]IndexAndIntra, 0)
+	if len(payset) == 0 {
+		return cuts
+	}
+
+	index, intra := 0, uint(0)
+	cuts = append(cuts, IndexAndIntra{index, intra})
+	var dangling bool
+	for leftIntra := intra; index < len(payset); {
+		dangling = true
+		intra += innerTxnTreeSize(&payset[index].SignedTxnWithAD)
+		index++
+		if intra >= leftIntra + batchMinSize {
+			cuts = append(cuts, IndexAndIntra{index, intra})
+			leftIntra = intra
+			dangling = false
+		}
+	}
+	if dangling {
+		cuts = append(cuts, IndexAndIntra{index, intra})
+	}
+	return cuts
+}
diff --git a/idb/postgres/internal/writer/write_txn_participation.go b/idb/postgres/internal/writer/write_txn_participation.go
index 65edf1c1c..7d78ec0e5 100644
--- a/idb/postgres/internal/writer/write_txn_participation.go
+++ b/idb/postgres/internal/writer/write_txn_participation.go
@@ -111,18 +111,18 @@ func addInnerTransactionParticipation(stxnad *types.SignedTxnWithAD, round, intr
 
 // AddTransactionParticipation writes account participation info to the
 // `txn_participation` table.
-func AddTransactionParticipation(block *types.Block, tx pgx.Tx) error {
+func AddTransactionParticipation(round uint64, payset []types.SignedTxnInBlock, tx pgx.Tx) error {
 	var rows [][]interface{}
 	next := uint64(0)
 
-	for _, stxnib := range block.Payset {
+	for _, stxnib := range payset {
 		participants := getTransactionParticipants(&stxnib.SignedTxnWithAD, true)
 
 		for j := range participants {
-			rows = append(rows, []interface{}{participants[j][:], uint64(block.Round), next})
+			rows = append(rows, []interface{}{participants[j][:], round, next})
 		}
 
-		next, rows = addInnerTransactionParticipation(&stxnib.SignedTxnWithAD, uint64(block.Round), next+1, rows)
+		next, rows = addInnerTransactionParticipation(&stxnib.SignedTxnWithAD, round, next+1, rows)
 	}
 
 	_, err := tx.CopyFrom(
@@ -136,3 +136,30 @@ func AddTransactionParticipation(block *types.Block, tx pgx.Tx) error {
 
 	return nil
 }
+
+// AddTransactionParticipationOLD writes account participation info to the
+// `txn_participation` table.
+// func AddTransactionParticipationOLD(block *types.Block, tx pgx.Tx) error {
+// 	var rows [][]interface{}
+// 	next := uint64(0)
+
+// 	for _, stxnib := range block.Payset {
+// 		participants := getTransactionParticipants(&stxnib.SignedTxnWithAD, true)
+
+// 		for j := range participants {
+// 			rows = append(rows, []interface{}{participants[j][:], uint64(block.Round), next})
+// 		}
+
+// 		next, rows = addInnerTransactionParticipation(&stxnib.SignedTxnWithAD, uint64(block.Round), next+1, rows)
+// 	}
+
+// 	_, err := tx.CopyFrom(
+// 		context.Background(),
+// 		pgx.Identifier{"txn_participation"},
+// 		[]string{"addr", "round", "intra"},
+// 		pgx.CopyFromRows(rows))
+// 	if err != nil {
+// 		return fmt.Errorf("addTransactionParticipationOLD() copy from err: %w", err)
+// 	}
+// 	return nil
+// }
diff --git a/idb/postgres/internal/writer/writer_test.go b/idb/postgres/internal/writer/writer_test.go
index d793b97a4..4a72fcf47 100644
--- a/idb/postgres/internal/writer/writer_test.go
+++ b/idb/postgres/internal/writer/writer_test.go
@@ -2,7 +2,6 @@ package writer_test
 
 import (
 	"context"
-	"fmt"
 	"math"
 	"testing"
 	"time"
@@ -23,7 +22,6 @@ import (
 	"github.com/algorand/indexer/v3/util"
 	"github.com/algorand/indexer/v3/util/test"
 
-	crypto2 "github.com/algorand/go-algorand-sdk/v2/crypto"
 	sdk "github.com/algorand/go-algorand-sdk/v2/types"
 )
 
@@ -168,151 +166,151 @@ func TestWriterSpecialAccounts(t *testing.T) {
 	assert.Equal(t, expected, accounts)
 }
 
-func TestWriterTxnTableBasic(t *testing.T) {
-	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
-	defer shutdownFunc()
-
-	block := sdk.Block{
-		BlockHeader: sdk.BlockHeader{
-			Round:       sdk.Round(2),
-			TimeStamp:   333,
-			GenesisID:   test.MakeGenesis().ID(),
-			GenesisHash: test.MakeGenesis().Hash(),
-			RewardsState: sdk.RewardsState{
-				RewardsLevel: 111111,
-			},
-			TxnCounter: 9,
-			UpgradeState: sdk.UpgradeState{
-				CurrentProtocol: "future",
-			},
-		},
-		Payset: make([]sdk.SignedTxnInBlock, 2),
-	}
-
-	stxnad0 := test.MakePaymentTxn(
-		1000, 1, 0, 0, 0, 0, sdk.Address(test.AccountA), sdk.Address(test.AccountB), sdk.Address{},
-		sdk.Address{})
-	var err error
-	block.Payset[0], err =
-		util.EncodeSignedTxn(block.BlockHeader, stxnad0.SignedTxn, stxnad0.ApplyData)
-	require.NoError(t, err)
-
-	stxnad1 := test.MakeAssetConfigTxn(
-		0, 100, 1, false, "ma", "myasset", "myasset.com", sdk.Address(test.AccountA))
-	block.Payset[1], err =
-		util.EncodeSignedTxn(block.BlockHeader, stxnad1.SignedTxn, stxnad1.ApplyData)
-	require.NoError(t, err)
-
-	f := func(tx pgx.Tx) error {
-		return writer.AddTransactions(&block, block.Payset, tx)
-	}
-	err = pgutil.TxWithRetry(db, serializable, f, nil)
-	require.NoError(t, err)
-
-	rows, err := db.Query(context.Background(), "SELECT * FROM txn ORDER BY intra")
-	require.NoError(t, err)
-	defer rows.Close()
-
-	var round uint64
-	var intra uint64
-	var typeenum uint
-	var asset uint64
-	var txid []byte
-	var txn []byte
-	var extra []byte
-
-	require.True(t, rows.Next())
-	err = rows.Scan(&round, &intra, &typeenum, &asset, &txid, &txn, &extra)
-	require.NoError(t, err)
-	assert.Equal(t, block.Round, sdk.Round(round))
-	assert.Equal(t, uint64(0), intra)
-	assert.Equal(t, idb.TypeEnumPay, idb.TxnTypeEnum(typeenum))
-	assert.Equal(t, uint64(0), asset)
-	assert.Equal(t, crypto2.TransactionIDString(stxnad0.Txn), string(txid))
-	{
-		stxn, err := encoding.DecodeSignedTxnWithAD(txn)
-		require.NoError(t, err)
-		assert.Equal(t, stxnad0, stxn)
-	}
-	assert.Equal(t, "{}", string(extra))
-
-	require.True(t, rows.Next())
-	err = rows.Scan(&round, &intra, &typeenum, &asset, &txid, &txn, &extra)
-	require.NoError(t, err)
-	assert.Equal(t, block.Round, sdk.Round(round))
-	assert.Equal(t, uint64(1), intra)
-	assert.Equal(t, idb.TypeEnumAssetConfig, idb.TxnTypeEnum(typeenum))
-	assert.Equal(t, uint64(9), asset)
-	assert.Equal(t, crypto2.TransactionIDString(stxnad1.Txn), string(txid))
-	{
-		stxn, err := encoding.DecodeSignedTxnWithAD(txn)
-		require.NoError(t, err)
-		assert.Equal(t, stxnad1, stxn)
-	}
-	assert.Equal(t, "{}", string(extra))
-
-	assert.False(t, rows.Next())
-	assert.NoError(t, rows.Err())
-}
+// func TestWriterTxnTableBasic(t *testing.T) {
+// 	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+// 	defer shutdownFunc()
+
+// 	block := sdk.Block{
+// 		BlockHeader: sdk.BlockHeader{
+// 			Round:       sdk.Round(2),
+// 			TimeStamp:   333,
+// 			GenesisID:   test.MakeGenesis().ID(),
+// 			GenesisHash: test.MakeGenesis().Hash(),
+// 			RewardsState: sdk.RewardsState{
+// 				RewardsLevel: 111111,
+// 			},
+// 			TxnCounter: 9,
+// 			UpgradeState: sdk.UpgradeState{
+// 				CurrentProtocol: "future",
+// 			},
+// 		},
+// 		Payset: make([]sdk.SignedTxnInBlock, 2),
+// 	}
+
+// 	stxnad0 := test.MakePaymentTxn(
+// 		1000, 1, 0, 0, 0, 0, sdk.Address(test.AccountA), sdk.Address(test.AccountB), sdk.Address{},
+// 		sdk.Address{})
+// 	var err error
+// 	block.Payset[0], err =
+// 		util.EncodeSignedTxn(block.BlockHeader, stxnad0.SignedTxn, stxnad0.ApplyData)
+// 	require.NoError(t, err)
+
+// 	stxnad1 := test.MakeAssetConfigTxn(
+// 		0, 100, 1, false, "ma", "myasset", "myasset.com", sdk.Address(test.AccountA))
+// 	block.Payset[1], err =
+// 		util.EncodeSignedTxn(block.BlockHeader, stxnad1.SignedTxn, stxnad1.ApplyData)
+// 	require.NoError(t, err)
+
+// 	f := func(tx pgx.Tx) error {
+// 		return writer.AddTransactionsW(&block, 0, block.Payset, tx)
+// 	}
+// 	err = pgutil.TxWithRetry(db, serializable, f, nil)
+// 	require.NoError(t, err)
+
+// 	rows, err := db.Query(context.Background(), "SELECT * FROM txn ORDER BY intra")
+// 	require.NoError(t, err)
+// 	defer rows.Close()
+
+// 	var round uint64
+// 	var intra uint64
+// 	var typeenum uint
+// 	var asset uint64
+// 	var txid []byte
+// 	var txn []byte
+// 	var extra []byte
+
+// 	require.True(t, rows.Next())
+// 	err = rows.Scan(&round, &intra, &typeenum, &asset, &txid, &txn, &extra)
+// 	require.NoError(t, err)
+// 	assert.Equal(t, block.Round, sdk.Round(round))
+// 	assert.Equal(t, uint64(0), intra)
+// 	assert.Equal(t, idb.TypeEnumPay, idb.TxnTypeEnum(typeenum))
+// 	assert.Equal(t, uint64(0), asset)
+// 	assert.Equal(t, crypto2.TransactionIDString(stxnad0.Txn), string(txid))
+// 	{
+// 		stxn, err := encoding.DecodeSignedTxnWithAD(txn)
+// 		require.NoError(t, err)
+// 		assert.Equal(t, stxnad0, stxn)
+// 	}
+// 	assert.Equal(t, "{}", string(extra))
+
+// 	require.True(t, rows.Next())
+// 	err = rows.Scan(&round, &intra, &typeenum, &asset, &txid, &txn, &extra)
+// 	require.NoError(t, err)
+// 	assert.Equal(t, block.Round, sdk.Round(round))
+// 	assert.Equal(t, uint64(1), intra)
+// 	assert.Equal(t, idb.TypeEnumAssetConfig, idb.TxnTypeEnum(typeenum))
+// 	assert.Equal(t, uint64(9), asset)
+// 	assert.Equal(t, crypto2.TransactionIDString(stxnad1.Txn), string(txid))
+// 	{
+// 		stxn, err := encoding.DecodeSignedTxnWithAD(txn)
+// 		require.NoError(t, err)
+// 		assert.Equal(t, stxnad1, stxn)
+// 	}
+// 	assert.Equal(t, "{}", string(extra))
+
+// 	assert.False(t, rows.Next())
+// 	assert.NoError(t, rows.Err())
+// }
 
 // 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 := pgtest.SetupPostgresWithSchema(t)
-	defer shutdownFunc()
-
-	block := sdk.Block{
-		BlockHeader: sdk.BlockHeader{
-			GenesisID:   test.MakeGenesis().ID(),
-			GenesisHash: test.MakeGenesis().Hash(),
-			UpgradeState: sdk.UpgradeState{
-				CurrentProtocol: "future",
-			},
-		},
-		Payset: make(sdk.Payset, 1),
-	}
-	stxnad := test.MakeAssetTransferTxn(1, 2, sdk.Address(test.AccountA), sdk.Address(test.AccountB), sdk.Address(test.AccountC))
-	var err error
-	block.Payset[0], err = util.EncodeSignedTxn(block.BlockHeader, stxnad.SignedTxn, stxnad.ApplyData)
-	require.NoError(t, err)
-
-	payset := []sdk.SignedTxnInBlock{block.Payset[0]}
-	payset[0].ApplyData.AssetClosingAmount = 3
-
-	f := func(tx pgx.Tx) error {
-		return writer.AddTransactions(&block, payset, tx)
-	}
-	err = pgutil.TxWithRetry(db, serializable, f, nil)
-	require.NoError(t, err)
-
-	rows, err := db.Query(
-		context.Background(), "SELECT txn, extra FROM txn ORDER BY intra")
-	require.NoError(t, err)
-	defer rows.Close()
-
-	var txn []byte
-	var extra []byte
-	require.True(t, rows.Next())
-	err = rows.Scan(&txn, &extra)
-	require.NoError(t, err)
-
-	{
-		ret, err := encoding.DecodeSignedTxnWithAD(txn)
-		require.NoError(t, err)
-		assert.Equal(t, stxnad, ret)
-	}
-	{
-		expected := idb.TxnExtra{AssetCloseAmount: 3}
-
-		actual, err := encoding.DecodeTxnExtra(extra)
-		require.NoError(t, err)
-
-		assert.Equal(t, expected, actual)
-	}
-
-	assert.False(t, rows.Next())
-	assert.NoError(t, rows.Err())
-}
+// func TestWriterTxnTableAssetCloseAmount(t *testing.T) {
+// 	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+// 	defer shutdownFunc()
+
+// 	block := sdk.Block{
+// 		BlockHeader: sdk.BlockHeader{
+// 			GenesisID:   test.MakeGenesis().ID(),
+// 			GenesisHash: test.MakeGenesis().Hash(),
+// 			UpgradeState: sdk.UpgradeState{
+// 				CurrentProtocol: "future",
+// 			},
+// 		},
+// 		Payset: make(sdk.Payset, 1),
+// 	}
+// 	stxnad := test.MakeAssetTransferTxn(1, 2, sdk.Address(test.AccountA), sdk.Address(test.AccountB), sdk.Address(test.AccountC))
+// 	var err error
+// 	block.Payset[0], err = util.EncodeSignedTxn(block.BlockHeader, stxnad.SignedTxn, stxnad.ApplyData)
+// 	require.NoError(t, err)
+
+// 	payset := []sdk.SignedTxnInBlock{block.Payset[0]}
+// 	payset[0].ApplyData.AssetClosingAmount = 3
+
+// 	f := func(tx pgx.Tx) error {
+// 		return writer.AddTransactionsW(&block, 0, payset, tx)
+// 	}
+// 	err = pgutil.TxWithRetry(db, serializable, f, nil)
+// 	require.NoError(t, err)
+
+// 	rows, err := db.Query(
+// 		context.Background(), "SELECT txn, extra FROM txn ORDER BY intra")
+// 	require.NoError(t, err)
+// 	defer rows.Close()
+
+// 	var txn []byte
+// 	var extra []byte
+// 	require.True(t, rows.Next())
+// 	err = rows.Scan(&txn, &extra)
+// 	require.NoError(t, err)
+
+// 	{
+// 		ret, err := encoding.DecodeSignedTxnWithAD(txn)
+// 		require.NoError(t, err)
+// 		assert.Equal(t, stxnad, ret)
+// 	}
+// 	{
+// 		expected := idb.TxnExtra{AssetCloseAmount: 3}
+
+// 		actual, err := encoding.DecodeTxnExtra(extra)
+// 		require.NoError(t, err)
+
+// 		assert.Equal(t, expected, actual)
+// 	}
+
+// 	assert.False(t, rows.Next())
+// 	assert.NoError(t, rows.Err())
+// }
 
 func TestWriterTxnParticipationTable(t *testing.T) {
 	type testtype struct {
@@ -410,7 +408,7 @@ func TestWriterTxnParticipationTable(t *testing.T) {
 			block.Payset = testcase.payset
 
 			f := func(tx pgx.Tx) error {
-				return writer.AddTransactionParticipation(&block, tx)
+				return writer.AddTransactionParticipation(uint64(block.Round), block.Payset, tx)
 			}
 			err := pgutil.TxWithRetry(db, serializable, f, nil)
 			require.NoError(t, err)
@@ -1347,179 +1345,179 @@ func TestWriterAccountAppTableCreateDeleteSameRound(t *testing.T) {
 	assert.Equal(t, block.Round, sdk.Round(closedAt))
 }
 
-func TestAddBlockInvalidInnerAsset(t *testing.T) {
-	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
-	defer shutdownFunc()
-
-	callWithBadInner := test.MakeCreateAppTxn(sdk.Address(test.AccountA))
-	callWithBadInner.ApplyData.EvalDelta.InnerTxns = []sdk.SignedTxnWithAD{
-		{
-			ApplyData: sdk.ApplyData{
-				// This is the invalid inner asset. It should not be zero.
-				ConfigAsset: 0,
-			},
-			SignedTxn: sdk.SignedTxn{
-				Txn: sdk.Transaction{
-					Type: sdk.AssetConfigTx,
-					Header: sdk.Header{
-						Sender: sdk.Address(test.AccountB),
-					},
-					AssetConfigTxnFields: sdk.AssetConfigTxnFields{
-						ConfigAsset: 0,
-					},
-				},
-			},
-		},
-	}
-
-	genesisBlock := test.MakeGenesisBlock()
-	block, err := test.MakeBlockForTxns(genesisBlock.BlockHeader, &callWithBadInner)
-	require.NoError(t, err)
-
-	err = makeTx(db, func(tx pgx.Tx) error {
-		return writer.AddTransactions(&block, block.Payset, tx)
-	})
-	require.Contains(t, err.Error(), "Missing ConfigAsset for transaction: ")
-}
-
-func TestWriterAddBlockInnerTxnsAssetCreate(t *testing.T) {
-	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
-	defer shutdownFunc()
-
-	// App call with inner txns, should be intra 0, 1, 2, 3, 4
-	var appAddr sdk.Address
-	appAddr[1] = 99
-	appCall := test.MakeAppCallWithInnerTxn(sdk.Address(test.AccountA), appAddr, sdk.Address(test.AccountB), appAddr, sdk.Address(test.AccountC))
-
-	// Asset create call, should have intra = 5
-	assetCreate := test.MakeAssetConfigTxn(
-		0, 100, 1, false, "ma", "myasset", "myasset.com", sdk.Address(test.AccountD))
-
-	genesisBlock := test.MakeGenesisBlock()
-	block, err := test.MakeBlockForTxns(genesisBlock.BlockHeader, &appCall, &assetCreate)
-	require.NoError(t, err)
-
-	err = makeTx(db, func(tx pgx.Tx) error {
-		err := writer.AddTransactions(&block, block.Payset, tx)
-		if err != nil {
-			return err
-		}
-		return writer.AddTransactionParticipation(&block, tx)
-	})
-	require.NoError(t, err)
-
-	txns, err := txnQuery(db, "SELECT * FROM txn ORDER BY intra")
-	require.NoError(t, err)
-	require.Len(t, txns, 6)
-
-	// Verify that intra is correctly assigned
-	for i, tx := range txns {
-		require.Equal(t, i, tx.intra, "Intra should be assigned 0 - 4.")
-	}
-
-	// Verify correct order of transaction types.
-	require.Equal(t, idb.TypeEnumApplication, txns[0].typeenum)
-	require.Equal(t, idb.TypeEnumPay, txns[1].typeenum)
-	require.Equal(t, idb.TypeEnumApplication, txns[2].typeenum)
-	require.Equal(t, idb.TypeEnumAssetTransfer, txns[3].typeenum)
-	require.Equal(t, idb.TypeEnumApplication, txns[4].typeenum)
-	require.Equal(t, idb.TypeEnumAssetConfig, txns[5].typeenum)
-
-	// Verify special properties of inner transactions.
-	expectedExtra := fmt.Sprintf(`{"root-txid": "%s", "root-intra": "%d"}`, txns[0].txid, 0)
-
-	// Inner pay 1
-	require.Equal(t, "", txns[1].txid)
-	require.Equal(t, expectedExtra, txns[1].extra)
-
-	// Inner pay 2
-	require.Equal(t, "", txns[2].txid)
-	require.Equal(t, expectedExtra, txns[2].extra)
-	require.NotContains(t, txns[2].txn, `"itx"`, "The inner transactions should be pruned.")
-
-	// Inner xfer
-	require.Equal(t, "", txns[3].txid)
-	require.Equal(t, expectedExtra, txns[3].extra)
-	require.NotContains(t, txns[3].txn, `"itx"`, "The inner transactions should be pruned.")
-
-	// Verify correct App and Asset IDs
-	require.Equal(t, 1, txns[0].asset, "intra == 0 -> ApplicationID = 1")
-	require.Equal(t, 789, txns[4].asset, "intra == 4 -> ApplicationID = 789")
-	require.Equal(t, 6, txns[5].asset, "intra == 5 -> AssetID = 6")
-
-	// Verify txn participation
-	txnPart, err := txnParticipationQuery(db, `SELECT * FROM txn_participation ORDER BY round, intra, addr`)
-	require.NoError(t, err)
-
-	expectedParticipation := []txnParticipationRow{
-		// Top-level appl transaction + inner transactions
-		{
-			addr:  appAddr,
-			round: 1,
-			intra: 0,
-		},
-		{
-			addr:  sdk.Address(test.AccountA),
-			round: 1,
-			intra: 0,
-		},
-		{
-			addr:  sdk.Address(test.AccountB),
-			round: 1,
-			intra: 0,
-		},
-		{
-			addr:  sdk.Address(test.AccountC),
-			round: 1,
-			intra: 0,
-		},
-		// Inner pay transaction 1
-		{
-			addr:  appAddr,
-			round: 1,
-			intra: 1,
-		},
-		{
-			addr:  sdk.Address(test.AccountB),
-			round: 1,
-			intra: 1,
-		},
-		// Inner pay transaction 2
-		{
-			addr:  appAddr,
-			round: 1,
-			intra: 2,
-		},
-		// Inner xfer transaction
-		{
-			addr:  appAddr,
-			round: 1,
-			intra: 3,
-		},
-		{
-			addr:  sdk.Address(test.AccountC),
-			round: 1,
-			intra: 3,
-		},
-		// Inner appl transaction
-		{
-			addr:  appAddr,
-			round: 1,
-			intra: 4,
-		},
-		// acfg after appl
-		{
-			addr:  sdk.Address(test.AccountD),
-			round: 1,
-			intra: 5,
-		},
-	}
-
-	require.Len(t, txnPart, len(expectedParticipation))
-	for i := 0; i < len(txnPart); i++ {
-		require.Equal(t, expectedParticipation[i], txnPart[i])
-	}
-}
+// func TestAddBlockInvalidInnerAsset(t *testing.T) {
+// 	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+// 	defer shutdownFunc()
+
+// 	callWithBadInner := test.MakeCreateAppTxn(sdk.Address(test.AccountA))
+// 	callWithBadInner.ApplyData.EvalDelta.InnerTxns = []sdk.SignedTxnWithAD{
+// 		{
+// 			ApplyData: sdk.ApplyData{
+// 				// This is the invalid inner asset. It should not be zero.
+// 				ConfigAsset: 0,
+// 			},
+// 			SignedTxn: sdk.SignedTxn{
+// 				Txn: sdk.Transaction{
+// 					Type: sdk.AssetConfigTx,
+// 					Header: sdk.Header{
+// 						Sender: sdk.Address(test.AccountB),
+// 					},
+// 					AssetConfigTxnFields: sdk.AssetConfigTxnFields{
+// 						ConfigAsset: 0,
+// 					},
+// 				},
+// 			},
+// 		},
+// 	}
+
+// 	genesisBlock := test.MakeGenesisBlock()
+// 	block, err := test.MakeBlockForTxns(genesisBlock.BlockHeader, &callWithBadInner)
+// 	require.NoError(t, err)
+
+// 	err = makeTx(db, func(tx pgx.Tx) error {
+// 		return writer.AddTransactionsW(&block, 0, block.Payset, tx)
+// 	})
+// 	require.Contains(t, err.Error(), "Missing ConfigAsset for transaction: ")
+// }
+
+// func TestWriterAddBlockInnerTxnsAssetCreate(t *testing.T) {
+// 	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
+// 	defer shutdownFunc()
+
+// 	// App call with inner txns, should be intra 0, 1, 2, 3, 4
+// 	var appAddr sdk.Address
+// 	appAddr[1] = 99
+// 	appCall := test.MakeAppCallWithInnerTxn(sdk.Address(test.AccountA), appAddr, sdk.Address(test.AccountB), appAddr, sdk.Address(test.AccountC))
+
+// 	// Asset create call, should have intra = 5
+// 	assetCreate := test.MakeAssetConfigTxn(
+// 		0, 100, 1, false, "ma", "myasset", "myasset.com", sdk.Address(test.AccountD))
+
+// 	genesisBlock := test.MakeGenesisBlock()
+// 	block, err := test.MakeBlockForTxns(genesisBlock.BlockHeader, &appCall, &assetCreate)
+// 	require.NoError(t, err)
+
+// 	err = makeTx(db, func(tx pgx.Tx) error {
+// 		err := writer.AddTransactionsW(&block, 0, block.Payset, tx)
+// 		if err != nil {
+// 			return err
+// 		}
+// 		return writer.AddTransactionParticipation(uint64(block.Round), block.Payset, tx)
+// 	})
+// 	require.NoError(t, err)
+
+// 	txns, err := txnQuery(db, "SELECT * FROM txn ORDER BY intra")
+// 	require.NoError(t, err)
+// 	require.Len(t, txns, 6)
+
+// 	// Verify that intra is correctly assigned
+// 	for i, tx := range txns {
+// 		require.Equal(t, i, tx.intra, "Intra should be assigned 0 - 4.")
+// 	}
+
+// 	// Verify correct order of transaction types.
+// 	require.Equal(t, idb.TypeEnumApplication, txns[0].typeenum)
+// 	require.Equal(t, idb.TypeEnumPay, txns[1].typeenum)
+// 	require.Equal(t, idb.TypeEnumApplication, txns[2].typeenum)
+// 	require.Equal(t, idb.TypeEnumAssetTransfer, txns[3].typeenum)
+// 	require.Equal(t, idb.TypeEnumApplication, txns[4].typeenum)
+// 	require.Equal(t, idb.TypeEnumAssetConfig, txns[5].typeenum)
+
+// 	// Verify special properties of inner transactions.
+// 	expectedExtra := fmt.Sprintf(`{"root-txid": "%s", "root-intra": "%d"}`, txns[0].txid, 0)
+
+// 	// Inner pay 1
+// 	require.Equal(t, "", txns[1].txid)
+// 	require.Equal(t, expectedExtra, txns[1].extra)
+
+// 	// Inner pay 2
+// 	require.Equal(t, "", txns[2].txid)
+// 	require.Equal(t, expectedExtra, txns[2].extra)
+// 	require.NotContains(t, txns[2].txn, `"itx"`, "The inner transactions should be pruned.")
+
+// 	// Inner xfer
+// 	require.Equal(t, "", txns[3].txid)
+// 	require.Equal(t, expectedExtra, txns[3].extra)
+// 	require.NotContains(t, txns[3].txn, `"itx"`, "The inner transactions should be pruned.")
+
+// 	// Verify correct App and Asset IDs
+// 	require.Equal(t, 1, txns[0].asset, "intra == 0 -> ApplicationID = 1")
+// 	require.Equal(t, 789, txns[4].asset, "intra == 4 -> ApplicationID = 789")
+// 	require.Equal(t, 6, txns[5].asset, "intra == 5 -> AssetID = 6")
+
+// 	// Verify txn participation
+// 	txnPart, err := txnParticipationQuery(db, `SELECT * FROM txn_participation ORDER BY round, intra, addr`)
+// 	require.NoError(t, err)
+
+// 	expectedParticipation := []txnParticipationRow{
+// 		// Top-level appl transaction + inner transactions
+// 		{
+// 			addr:  appAddr,
+// 			round: 1,
+// 			intra: 0,
+// 		},
+// 		{
+// 			addr:  sdk.Address(test.AccountA),
+// 			round: 1,
+// 			intra: 0,
+// 		},
+// 		{
+// 			addr:  sdk.Address(test.AccountB),
+// 			round: 1,
+// 			intra: 0,
+// 		},
+// 		{
+// 			addr:  sdk.Address(test.AccountC),
+// 			round: 1,
+// 			intra: 0,
+// 		},
+// 		// Inner pay transaction 1
+// 		{
+// 			addr:  appAddr,
+// 			round: 1,
+// 			intra: 1,
+// 		},
+// 		{
+// 			addr:  sdk.Address(test.AccountB),
+// 			round: 1,
+// 			intra: 1,
+// 		},
+// 		// Inner pay transaction 2
+// 		{
+// 			addr:  appAddr,
+// 			round: 1,
+// 			intra: 2,
+// 		},
+// 		// Inner xfer transaction
+// 		{
+// 			addr:  appAddr,
+// 			round: 1,
+// 			intra: 3,
+// 		},
+// 		{
+// 			addr:  sdk.Address(test.AccountC),
+// 			round: 1,
+// 			intra: 3,
+// 		},
+// 		// Inner appl transaction
+// 		{
+// 			addr:  appAddr,
+// 			round: 1,
+// 			intra: 4,
+// 		},
+// 		// acfg after appl
+// 		{
+// 			addr:  sdk.Address(test.AccountD),
+// 			round: 1,
+// 			intra: 5,
+// 		},
+// 	}
+
+// 	require.Len(t, txnPart, len(expectedParticipation))
+// 	for i := 0; i < len(txnPart); i++ {
+// 		require.Equal(t, expectedParticipation[i], txnPart[i])
+// 	}
+// }
 
 func TestWriterAddBlock0(t *testing.T) {
 	db, _, shutdownFunc := pgtest.SetupPostgresWithSchema(t)
@@ -1854,3 +1852,151 @@ func TestWriterAppBoxTableInsertMutateDelete(t *testing.T) {
 
 	validateTotals()
 }
+
+func TestCutBatches(t *testing.T) {
+	singleSTWAD := sdk.SignedTxnWithAD{
+		ApplyData: sdk.ApplyData{
+			EvalDelta: sdk.EvalDelta{
+				InnerTxns: []sdk.SignedTxnWithAD{{}},
+			},
+		},
+	}
+	threeGenSTWAD := sdk.SignedTxnWithAD{
+		ApplyData: sdk.ApplyData{
+			EvalDelta: sdk.EvalDelta{
+				InnerTxns: []sdk.SignedTxnWithAD{singleSTWAD},
+			},
+		},
+	}
+	fourGenSTWAD := sdk.SignedTxnWithAD{
+		ApplyData: sdk.ApplyData{
+			EvalDelta: sdk.EvalDelta{
+				InnerTxns: []sdk.SignedTxnWithAD{threeGenSTWAD},
+			},
+		},
+	}
+
+	singleParent := sdk.SignedTxnInBlock{SignedTxnWithAD: singleSTWAD}
+	threeGen := sdk.SignedTxnInBlock{SignedTxnWithAD: threeGenSTWAD}
+	fourGen := sdk.SignedTxnInBlock{SignedTxnWithAD: fourGenSTWAD}
+
+	testCases := []struct {
+		name     string
+		payset   []sdk.SignedTxnInBlock
+		batchMinSize uint
+		expected []writer.IndexAndIntra
+	}{
+		{
+			name: "empty payset",
+			payset: []sdk.SignedTxnInBlock{},
+			batchMinSize: 3,
+			expected: []writer.IndexAndIntra{},
+		},
+		{
+			name: "5 simple txns batches of 3",
+			payset: []sdk.SignedTxnInBlock{
+				{},
+				{},
+				{},
+				{},
+				{},
+			},
+			batchMinSize: 3,
+			expected: []writer.IndexAndIntra{
+				{Index: 0, Intra: 0},
+				{Index: 3, Intra: 3},
+				{Index: 5, Intra: 5},
+			},
+		},
+		{
+			name: "9 - a multiple of 3",
+			payset: []sdk.SignedTxnInBlock{
+				{}, {}, {}, 
+				{}, {}, {}, 
+				{}, {}, {},
+			},
+			batchMinSize: 3,
+			expected: []writer.IndexAndIntra{
+				{Index: 0, Intra: 0},
+				{Index: 3, Intra: 3},
+				{Index: 6, Intra: 6},
+				{Index: 9, Intra: 9},
+			},
+		},
+		{
+			name: "4 single parents batches of 2",
+			payset: []sdk.SignedTxnInBlock{
+				singleParent, singleParent, singleParent, singleParent,
+			},
+			batchMinSize: 2,
+			expected: []writer.IndexAndIntra{
+				{Index: 0, Intra: 0},
+				{Index: 1, Intra: 2},
+				{Index: 2, Intra: 4},
+				{Index: 3, Intra: 6},
+				{Index: 4, Intra: 8},
+			},
+		},
+		{
+			name: "4 single parents batches of 3",
+			payset: []sdk.SignedTxnInBlock{
+				singleParent, singleParent, singleParent, singleParent,
+			},
+			batchMinSize: 3,
+			expected: []writer.IndexAndIntra{
+				{Index: 0, Intra: 0},
+				{Index: 2, Intra: 4},
+				{Index: 4, Intra: 8},
+			},
+		},
+		{
+			name: "5 single parents batches of 3",
+			payset: []sdk.SignedTxnInBlock{
+				singleParent, singleParent, singleParent, singleParent, singleParent,
+			},
+			batchMinSize: 3,
+			expected: []writer.IndexAndIntra{
+				{Index: 0, Intra: 0},
+				{Index: 2, Intra: 4},
+				{Index: 4, Intra: 8},
+				{Index: 5, Intra: 10},
+			},
+		},
+		{
+			name: "4 gens 3 gens 2 gens 1 gen batches of 2",
+			payset: []sdk.SignedTxnInBlock{
+				fourGen, threeGen, singleParent, {},
+			},
+			batchMinSize: 2,
+			expected: []writer.IndexAndIntra{
+				{Index: 0, Intra: 0},
+				{Index: 1, Intra: 4},
+				{Index: 2, Intra: 7},
+				{Index: 3, Intra: 9},
+				{Index: 4, Intra: 10},
+			},
+		},
+		{
+			name: "4 gens 3 gens 2 gens 1 gen batches of 5",
+			payset: []sdk.SignedTxnInBlock{
+				fourGen, threeGen, singleParent, {},
+			},
+			batchMinSize: 5,
+			expected: []writer.IndexAndIntra{
+				{Index: 0, Intra: 0},
+				{Index: 2, Intra: 7},
+				{Index: 4, Intra: 10},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			actual := writer.CutBatches(tc.payset, tc.batchMinSize)
+			assert.Equal(t, tc.expected, actual)
+		})
+	}
+
+}
\ No newline at end of file
diff --git a/idb/postgres/postgres.go b/idb/postgres/postgres.go
index d0918eda7..b9058b7fd 100644
--- a/idb/postgres/postgres.go
+++ b/idb/postgres/postgres.go
@@ -23,7 +23,6 @@ import (
 
 	models "github.com/algorand/indexer/v3/api/generated/v2"
 	"github.com/algorand/indexer/v3/idb"
-	"github.com/algorand/indexer/v3/idb/migration"
 	"github.com/algorand/indexer/v3/idb/postgres/internal/encoding"
 	"github.com/algorand/indexer/v3/idb/postgres/internal/schema"
 	"github.com/algorand/indexer/v3/idb/postgres/internal/types"
@@ -37,21 +36,21 @@ import (
 	sdk "github.com/algorand/go-algorand-sdk/v2/types"
 )
 
-var serializable = pgx.TxOptions{IsoLevel: pgx.Serializable} // be a real ACID database
-var readonlyRepeatableRead = pgx.TxOptions{IsoLevel: pgx.RepeatableRead, AccessMode: pgx.ReadOnly}
-
 // OpenPostgres is available for creating test instances of postgres.IndexerDb
 // Returns an error object and a channel that gets closed when blocking migrations
 // finish running successfully.
 func OpenPostgres(connection string, opts idb.IndexerDbOptions, log *log.Logger) (*IndexerDb, chan struct{}, error) {
+	return openPostgres(connection, opts, nil, log)
+}
 
+func openPostgres(connection string, opts idb.IndexerDbOptions, tuning *TuningParams, log *log.Logger) (*IndexerDb, chan struct{}, error) {
 	postgresConfig, err := pgxpool.ParseConfig(connection)
 	if err != nil {
 		return nil, nil, fmt.Errorf("couldn't parse config: %v", err)
 	}
 
-	if opts.MaxConn != 0 {
-		postgresConfig.MaxConns = int32(opts.MaxConn)
+	if opts.MaxConns != 0 {
+		postgresConfig.MaxConns = opts.MaxConns
 	}
 
 	db, err := pgxpool.ConnectConfig(context.Background(), postgresConfig)
@@ -64,15 +63,20 @@ func OpenPostgres(connection string, opts idb.IndexerDbOptions, log *log.Logger)
 		opts.ReadOnly = true
 	}
 
-	return openPostgres(db, opts, log)
+	if tuning == nil {
+		tp := defaultTuningParams()
+		tuning = &tp
+	}
+
+	return openPostgresWithTuning(db, opts, *tuning, log)
 }
 
-// Allow tests to inject a DB
-func openPostgres(db *pgxpool.Pool, opts idb.IndexerDbOptions, logger *log.Logger) (*IndexerDb, chan struct{}, error) {
+func openPostgresWithTuning(db *pgxpool.Pool, opts idb.IndexerDbOptions, tuning TuningParams, logger *log.Logger) (*IndexerDb, chan struct{}, error) {
 	idb := &IndexerDb{
 		readonly: opts.ReadOnly,
 		log:      logger,
 		db:       db,
+		TuningParams: tuning,
 	}
 
 	if idb.log == nil {
@@ -105,15 +109,6 @@ func openPostgres(db *pgxpool.Pool, opts idb.IndexerDbOptions, logger *log.Logge
 	return idb, ch, nil
 }
 
-// IndexerDb is an idb.IndexerDB implementation
-type IndexerDb struct {
-	readonly bool
-	log      *log.Logger
-
-	db             *pgxpool.Pool
-	migration      *migration.Migration
-	accountingLock sync.Mutex
-}
 
 // Close is part of idb.IndexerDb.
 func (db *IndexerDb) Close() {
@@ -173,6 +168,108 @@ func (db *IndexerDb) init(opts idb.IndexerDbOptions) (chan struct{}, error) {
 	return db.runAvailableMigrations(opts)
 }
 
+// loadTransactionBatchW called by loadTransactions.
+// func loadTransactionBatchW(db *IndexerDb, block *sdk.Block, batchnum, start, size int) error {
+// 	f := func(tx pgx.Tx) error {
+// 		batchStart := time.Now()
+// 		var txns []sdk.SignedTxnInBlock
+// 		end := start + size
+// 		if end > len(block.Payset) {
+// 			txns = block.Payset[start:]
+// 		} else {
+// 			txns = block.Payset[start:end]
+// 		}
+// 		err := writer.AddTransactionsW(block, uint64(start), txns, tx)
+// 		fmt.Printf("AddTransactions batch(%d): %s\n", batchnum, time.Since(batchStart))
+// 		return err
+// 	}
+// 	return db.txWithRetry(experimentalCommitLevel, f)
+// }
+
+// loadTransactionsW writes txn data to the DB.
+// func loadTransactionsW(db *IndexerDb, batchSize int, block *sdk.Block) []error {
+// 	var errArr []error
+// 	var txnsWg sync.WaitGroup
+// 	batchnum := 0
+// 	for i := 0; i < len(block.Payset); i += batchSize {
+// 		start := i
+// 		num := batchnum
+// 		txnsWg.Add(1)
+// 		go func() {
+// 			defer txnsWg.Done()
+// 			errArr = append(errArr, loadTransactionBatchW(db, block, num, start, batchSize))
+// 		}()
+// 		batchnum++
+// 	}
+// 	txnsWg.Wait()
+
+// 	return nil
+// }
+
+// loadTransactionBatch called by loadTransactions.
+func loadTransactionBatch(db *IndexerDb, block *sdk.Block, batchnum int, left, right writer.IndexAndIntra) error {
+	f := func(tx pgx.Tx) error {
+		batchStart := time.Now()
+		var txns []sdk.SignedTxnInBlock
+
+		if right.Index > len(block.Payset) {
+			txns = block.Payset[left.Index:]
+		} else {
+			txns = block.Payset[left.Index:right.Index]
+		}
+		err := writer.AddTransactions(tx, block, txns, left)
+		db.log.Debugf("AddTransactions batch(%d:%d): %d", block.Round, batchnum, time.Since(batchStart).Milliseconds())
+		return err
+	}
+	// return db.txWithRetry(experimentalCommitLevel, f)
+	return db.txWithRetry(db.PgxOpts, f)
+}
+
+// loadTransactions writes txn data to the DB.
+func loadTransactions(db *IndexerDb, batchSize uint, block *sdk.Block) []error {
+	var errArr []error
+	var txnsWg sync.WaitGroup
+
+	if len(block.Payset) == 0 {
+		return nil
+	}
+
+	batches := writer.CutBatches(block.Payset, batchSize)
+	if len(batches) < 2 {
+		return []error{
+			fmt.Errorf("loadTransactions: this should never happen! batch cuts of lengvth %d but len(block.Payset) = %d", len(batches), len(block.Payset)),
+		}
+	}
+
+	left := batches[0]
+	for batchnum, right := range batches[1:] {
+		txnsWg.Add(1)
+		go func(batchnum int, left, right writer.IndexAndIntra) {
+			defer txnsWg.Done()
+			errArr = append(errArr, loadTransactionBatch(db, block, batchnum, left, right))
+		}(batchnum, left, right)
+		left = right
+	}
+	txnsWg.Wait()
+
+	return nil
+}
+
+func loadTransactionParticipation(db *IndexerDb, block *sdk.Block) error {
+	st := time.Now()
+	f := func(tx pgx.Tx) error {
+		err := writer.AddTransactionParticipation(uint64(block.Round), block.Payset, tx)
+		db.log.Infof("Round %d AddTransactionParticipation: %d", block.Round, time.Since(st).Milliseconds())
+		//tx.Rollback(context.Background())
+		st = time.Now()
+		return err
+	}
+	// err := db.txWithRetry(experimentalCommitLevel, f)
+	err := db.txWithRetry(db.PgxOpts, f)
+	db.log.Infof("Round %d AddTransactionParticipation(commit): %d", block.Round, time.Since(st).Milliseconds())
+	return err
+}
+
 // AddBlock is part of idb.IndexerDb.
 func (db *IndexerDb) AddBlock(vb *itypes.ValidatedBlock) error {
 	protoVersion := protocol.ConsensusVersion(vb.Block.CurrentProtocol)
@@ -188,6 +285,7 @@ func (db *IndexerDb) AddBlock(vb *itypes.ValidatedBlock) error {
 	db.accountingLock.Lock()
 	defer db.accountingLock.Unlock()
 
+	commitStart := time.Now()
 	f := func(tx pgx.Tx) error {
 		// Check and increment next round counter.
 		importstate, err := db.getImportState(context.Background(), tx)
@@ -222,24 +320,51 @@ func (db *IndexerDb) AddBlock(vb *itypes.ValidatedBlock) error {
 		var wg sync.WaitGroup
 		defer wg.Wait()
 
-		var err0 error
+		// var err0 error
+		var errs0 []error
+		// fmt.Printf("------------------\n")
+		// fmt.Printf("Round: %d\n", vb.Block.Round)
+		// size := 2000
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			f := func(tx pgx.Tx) error {
-				err := writer.AddTransactions(&block, block.Payset, tx)
-				if err != nil {
-					return err
-				}
-				return writer.AddTransactionParticipation(&block, tx)
-			}
-			err0 = db.txWithRetry(serializable, f)
+			// if useExperimentalTxnInsertion && !useExperimentalWithIntraBugfix {
+			// 	// st := time.Now()
+			// 	// errs0 = loadTransactionsW(db, size, &block)
+			// 	// db.log.Infof("Round %d AddTransactions(total): %d", vb.Block.Round, time.Since(st).Microseconds())
+			// } else 
+			// if useExperimentalWithIntraBugfix {
+				st := time.Now()
+				errs0 = loadTransactions(db, uint(db.BatchSize), &block)
+				db.log.Infof("Round %d AddTransactions(total): %d", vb.Block.Round, time.Since(st).Milliseconds())
+			// } else {
+			// 	f := func(tx pgx.Tx) error {
+			// 		err := writer.AddTransactionsOLD(&block, block.Payset, tx)
+			// 		if err != nil {
+			// 			return err
+			// 		}
+			// 		return writer.AddTransactionParticipationOLD(&block, tx)
+			// 	}
+			// 	err0 = db.txWithRetry(serializable, f)
+			// }
 		}()
 
+		var err1 error
+		// if useExperimentalTxnInsertion || useExperimentalWithIntraBugfix {
+		// if useExperimentalWithIntraBugfix {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				err1 = loadTransactionParticipation(db, &block)
+			}()
+		// }
+
+		blockStart := time.Now()
 		err = w.AddBlock(&block, vb.Delta)
 		if err != nil {
 			return fmt.Errorf("AddBlock() err: %w", err)
 		}
+		db.log.Infof("Round %d AddBlock: %d", round, time.Since(blockStart).Milliseconds())
 
 		// Wait for goroutines to finish and check for errors. If there is an error, we
 		// return our own error so that the main transaction does not commit. Hence,
@@ -250,10 +375,29 @@ func (db *IndexerDb) AddBlock(vb *itypes.ValidatedBlock) error {
 			var pgerr *pgconn.PgError
 			return errors.As(err, &pgerr) && (pgerr.Code == pgerrcode.UniqueViolation)
 		}
-		if (err0 != nil) && !isUniqueViolationFunc(err0) {
-			return fmt.Errorf("AddBlock() err0: %w", err0)
+
+		// if useExperimentalTxnInsertion || useExperimentalWithIntraBugfix {
+		// if useExperimentalWithIntraBugfix {
+			for _, errItem := range errs0 {
+				if (errItem != nil) && !isUniqueViolationFunc(errItem) {
+					return fmt.Errorf("AddBlock() errItem: %w", errItem)
+				} else if errItem != nil {
+					db.log.Warnf("AddBlock() ignoring violation error, this usually means the data has already been written: %s", err)
+				}
+			}
+		// } else {
+		// 	if (err0 != nil) && !isUniqueViolationFunc(err0) {
+		// 		return fmt.Errorf("AddBlock() err0: %w", err0)
+		// 	}
+		// }
+
+		if (err1 != nil) && !isUniqueViolationFunc(err1) {
+			return fmt.Errorf("AddBlock() err1: %w", err1)
+		} else if err1 != nil {
+			db.log.Warnf("AddBlock() ignoring violation error, this usually means the data has already been written: %s", err)
 		}
 
+		commitStart = time.Now()
 		return nil
 	}
 	err := db.txWithRetry(serializable, f)
@@ -261,6 +405,7 @@ func (db *IndexerDb) AddBlock(vb *itypes.ValidatedBlock) error {
 		return fmt.Errorf("AddBlock() err: %w", err)
 	}
 
+	db.log.Infof("Round %d AddBlock(commit): %d", round, time.Since(commitStart).Milliseconds())
 	return nil
 }
 
diff --git a/idb/postgres/postgres_bench_test.go b/idb/postgres/postgres_bench_test.go
new file mode 100644
index 000000000..386f6857d
--- /dev/null
+++ b/idb/postgres/postgres_bench_test.go
@@ -0,0 +1,202 @@
+package postgres
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"os"
+	"testing"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+
+	sdk "github.com/algorand/go-algorand-sdk/v2/types"
+	"github.com/jackc/pgx/v4"
+
+	"github.com/algorand/indexer/v3/types"
+	"github.com/algorand/indexer/v3/util/test"
+	"github.com/stretchr/testify/require"
+)
+
+const benchmarkDuration = 45 * time.Second
+
+// gnomock's defaultStopTimeoutSec is 1 seconds after which
+// the container is forcefully killed. So wait a little longer
+// to make sure the container is cleaned up.
+const waitForContainerCleanup = 1500 * time.Millisecond
+
+var benchmarkLogger *log.Logger
+
+func init() {
+	benchmarkLogger = log.New()
+	benchmarkLogger.SetFormatter(&log.JSONFormatter{})
+	benchmarkLogger.SetOutput(os.Stdout)
+	benchmarkLogger.SetLevel(log.ErrorLevel)
+}
+
+type benchmarkCase struct {
+	name           string
+	pgVersion      string
+	maxConns       int32
+	isolationLevel pgx.TxIsoLevel
+	batchSize      uint32
+	scenario       string
+	blockSize      uint
+}
+
+const blockPathFormat = "test_resources/file_exported_blocks/5_%s.%d.msgp.gz"
+
+// pg version 16 turned out to be ~ 70% __FASTER__ for payments.
+// However, it also crashes unpredictably!!!
+// var pgVersions = []string{"14", "15", "16beta3"}
+
+var pgVersions = []string{"15"}
+var maxConnss = []int32{4, 8, 12, 16, 20}
+var isoLevels = []pgx.TxIsoLevel{pgx.Serializable} //pgx.ReadUncommitted} //, pgx.ReadCommitted} // pgx.RepeatableRead, pgx.ReadCommitted} //, pgx.ReadUncommitted}
+var batchSizes = []uint32{1_000, 2_000, 4_000}                      //{16_000, 12_000, 8_000, 4_000, 2000, 1000} //25_000 10_000, 2_500, 1_000, 250, 100}
+var scenarios = []string{"organic", "payment", "stress"}
+var blockSizes = []uint{25_000} //, 50_000}
+
+var benchCases []benchmarkCase
+var r *rand.Rand
+
+func init() {
+	for _, pgVersion := range pgVersions {
+		for _, maxConns := range maxConnss {
+			for _, isoLevel := range isoLevels {
+				for _, batchSize := range batchSizes {
+					for _, scenario := range scenarios {
+						for _, blockSize := range blockSizes {
+							name := fmt.Sprintf(
+								"%s_%d_%s_%d-%s_%d",
+								pgVersion, maxConns, shortName(isoLevel), batchSize,
+								scenario, blockSize,
+							)
+							benchCases = append(benchCases, benchmarkCase{
+								name:           name,
+								pgVersion:      pgVersion,
+								maxConns:       maxConns,
+								isolationLevel: isoLevel,
+								batchSize:      batchSize,
+								scenario:       scenario,
+								blockSize:      blockSize,
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+
+	r = rand.New(rand.NewSource(time.Now().UnixNano()))
+}
+
+type exportStats struct {
+	trials        uint
+	setupDuration time.Duration
+	simDuration   time.Duration
+	fullRounds    uint
+	bytes         uint64
+	approxTxns    uint
+}
+
+func add(x, y exportStats) exportStats {
+	return exportStats{
+		trials:        x.trials + y.trials,
+		setupDuration: x.setupDuration + y.setupDuration,
+		simDuration:   x.simDuration + y.simDuration,
+		fullRounds:    x.fullRounds + y.fullRounds,
+		bytes:         x.bytes + y.bytes,
+		approxTxns:    x.approxTxns + y.approxTxns,
+	}
+}
+
+func reportMetrics(b *testing.B, stats exportStats) {
+	b.ReportMetric(float64(stats.setupDuration.Seconds()), "setupTime")
+	b.ReportMetric(float64(stats.simDuration.Seconds()), "simTime")
+	b.ReportMetric(float64(stats.bytes), "bytes")
+	b.ReportMetric(float64(stats.bytes)/stats.simDuration.Seconds(), "bytes/sec")
+	b.ReportMetric(float64(stats.approxTxns), "approxTxns")
+	b.ReportMetric(float64(stats.approxTxns)/stats.simDuration.Seconds(), "approxTxns/sec")
+	b.ReportMetric(float64(stats.fullRounds), "rounds")
+	b.ReportMetric(float64(stats.fullRounds)/stats.simDuration.Seconds(), "rounds/sec")
+}
+
+func simulateExport(b *testing.B, vb *types.ValidatedBlock, size uint64, db *IndexerDb, ccf context.CancelCauseFunc, stats *exportStats) {
+	start := time.Now()
+
+	round := sdk.Round(1)
+	for ; time.Since(start) < benchmarkDuration; round++ {
+		vb.Block.Round = round
+		err := db.AddBlock(vb)
+		require.NoError(b, err)
+	}
+	stats.fullRounds = uint(round)
+	ccf(fmt.Errorf("simulation complete after %d rounds. runtime=%s > behcnmark duration=%s", round, time.Since(start), benchmarkDuration))
+}
+
+func BenchmarkExport(b *testing.B) {
+	r.Shuffle(len(benchCases), func(i, j int) {
+		benchCases[i], benchCases[j] = benchCases[j], benchCases[i]
+	})
+	for _, bc := range benchCases {
+		b.Run(bc.name, func(b *testing.B) {
+			stats := exportStats{}
+			blockFile := fmt.Sprintf(blockPathFormat, bc.scenario, bc.blockSize)
+			vb, size, err := test.ReadConduitBlockFromFile(blockFile)
+			require.NoError(b, err, bc.name)
+
+			for i := 0; i < b.N; i++ {
+				setupStart := time.Now()
+				tuning := TuningParams{
+					PgxOpts:   pgx.TxOptions{IsoLevel: bc.isolationLevel},
+					BatchSize: bc.batchSize,
+				}
+				db, shutdownFunc := setupIdbWithPgVersion(b, test.MakeGenesis(), bc.pgVersion, &bc.maxConns, &tuning, benchmarkLogger)
+				ctx, ccf := context.WithCancelCause(context.Background())
+				trialStats := exportStats{
+					trials:        1,
+					setupDuration: time.Since(setupStart),
+				}
+
+				b.StartTimer()
+				go simulateExport(b, &vb, size, db, ccf, &trialStats)
+
+				<-ctx.Done()
+				b.StopTimer()
+				b.Logf("trial complete because: %v\n", context.Cause(ctx))
+
+				shutdownFunc()
+
+				trialStats.bytes = size * uint64(trialStats.fullRounds)
+				trialStats.approxTxns = bc.blockSize * trialStats.fullRounds
+				trialStats.simDuration = b.Elapsed()
+
+				reportMetrics(b, trialStats)
+				stats = add(stats, trialStats)
+
+				time.Sleep(waitForContainerCleanup)
+			}
+			b.Logf("benchmark: %#v, stats: %#v", bc, stats)
+
+		})
+	}
+}
+
+// BenchmarkRead is a sanity check that only benchmarks the block reading functionality
+func BenchmarkRead(b *testing.B) {
+	for _, bc := range benchCases {
+		b.Run(bc.name, func(b *testing.B) {
+			blockFile := fmt.Sprintf(blockPathFormat, bc.scenario, bc.blockSize)
+			vb, size, err := test.ReadConduitBlockFromFile(blockFile)
+			require.NoError(b, err, bc.name)
+			require.Equal(b, sdk.Round(5), vb.Block.Round, bc.name)
+
+			secs := b.Elapsed().Seconds()
+			bps := float64(size) / secs
+			b.ReportMetric(bps, "bytes/sec")
+			b.ReportMetric(float64(size), "bytes")
+		})
+	}
+
+}
diff --git a/idb/postgres/postgres_integration_common_test.go b/idb/postgres/postgres_integration_common_test.go
index 9392cd9ef..994826281 100644
--- a/idb/postgres/postgres_integration_common_test.go
+++ b/idb/postgres/postgres_integration_common_test.go
@@ -7,6 +7,7 @@ import (
 	sdk "github.com/algorand/go-algorand-sdk/v2/types"
 	"github.com/algorand/indexer/v3/types"
 	"github.com/jackc/pgx/v4/pgxpool"
+	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/require"
 
 	"github.com/algorand/indexer/v3/idb"
@@ -14,8 +15,12 @@ import (
 	"github.com/algorand/indexer/v3/util/test"
 )
 
-func setupIdbWithConnectionString(t *testing.T, connStr string, genesis sdk.Genesis) *IndexerDb {
-	idb, _, err := OpenPostgres(connStr, idb.IndexerDbOptions{}, nil)
+func setupIdbWithConnectionString(t testing.TB, connStr string, genesis sdk.Genesis, maxConns *int32, tuning *TuningParams, logger *log.Logger) *IndexerDb {
+	opts := idb.IndexerDbOptions{}
+	if maxConns != nil {
+		opts.MaxConns = *maxConns
+	}
+	idb, _, err :=  openPostgres(connStr, opts, tuning, logger) // OpenPostgres(connStr, opts, logger)
 	require.NoError(t, err)
 
 	err = idb.LoadGenesis(genesis)
@@ -25,10 +30,17 @@ func setupIdbWithConnectionString(t *testing.T, connStr string, genesis sdk.Gene
 }
 
 func setupIdb(t *testing.T, genesis sdk.Genesis) (*IndexerDb, func()) {
-
 	_, connStr, shutdownFunc := pgtest.SetupPostgres(t)
+	return setupIdbImpl(t, connStr, genesis, shutdownFunc, nil, nil, nil)
+}
 
-	db := setupIdbWithConnectionString(t, connStr, genesis)
+func setupIdbWithPgVersion(t testing.TB, genesis sdk.Genesis, pgImage string, maxConns *int32, tuning *TuningParams, pgLogger *log.Logger) (*IndexerDb, func()) {
+	_, connStr, shutdownFunc := pgtest.SetupGnomockPgWithVersion(t, pgImage)
+	return setupIdbImpl(t, connStr, genesis, shutdownFunc, maxConns, tuning, pgLogger)
+}
+
+func setupIdbImpl(t testing.TB, connStr string, genesis sdk.Genesis, shutdownFunc func(), maxConns *int32, tuning *TuningParams, logger *log.Logger) (*IndexerDb, func()) {
+	db := setupIdbWithConnectionString(t, connStr, genesis, maxConns, tuning, logger)
 	newShutdownFunc := func() {
 		db.Close()
 		shutdownFunc()
@@ -37,7 +49,8 @@ func setupIdb(t *testing.T, genesis sdk.Genesis) (*IndexerDb, func()) {
 		Block: test.MakeGenesisBlock(),
 		Delta: sdk.LedgerStateDelta{},
 	}
-	db.AddBlock(&vb)
+	err := db.AddBlock(&vb)
+	require.NoError(t, err)
 
 	return db, newShutdownFunc
 }
diff --git a/idb/postgres/postgres_integration_test.go b/idb/postgres/postgres_integration_test.go
index f1854d020..f632a3434 100644
--- a/idb/postgres/postgres_integration_test.go
+++ b/idb/postgres/postgres_integration_test.go
@@ -108,7 +108,7 @@ func TestMaxConnection(t *testing.T) {
 	defer shutdownFunc()
 
 	// Open Postgres with a maximum of 2 connections locally
-	pdb, _, err := OpenPostgres(connStr, idb.IndexerDbOptions{MaxConn: 2}, nil)
+	pdb, _, err := OpenPostgres(connStr, idb.IndexerDbOptions{MaxConns: 2}, nil)
 	assert.NoError(t, err)
 	defer pdb.Close()
 
@@ -1610,7 +1610,7 @@ func TestSearchForInnerTransactionReturnsRootTransaction(t *testing.T) {
 	pdb, connStr, shutdownFunc := pgtest.SetupPostgres(t)
 	defer shutdownFunc()
 
-	db := setupIdbWithConnectionString(t, connStr, test.MakeGenesis())
+	db := setupIdbWithConnectionString(t, connStr, test.MakeGenesis(), nil, nil, nil)
 	defer db.Close()
 
 	// appCall := test.MakeAppCallWithInnerTxn(test.AccountA, appAddr, test.AccountB, appAddr, test.AccountC)
@@ -1980,7 +1980,7 @@ func TestGenesisHashCheckAtDBSetup(t *testing.T) {
 	defer shutdownFunc()
 
 	genesis := test.MakeGenesis()
-	db := setupIdbWithConnectionString(t, connStr, genesis)
+	db := setupIdbWithConnectionString(t, connStr, genesis, nil, nil, nil)
 	defer db.Close()
 	genesisHash := genesis.Hash()
 	network, err := db.getMetastate(context.Background(), nil, schema.NetworkMetaStateKey)
diff --git a/mule.yaml b/mule.yaml
deleted file mode 100644
index 497eee80a..000000000
--- a/mule.yaml
+++ /dev/null
@@ -1,69 +0,0 @@
-agents:
-  - name: ubuntu
-    dockerFilePath: docker/Dockerfile.mule
-    image: algorand/indexer-ci-linux
-    version: README.md
-    env:
-      - AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID
-      - AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY
-    volumes:
-      - $XDG_RUNTIME_DIR/gnupg/S.gpg-agent:/root/.gnupg/S.gpg-agent
-      - $HOME/.gnupg/pubring.kbx:/root/.gnupg/pubring.kbx
-    workDir: $HOME/projects/indexer
-
-tasks:
-  - task: docker.Make
-    name: package
-    agent: ubuntu
-    target: package
-
-  - task: s3.BucketCopy
-    name: stage
-    src: $HOME/projects/indexer/tmp/node_pkgs/linux/amd64/$VERSION
-    dest: s3://$STAGING/indexer/$VERSION
-
-  - task: docker.Make
-    name: sign
-    agent: ubuntu
-    target: sign
-
-  - task: docker.Make
-    name: deploy
-    agent: ubuntu
-    target: deploy
-
-  - task: docker.Make
-    name: test
-    agent: ubuntu
-    target: test
-
-  - task: docker.Make
-    name: test-package
-    agent: ubuntu
-    target: test-package
-
-jobs:
-  deploy:
-    tasks:
-      - docker.Make.deploy
-
-  package:
-    tasks:
-      - docker.Make.package
-
-  sign:
-    tasks:
-      - docker.Make.sign
-
-  stage:
-    tasks:
-      - s3.BucketCopy.stage
-
-  test:
-    tasks:
-      - docker.Make.test
-
-  test-package:
-    tasks:
-      - docker.Make.test-package
-
diff --git a/types/conduit.go b/types/conduit.go
new file mode 100644
index 000000000..5fa6847db
--- /dev/null
+++ b/types/conduit.go
@@ -0,0 +1,33 @@
+package types
+
+import (
+	sdk "github.com/algorand/go-algorand-sdk/v2/types"
+)
+
+// orignal source: https://github.com/algorand/conduit/data/block_export_data.go
+
+// BlockData is provided to the Exporter on each round.
+type BlockData struct {
+
+	// BlockHeader is the immutable header from the block
+	BlockHeader sdk.BlockHeader `json:"block,omitempty"`
+
+	// Payset is the set of data the block is carrying--can be modified as it is processed
+	Payset []sdk.SignedTxnInBlock `json:"payset,omitempty"`
+
+	// Delta contains a list of account changes resulting from the block. Processor plugins may have modify this data.
+	Delta *sdk.LedgerStateDelta `json:"delta,omitempty"`
+
+	// Certificate contains voting data that certifies the block. The certificate is non deterministic, a node stops collecting votes once the voting threshold is reached.
+	Certificate *map[string]interface{} `json:"cert,omitempty"`
+}
+
+// Round returns the round to which the BlockData corresponds
+func (blkData BlockData) Round() uint64 {
+	return uint64(blkData.BlockHeader.Round)
+}
+
+// Empty returns whether the Block contains Txns. Assumes the Block is never nil
+func (blkData BlockData) Empty() bool {
+	return len(blkData.Payset) == 0
+}
diff --git a/util/test/testutil.go b/util/test/testutil.go
index 0380edb65..df27b6b1e 100644
--- a/util/test/testutil.go
+++ b/util/test/testutil.go
@@ -1,14 +1,17 @@
 package test
 
 import (
+	"compress/gzip"
 	"context"
 	"crypto/sha512"
 	"encoding/binary"
 	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"runtime"
 
+	"github.com/algorand/go-codec/codec"
 	"github.com/algorand/indexer/v3/idb"
 	"github.com/algorand/indexer/v3/types"
 	"github.com/algorand/indexer/v3/util"
@@ -132,6 +135,52 @@ func ReadValidatedBlockFromFile(filename string) (types.ValidatedBlock, error) {
 
 }
 
+// CountingReader wraps an io.Reader to count the number of bytes read.
+type CountingReader struct {
+	r io.Reader
+	n uint64
+}
+
+func (cr *CountingReader) Read(p []byte) (int, error) {
+	n, err := cr.r.Read(p)
+	cr.n += uint64(n)
+	return n, err
+}
+
+// ReadConduitBlockFromFile reads a (validated) conduit block from a file
+// and returns the block casted as a ValidatedBlock along with the number of bytes read (after decompression).
+func ReadConduitBlockFromFile(filename string) (types.ValidatedBlock, uint64, error) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return types.ValidatedBlock{}, 0, fmt.Errorf("ReadConduitBlockFromFile err: %w", err)
+	}
+	defer file.Close()
+
+	isGzip := filename[len(filename)-3:] == ".gz"
+	var reader io.Reader
+	if isGzip {
+		gz, err := gzip.NewReader(file)
+		if err != nil {
+			return types.ValidatedBlock{}, 0, fmt.Errorf("ReadConduitBlockFromFile err: failed to make gzip reader: %w", err)
+		}
+		defer gz.Close()
+		reader = gz
+	} else {
+		reader = file
+	}
+
+	cr := &CountingReader{r: reader}
+	var cb types.BlockData
+	if err := codec.NewDecoder(cr, msgpack.LenientCodecHandle).Decode(&cb); err != nil {
+		return types.ValidatedBlock{}, 0, fmt.Errorf("ReadConduitBlockFromFile err: %w", err)
+	}
+	return types.ValidatedBlock{
+		Block: sdk.Block{BlockHeader: cb.BlockHeader, Payset: cb.Payset},
+		Delta: *cb.Delta,
+	}, cr.n, nil
+}
+
+
 // AppAddress generates Address for the given appID
 func AppAddress(app sdk.AppIndex) sdk.Address {
 	hashid := "appID"