Repository: celestiaorg/celestia-app

Issue:
`./scripts/single-node.sh` is broken
## Context

On `main`

## Problem

```
$ ./scripts/single-node.sh
celestia-app version: 3.2.1-rc1-130-gb54dd2d3b
celestia-app home: /Users/rootulp/.celestia-app
celestia-app genesis file: /Users/rootulp/.celestia-app/config/genesis.json

Do you want to delete existing /Users/rootulp/.celestia-app and start a new local testnet? [y/n]
y
Deleting /Users/rootulp/.celestia-app...
Initializing validator and node config files...
Adding a new key to the keyring...
Adding genesis account...
Error: unknown command "add-genesis-account" for "celestia-appd"
Run 'celestia-appd --help' for usage.
```

Discussion:
@tac0turtle: i can pick this up. feel free to assign me


Solution patch:
diff --git a/Makefile b/Makefile
index 4330b089..70aae98a 100644
--- a/Makefile
+++ b/Makefile
@@ -213,10 +213,10 @@ test-race:
 	@go test -timeout 15m ./... -v -race -skip "TestPrepareProposalConsistency|TestIntegrationTestSuite|TestSquareSizeIntegrationTest|TestStandardSDKIntegrationTestSuite|TestTxsimCommandFlags|TestTxsimCommandEnvVar|TestTxsimDefaultKeypath|TestMintIntegrationTestSuite|TestUpgrade|TestMaliciousTestNode|TestBigBlobSuite|TestQGBIntegrationSuite|TestSignerTestSuite|TestPriorityTestSuite|TestTimeInPrepareProposalContext|TestCLITestSuite|TestLegacyUpgrade|TestSignerTwins|TestConcurrentTxSubmission|TestTxClientTestSuite|Test_testnode|TestEvictions|TestEstimateGasUsed|TestEstimateGasPrice|TestWithEstimatorService"
 .PHONY: test-race
 
-## test-bench: Run unit tests in bench mode.
+## test-bench: Run benchmark unit tests.
 test-bench:
-	@echo "--> Running tests in bench mode"
-	@go test -bench=. ./...
+	@echo "--> Running benchmark tests"
+	@go test -timeout 30m -tags=benchmarks -bench=. ./app/benchmarks/...
 .PHONY: test-bench
 
 ## test-coverage: Generate test coverage.txt
diff --git a/app/benchmarks/README.md b/app/benchmarks/README.md
index 95a610de..affc4b6a 100644
--- a/app/benchmarks/README.md
+++ b/app/benchmarks/README.md
@@ -11,7 +11,7 @@ This package contains benchmarks for the ABCI methods with the following transac
 To run the benchmarks, run the following in the root directory:
 
 ```shell
-go test -tags=bench_abci_methods -bench=<benchmark_name> app/benchmarks/benchmark_*
+go test -tags=benchmarks -bench=<benchmark_name> app/benchmarks/...
 ```
 
 ## Results
diff --git a/go.mod b/go.mod
index 9dd12ffd..e3fd56be 100644
--- a/go.mod
+++ b/go.mod
@@ -31,7 +31,6 @@ require (
 	github.com/cosmos/ibc-apps/middleware/packet-forward-middleware/v8 v8.2.0
 	github.com/cosmos/ibc-go/modules/capability v1.0.1
 	github.com/cosmos/ibc-go/v8 v8.7.0
-	github.com/ethereum/go-ethereum v1.15.8
 	github.com/go-kit/log v0.2.1
 	github.com/golang/protobuf v1.5.4
 	github.com/grpc-ecosystem/grpc-gateway v1.16.0
@@ -132,6 +131,7 @@ require (
 	github.com/emicklei/go-restful/v3 v3.11.0 // indirect
 	github.com/envoyproxy/go-control-plane/envoy v1.32.4 // indirect
 	github.com/envoyproxy/protoc-gen-validate v1.2.1 // indirect
+	github.com/ethereum/go-ethereum v1.15.8 // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/fsnotify/fsnotify v1.8.0 // indirect
diff --git a/pkg/appconsts/global_consts.go b/pkg/appconsts/global_consts.go
index 076581e4..c93a02ed 100644
--- a/pkg/appconsts/global_consts.go
+++ b/pkg/appconsts/global_consts.go
@@ -28,12 +28,6 @@ const (
 )
 
 var (
-	// DataCommitmentBlocksLimit is the maximum number of blocks that a data commitment can span
-	// DataCommitmentBlocksLimit is the limit to the number of blocks we can generate a data commitment for.
-	// Deprecated: this is no longer used as we're moving towards Blobstream X. However, we're leaving it
-	// here for backwards compatibility purpose until it's removed in the next breaking release.
-	DataCommitmentBlocksLimit = 1000
-
 	// NewBaseHashFunc is the base hash function used by NMT. Change accordingly
 	// if another hash.Hash should be used as a base hasher in the NMT.
 	NewBaseHashFunc = sha256.New
diff --git a/pkg/appconsts/prepare_proposal_consts.go b/pkg/appconsts/prepare_proposal_consts.go
index c933aabd..98247684 100644
--- a/pkg/appconsts/prepare_proposal_consts.go
+++ b/pkg/appconsts/prepare_proposal_consts.go
@@ -1,4 +1,4 @@
-//go:build !bench_abci_methods
+//go:build !benchmarks
 
 package appconsts
 
diff --git a/pkg/appconsts/prepare_proposal_consts_bench.go b/pkg/appconsts/prepare_proposal_consts_bench.go
index cc8141f7..a7bc8979 100644
--- a/pkg/appconsts/prepare_proposal_consts_bench.go
+++ b/pkg/appconsts/prepare_proposal_consts_bench.go
@@ -1,8 +1,8 @@
-//go:build bench_abci_methods
+//go:build benchmarks
 
 package appconsts
 
-// Note: these constants are set to these values only when running `bench_abci_methods` benchmarks.
+// Note: these constants are set to these values only when running benchmarks.
 // For the production values, check prepare_proposal_consts.go file.
 
 const (
diff --git a/scripts/build-run-single-node.sh b/scripts/build-run-single-node.sh
index ff7ac24c..e3863c98 100755
--- a/scripts/build-run-single-node.sh
+++ b/scripts/build-run-single-node.sh
@@ -17,13 +17,13 @@ coins="1000000000000000utia"
 ${BIN_PATH} init $CHAINID --chain-id $CHAINID --home ${HOME_DIR}
 ${BIN_PATH} keys add validator --keyring-backend="test" --home ${HOME_DIR}
 # this won't work because the some proto types are declared twice and the logs output to stdout (dependency hell involving iavl)
-${BIN_PATH} add-genesis-account $(${BIN_PATH} keys show validator -a --keyring-backend="test" --home ${HOME_DIR}) $coins --home ${HOME_DIR}
-${BIN_PATH} gentx validator 5000000000utia \
+${BIN_PATH} genesis add-genesis-account $(${BIN_PATH} keys show validator -a --keyring-backend="test" --home ${HOME_DIR}) $coins --home ${HOME_DIR}
+${BIN_PATH} genesis gentx validator 5000000000utia \
 	--keyring-backend="test" \
 	--chain-id $CHAINID \
 	--home ${HOME_DIR}
 
-${BIN_PATH} collect-gentxs --home ${HOME_DIR}
+${BIN_PATH} genesis collect-gentxs --home ${HOME_DIR}
 
 # Set proper defaults and change ports
 # If you encounter: `sed: -I or -i may not be used with stdin` on MacOS you can mitigate by installing gnu-sed
diff --git a/scripts/single-node-upgrades.sh b/scripts/single-node-upgrades.sh
index 32dd577f..a5ef41f2 100755
--- a/scripts/single-node-upgrades.sh
+++ b/scripts/single-node-upgrades.sh
@@ -44,13 +44,13 @@ createGenesis() {
       > /dev/null 2>&1 # Hide output to reduce terminal noise
 
     echo "Adding genesis account..."
-    celestia-appd add-genesis-account \
+    celestia-appd genesis add-genesis-account \
       "$(celestia-appd keys show ${KEY_NAME} -a --keyring-backend=${KEYRING_BACKEND} --home "${APP_HOME}")" \
       "1000000000000000utia" \
       --home "${APP_HOME}"
 
     echo "Creating a genesis tx..."
-    celestia-appd gentx ${KEY_NAME} 5000000000utia \
+    celestia-appd genesis gentx ${KEY_NAME} 5000000000utia \
       --fees ${FEES} \
       --keyring-backend=${KEYRING_BACKEND} \
       --chain-id ${CHAIN_ID} \
@@ -58,7 +58,7 @@ createGenesis() {
       > /dev/null 2>&1 # Hide output to reduce terminal noise
 
     echo "Collecting genesis txs..."
-    celestia-appd collect-gentxs \
+    celestia-appd genesis collect-gentxs \
       --home "${APP_HOME}" \
         > /dev/null 2>&1 # Hide output to reduce terminal noise
 
diff --git a/scripts/single-node.sh b/scripts/single-node.sh
index c2159fe7..b1d73c3e 100755
--- a/scripts/single-node.sh
+++ b/scripts/single-node.sh
@@ -42,13 +42,13 @@ createGenesis() {
       > /dev/null 2>&1 # Hide output to reduce terminal noise
 
     echo "Adding genesis account..."
-    celestia-appd add-genesis-account \
+    celestia-appd genesis add-genesis-account \
       "$(celestia-appd keys show ${KEY_NAME} -a --keyring-backend=${KEYRING_BACKEND} --home "${APP_HOME}")" \
       "1000000000000000utia" \
       --home "${APP_HOME}"
 
     echo "Creating a genesis tx..."
-    celestia-appd gentx ${KEY_NAME} 5000000000utia \
+    celestia-appd genesis gentx ${KEY_NAME} 5000000000utia \
       --fees ${FEES} \
       --keyring-backend=${KEYRING_BACKEND} \
       --chain-id ${CHAIN_ID} \
@@ -56,7 +56,7 @@ createGenesis() {
       > /dev/null 2>&1 # Hide output to reduce terminal noise
 
     echo "Collecting genesis txs..."
-    celestia-appd collect-gentxs \
+    celestia-appd genesis collect-gentxs \
       --home "${APP_HOME}" \
         > /dev/null 2>&1 # Hide output to reduce terminal noise
 



Test patch:
diff --git a/app/benchmarks/benchmark_ibc_update_client_test.go b/app/benchmarks/benchmark_ibc_update_client_test.go
index c2d7717b..fc132727 100644
--- a/app/benchmarks/benchmark_ibc_update_client_test.go
+++ b/app/benchmarks/benchmark_ibc_update_client_test.go
@@ -1,4 +1,4 @@
-//go:build bench_abci_methods
+//go:build benchmarks
 
 package benchmarks_test
 
@@ -8,29 +8,29 @@ import (
 	"testing"
 	"time"
 
-	"github.com/celestiaorg/celestia-app/v4/app"
-	"github.com/celestiaorg/celestia-app/v4/app/encoding"
-	"github.com/celestiaorg/celestia-app/v4/pkg/appconsts"
-	"github.com/celestiaorg/celestia-app/v4/pkg/user"
-	testutil "github.com/celestiaorg/celestia-app/v4/test/util"
-	"github.com/celestiaorg/celestia-app/v4/test/util/testfactory"
 	dbm "github.com/cometbft/cometbft-db"
 	"github.com/cometbft/cometbft/abci/types"
 	"github.com/cometbft/cometbft/crypto"
+	"github.com/cometbft/cometbft/crypto/ed25519"
 	"github.com/cometbft/cometbft/crypto/tmhash"
-	crypto2 "github.com/cometbft/cometbft/proto/tendermint/crypto"
-	tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
-	tmprotoversion "github.com/cometbft/cometbft/proto/tendermint/version"
+	cmtprotocrypto "github.com/cometbft/cometbft/proto/tendermint/crypto"
+	cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
+	cmtprotoversion "github.com/cometbft/cometbft/proto/tendermint/version"
+	sm "github.com/cometbft/cometbft/state"
+	cmttypes "github.com/cometbft/cometbft/types"
 	"github.com/cometbft/cometbft/version"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	types3 "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
-	types2 "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types"
-	types4 "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint"
+	clienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
+	commitmenttypes "github.com/cosmos/ibc-go/v8/modules/core/23-commitment/types"
+	ibctm "github.com/cosmos/ibc-go/v8/modules/light-clients/07-tendermint"
 	"github.com/stretchr/testify/require"
 
-	"github.com/cometbft/cometbft/crypto/ed25519"
-	sm "github.com/cometbft/cometbft/state"
-	types0 "github.com/cometbft/cometbft/types"
+	"github.com/celestiaorg/celestia-app/v4/app"
+	"github.com/celestiaorg/celestia-app/v4/app/encoding"
+	"github.com/celestiaorg/celestia-app/v4/pkg/appconsts"
+	"github.com/celestiaorg/celestia-app/v4/pkg/user"
+	testutil "github.com/celestiaorg/celestia-app/v4/test/util"
+	"github.com/celestiaorg/celestia-app/v4/test/util/testfactory"
 )
 
 func BenchmarkIBC_CheckTx_Update_Client_Multi(b *testing.B) {
@@ -64,13 +64,13 @@ func benchmarkIBCCheckTxUpdateClient(b *testing.B, numberOfValidators int) {
 	testApp, rawTxs := generateIBCUpdateClientTransaction(b, numberOfValidators, 1, 1)
 	testApp.Commit()
 
-	checkTxRequest := types.RequestCheckTx{
+	checkTxReq := types.RequestCheckTx{
 		Type: types.CheckTxType_New,
 		Tx:   rawTxs[0],
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.CheckTx(&checkTxRequest)
+	resp, err := testApp.CheckTx(&checkTxReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.Equal(b, uint32(0), resp.Code)
@@ -81,7 +81,7 @@ func benchmarkIBCCheckTxUpdateClient(b *testing.B, numberOfValidators int) {
 	b.ReportMetric(float64(2*numberOfValidators/3), "number_of_verified_signatures")
 }
 
-func BenchmarkIBC_DeliverTx_Update_Client_Multi(b *testing.B) {
+func BenchmarkIBC_FinalizeBlock_Update_Client_Multi(b *testing.B) {
 	testCases := []struct {
 		numberOfValidators int
 	}{
@@ -103,20 +103,23 @@ func BenchmarkIBC_DeliverTx_Update_Client_Multi(b *testing.B) {
 	}
 	for _, testCase := range testCases {
 		b.Run(fmt.Sprintf("number of validators: %d", testCase.numberOfValidators), func(b *testing.B) {
-			benchmarkIBCDeliverTxUpdateClient(b, testCase.numberOfValidators)
+			benchmarkIBCFinalizeBlockUpdateClient(b, testCase.numberOfValidators)
 		})
 	}
 }
 
-func benchmarkIBCDeliverTxUpdateClient(b *testing.B, numberOfValidators int) {
+func benchmarkIBCFinalizeBlockUpdateClient(b *testing.B, numberOfValidators int) {
 	testApp, rawTxs := generateIBCUpdateClientTransaction(b, numberOfValidators, 1, 1)
 
-	deliverTxRequest := types.RequestFinalizeBlock{
-		Txs: rawTxs,
+	finalizeBlockReq := types.RequestFinalizeBlock{
+		Time:   testutil.GenesisTime.Add(blockTime),
+		Height: testApp.LastBlockHeight() + 1,
+		Hash:   testApp.LastCommitID().Hash,
+		Txs:    rawTxs,
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.FinalizeBlock(&deliverTxRequest)
+	resp, err := testApp.FinalizeBlock(&finalizeBlockReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.Equal(b, uint32(0), resp.TxResults[0].Code)
@@ -155,23 +158,23 @@ func BenchmarkIBC_PrepareProposal_Update_Client_Multi(b *testing.B) {
 }
 
 func benchmarkIBCPrepareProposalUpdateClient(b *testing.B, numberOfValidators, count int) {
-	testApp, rawTxs := generateIBCUpdateClientTransaction(b, numberOfValidators, count, 0)
+	testApp, rawTxs := generateIBCUpdateClientTransaction(b, numberOfValidators, count, count)
 
-	prepareProposalRequest := types.RequestPrepareProposal{
+	prepareProposalReq := types.RequestPrepareProposal{
 		Txs:    rawTxs,
-		Height: 10,
+		Height: testApp.LastBlockHeight() + 1,
 	}
 
 	b.ResetTimer()
-	prepareProposalResponse, err := testApp.PrepareProposal(&prepareProposalRequest)
+	prepareProposalResp, err := testApp.PrepareProposal(&prepareProposalReq)
 	require.NoError(b, err)
 	b.StopTimer()
-	require.GreaterOrEqual(b, len(prepareProposalResponse.Txs), 1)
+	require.GreaterOrEqual(b, len(prepareProposalResp.Txs), 1)
 	b.ReportMetric(float64(b.Elapsed().Nanoseconds()), "prepare_proposal_time(ns)")
-	b.ReportMetric(float64(len(prepareProposalResponse.Txs)), "number_of_transactions")
+	b.ReportMetric(float64(len(prepareProposalResp.Txs)), "number_of_transactions")
 	b.ReportMetric(float64(len(rawTxs[0])), "transactions_size(byte)")
-	b.ReportMetric(calculateBlockSizeInMb(prepareProposalResponse.Txs), "block_size(mb)")
-	b.ReportMetric(float64(calculateTotalGasUsed(testApp, prepareProposalResponse.Txs)), "total_gas_used")
+	b.ReportMetric(calculateBlockSizeInMb(prepareProposalResp.Txs), "block_size(mb)")
+	b.ReportMetric(float64(calculateTotalGasUsed(testApp, prepareProposalResp.Txs)), "total_gas_used")
 	b.ReportMetric(float64(numberOfValidators), "number_of_validators")
 	b.ReportMetric(float64(2*numberOfValidators/3), "number_of_verified_signatures")
 }
@@ -204,33 +207,35 @@ func BenchmarkIBC_ProcessProposal_Update_Client_Multi(b *testing.B) {
 }
 
 func benchmarkIBCProcessProposalUpdateClient(b *testing.B, numberOfValidators, count int) {
-	testApp, rawTxs := generateIBCUpdateClientTransaction(b, numberOfValidators, count, 0)
+	testApp, rawTxs := generateIBCUpdateClientTransaction(b, numberOfValidators, count, count)
 
-	prepareProposalRequest := types.RequestPrepareProposal{
+	prepareProposalReq := types.RequestPrepareProposal{
 		Txs:    rawTxs,
-		Height: 10,
+		Height: testApp.LastBlockHeight() + 1,
 	}
 
-	prepareProposalResponse, err := testApp.PrepareProposal(&prepareProposalRequest)
+	prepareProposalResp, err := testApp.PrepareProposal(&prepareProposalReq)
 	require.NoError(b, err)
-	require.GreaterOrEqual(b, len(prepareProposalResponse.Txs), 1)
+	require.GreaterOrEqual(b, len(prepareProposalResp.Txs), 1)
 
-	processProposalRequest := types.RequestProcessProposal{
-		Txs:    prepareProposalResponse.Txs,
-		Height: 10,
+	processProposalReq := types.RequestProcessProposal{
+		Txs:          prepareProposalResp.Txs,
+		Height:       testApp.LastBlockHeight() + 1,
+		DataRootHash: prepareProposalResp.DataRootHash,
+		SquareSize:   prepareProposalResp.SquareSize,
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.ProcessProposal(&processProposalRequest)
+	resp, err := testApp.ProcessProposal(&processProposalReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.Equal(b, types.ResponseProcessProposal_ACCEPT, resp.Status)
 
 	b.ReportMetric(float64(b.Elapsed().Nanoseconds()), "process_proposal_time(ns)")
-	b.ReportMetric(float64(len(prepareProposalResponse.Txs)), "number_of_transactions")
+	b.ReportMetric(float64(len(prepareProposalResp.Txs)), "number_of_transactions")
 	b.ReportMetric(float64(len(rawTxs[0])), "transactions_size(byte)")
-	b.ReportMetric(calculateBlockSizeInMb(prepareProposalResponse.Txs), "block_size(mb)")
-	b.ReportMetric(float64(calculateTotalGasUsed(testApp, prepareProposalResponse.Txs)), "total_gas_used")
+	b.ReportMetric(calculateBlockSizeInMb(prepareProposalResp.Txs), "block_size(mb)")
+	b.ReportMetric(float64(calculateTotalGasUsed(testApp, prepareProposalResp.Txs)), "total_gas_used")
 	b.ReportMetric(float64(numberOfValidators), "number_of_validators")
 	b.ReportMetric(float64(2*numberOfValidators/3), "number_of_verified_signatures")
 }
@@ -275,7 +280,7 @@ func generateIBCUpdateClientTransaction(b *testing.B, numberOfValidators, number
 	return testApp, rawTxs
 }
 
-func generateUpdateClientTransaction(b *testing.B, app *app.App, signer user.Signer, signerAddr, signerName string, numberOfValidators, numberOfMsgs int) []*types3.MsgUpdateClient {
+func generateUpdateClientTransaction(b *testing.B, app *app.App, signer user.Signer, signerAddr, signerName string, numberOfValidators, numberOfMsgs int) []*clienttypes.MsgUpdateClient {
 	state, _, privVals := makeState(numberOfValidators, 5)
 	wBefore := time.Now()
 	time.Sleep(time.Second)
@@ -285,8 +290,8 @@ func generateUpdateClientTransaction(b *testing.B, app *app.App, signer user.Sig
 	lastCommitHash := crypto.CRandBytes(tmhash.Size)
 	lastBlockHash := crypto.CRandBytes(tmhash.Size)
 	lastBlockID := makeBlockID(lastBlockHash, 1000, []byte("hash"))
-	header := tmproto.Header{
-		Version:            tmprotoversion.Consensus{Block: version.BlockProtocol, App: 1},
+	header := cmtproto.Header{
+		Version:            cmtprotoversion.Consensus{Block: version.BlockProtocol, App: 1},
 		ChainID:            state.ChainID,
 		Height:             5,
 		Time:               w,
@@ -301,8 +306,8 @@ func generateUpdateClientTransaction(b *testing.B, app *app.App, signer user.Sig
 		ProposerAddress:    crypto.CRandBytes(crypto.AddressSize),
 		LastBlockId:        lastBlockID.ToProto(),
 	}
-	t := types0.Header{
-		Version:            tmprotoversion.Consensus{Block: version.BlockProtocol, App: 1},
+	t := cmttypes.Header{
+		Version:            cmtprotoversion.Consensus{Block: version.BlockProtocol, App: 1},
 		ChainID:            state.ChainID,
 		Height:             5,
 		Time:               w,
@@ -321,30 +326,30 @@ func generateUpdateClientTransaction(b *testing.B, app *app.App, signer user.Sig
 	blockID := makeBlockID(header0Hash, 1000, []byte("partshash"))
 	commit, err := makeValidCommit(5, blockID, state.Validators, privVals)
 	require.NoError(b, err)
-	signatures := make([]tmproto.CommitSig, numberOfValidators)
-	validators := make([]*tmproto.Validator, numberOfValidators)
+	signatures := make([]cmtproto.CommitSig, numberOfValidators)
+	validators := make([]*cmtproto.Validator, numberOfValidators)
 	for i := 0; i < numberOfValidators; i++ {
-		signatures[i] = tmproto.CommitSig{
-			BlockIdFlag:      tmproto.BlockIDFlag(commit.Signatures[i].BlockIDFlag),
+		signatures[i] = cmtproto.CommitSig{
+			BlockIdFlag:      cmtproto.BlockIDFlag(commit.Signatures[i].BlockIDFlag),
 			ValidatorAddress: commit.Signatures[i].ValidatorAddress,
 			Timestamp:        commit.Signatures[i].Timestamp,
 			Signature:        commit.Signatures[i].Signature,
 		}
-		validators[i] = &tmproto.Validator{
+		validators[i] = &cmtproto.Validator{
 			Address:          state.Validators.Validators[i].Address,
-			PubKey:           crypto2.PublicKey{Sum: &crypto2.PublicKey_Ed25519{Ed25519: state.Validators.Validators[i].PubKey.Bytes()}},
+			PubKey:           cmtprotocrypto.PublicKey{Sum: &cmtprotocrypto.PublicKey_Ed25519{Ed25519: state.Validators.Validators[i].PubKey.Bytes()}},
 			VotingPower:      state.Validators.Validators[i].VotingPower,
 			ProposerPriority: state.Validators.Validators[i].ProposerPriority,
 		}
 	}
-	sh := tmproto.SignedHeader{
+	sh := cmtproto.SignedHeader{
 		Header: &header,
-		Commit: &tmproto.Commit{
+		Commit: &cmtproto.Commit{
 			Height: commit.Height,
 			Round:  commit.Round,
-			BlockID: tmproto.BlockID{
+			BlockID: cmtproto.BlockID{
 				Hash: header0Hash,
-				PartSetHeader: tmproto.PartSetHeader{
+				PartSetHeader: cmtproto.PartSetHeader{
 					Total: commit.BlockID.PartSetHeader.Total,
 					Hash:  commit.BlockID.PartSetHeader.Hash,
 				},
@@ -352,70 +357,78 @@ func generateUpdateClientTransaction(b *testing.B, app *app.App, signer user.Sig
 			Signatures: signatures,
 		},
 	}
-	clientState := types4.ClientState{
+	clientState := ibctm.ClientState{
 		ChainId:         chainID,
-		TrustLevel:      types4.Fraction{Numerator: 1, Denominator: 3},
+		TrustLevel:      ibctm.Fraction{Numerator: 1, Denominator: 3},
 		TrustingPeriod:  time.Hour * 24 * 21 * 100, // we want to always accept the upgrade
 		UnbondingPeriod: time.Hour * 24 * 21 * 101,
 		MaxClockDrift:   math.MaxInt64 - 1,
-		FrozenHeight:    types3.Height{},
-		LatestHeight: types3.Height{
+		FrozenHeight:    clienttypes.Height{},
+		LatestHeight: clienttypes.Height{
 			RevisionNumber: 0,
 			RevisionHeight: 4,
 		},
-		ProofSpecs:                   types2.GetSDKSpecs(),
+		ProofSpecs:                   commitmenttypes.GetSDKSpecs(),
 		AllowUpdateAfterExpiry:       true,
 		AllowUpdateAfterMisbehaviour: true,
 	}
-	consensusState := types4.ConsensusState{
+	consensusState := ibctm.ConsensusState{
 		Timestamp:          wBefore,
-		Root:               types2.MerkleRoot{Hash: lastBlockHash},
+		Root:               commitmenttypes.MerkleRoot{Hash: lastBlockHash},
 		NextValidatorsHash: state.Validators.Hash(),
 	}
 
-	msgs := make([]*types3.MsgUpdateClient, numberOfMsgs)
+	msgs := make([]*clienttypes.MsgUpdateClient, numberOfMsgs)
 	for index := 0; index < numberOfMsgs; index++ {
-		createClientMsg, err := types3.NewMsgCreateClient(&clientState, &consensusState, signerAddr)
+		createClientMsg, err := clienttypes.NewMsgCreateClient(&clientState, &consensusState, signerAddr)
 		require.NoError(b, err)
 		rawTx, _, err := signer.CreateTx([]sdk.Msg{createClientMsg}, user.SetGasLimit(2549760000), user.SetFee(10000))
 		require.NoError(b, err)
-		resp, err := app.FinalizeBlock(&types.RequestFinalizeBlock{Txs: [][]byte{rawTx}})
+		resp, err := app.FinalizeBlock(&types.RequestFinalizeBlock{
+			Height: app.LastBlockHeight() + 1,
+			Time:   testutil.GenesisTime.Add(blockTime),
+			Hash:   app.LastCommitID().Hash,
+			Txs:    [][]byte{rawTx},
+		})
 		require.NoError(b, err)
+
 		var clientName string
-		for _, event := range resp.Events {
-			if event.Type == types3.EventTypeCreateClient {
-				for _, attribute := range event.Attributes {
-					if string(attribute.Key) == types3.AttributeKeyClientID {
-						clientName = string(attribute.Value)
+		for _, res := range resp.TxResults {
+			for _, event := range res.Events {
+				if event.Type == clienttypes.EventTypeCreateClient {
+					for _, attribute := range event.Attributes {
+						if string(attribute.Key) == clienttypes.AttributeKeyClientID {
+							clientName = string(attribute.Value)
+						}
 					}
 				}
 			}
+			require.NotEmpty(b, clientName)
 		}
-		require.NotEmpty(b, clientName)
 
-		msg, err := types3.NewMsgUpdateClient(
+		msg, err := clienttypes.NewMsgUpdateClient(
 			clientName,
-			&types4.Header{
+			&ibctm.Header{
 				SignedHeader: &sh,
-				ValidatorSet: &tmproto.ValidatorSet{
+				ValidatorSet: &cmtproto.ValidatorSet{
 					Validators: validators,
-					Proposer: &tmproto.Validator{
+					Proposer: &cmtproto.Validator{
 						Address:          state.Validators.Proposer.Address,
-						PubKey:           crypto2.PublicKey{Sum: &crypto2.PublicKey_Ed25519{Ed25519: state.Validators.Proposer.PubKey.Bytes()}},
+						PubKey:           cmtprotocrypto.PublicKey{Sum: &cmtprotocrypto.PublicKey_Ed25519{Ed25519: state.Validators.Proposer.PubKey.Bytes()}},
 						VotingPower:      state.Validators.Proposer.VotingPower,
 						ProposerPriority: state.Validators.Proposer.ProposerPriority,
 					},
 					TotalVotingPower: state.Validators.TotalVotingPower(),
 				},
-				TrustedHeight: types3.Height{
+				TrustedHeight: clienttypes.Height{
 					RevisionNumber: 0,
 					RevisionHeight: 4,
 				},
-				TrustedValidators: &tmproto.ValidatorSet{
+				TrustedValidators: &cmtproto.ValidatorSet{
 					Validators: validators,
-					Proposer: &tmproto.Validator{
+					Proposer: &cmtproto.Validator{
 						Address:          state.Validators.Proposer.Address,
-						PubKey:           crypto2.PublicKey{Sum: &crypto2.PublicKey_Ed25519{Ed25519: state.Validators.Proposer.PubKey.Bytes()}},
+						PubKey:           cmtprotocrypto.PublicKey{Sum: &cmtprotocrypto.PublicKey_Ed25519{Ed25519: state.Validators.Proposer.PubKey.Bytes()}},
 						VotingPower:      state.Validators.Proposer.VotingPower,
 						ProposerPriority: state.Validators.Proposer.ProposerPriority,
 					},
@@ -433,22 +446,22 @@ func generateUpdateClientTransaction(b *testing.B, app *app.App, signer user.Sig
 	return msgs
 }
 
-func makeState(nVals, height int) (sm.State, dbm.DB, map[string]types0.PrivValidator) {
-	vals := make([]types0.GenesisValidator, nVals)
-	privVals := make(map[string]types0.PrivValidator, nVals)
+func makeState(nVals, height int) (sm.State, dbm.DB, map[string]cmttypes.PrivValidator) {
+	vals := make([]cmttypes.GenesisValidator, nVals)
+	privVals := make(map[string]cmttypes.PrivValidator, nVals)
 	for i := 0; i < nVals; i++ {
 		secret := []byte(fmt.Sprintf("test%d", i))
 		pk := ed25519.GenPrivKeyFromSecret(secret)
 		valAddr := pk.PubKey().Address()
-		vals[i] = types0.GenesisValidator{
+		vals[i] = cmttypes.GenesisValidator{
 			Address: valAddr,
 			PubKey:  pk.PubKey(),
 			Power:   1000,
 			Name:    fmt.Sprintf("test%d", i),
 		}
-		privVals[valAddr.String()] = types0.NewMockPVWithParams(pk, false, false)
+		privVals[valAddr.String()] = cmttypes.NewMockPVWithParams(pk, false, false)
 	}
-	s, _ := sm.MakeGenesisState(&types0.GenesisDoc{
+	s, _ := sm.MakeGenesisState(&cmttypes.GenesisDoc{
 		ChainID:    appconsts.TestChainID,
 		Validators: vals,
 		AppHash:    nil,
@@ -475,20 +488,20 @@ func makeState(nVals, height int) (sm.State, dbm.DB, map[string]types0.PrivValid
 
 func makeValidCommit(
 	height int64,
-	blockID types0.BlockID,
-	vals *types0.ValidatorSet,
-	privVals map[string]types0.PrivValidator,
-) (*types0.Commit, error) {
-	sigs := make([]types0.CommitSig, 0)
+	blockID cmttypes.BlockID,
+	vals *cmttypes.ValidatorSet,
+	privVals map[string]cmttypes.PrivValidator,
+) (*cmttypes.Commit, error) {
+	sigs := make([]cmttypes.CommitSig, 0)
 	for i := 0; i < vals.Size(); i++ {
 		_, val := vals.GetByIndex(int32(i))
-		vote, err := types0.MakeVote(height, blockID, vals, privVals[val.Address.String()], chainID, time.Now())
+		vote, err := cmttypes.MakeVote(privVals[val.Address.String()], appconsts.TestChainID, int32(i), height, 0, cmtproto.PrecommitType, blockID, time.Now())
 		if err != nil {
 			return nil, err
 		}
 		sigs = append(sigs, vote.CommitSig())
 	}
-	return &types0.Commit{
+	return &cmttypes.Commit{
 		Height:     height,
 		Round:      0,
 		BlockID:    blockID,
@@ -496,16 +509,16 @@ func makeValidCommit(
 	}, nil
 }
 
-func makeBlockID(hash []byte, partSetSize uint32, partSetHash []byte) types0.BlockID {
+func makeBlockID(hash []byte, partSetSize uint32, partSetHash []byte) cmttypes.BlockID {
 	var (
 		h   = make([]byte, tmhash.Size)
 		psH = make([]byte, tmhash.Size)
 	)
 	copy(h, hash)
 	copy(psH, partSetHash)
-	return types0.BlockID{
+	return cmttypes.BlockID{
 		Hash: h,
-		PartSetHeader: types0.PartSetHeader{
+		PartSetHeader: cmttypes.PartSetHeader{
 			Total: partSetSize,
 			Hash:  psH,
 		},
diff --git a/app/benchmarks/benchmark_msg_send_test.go b/app/benchmarks/benchmark_msg_send_test.go
index 72ee3676..ef844708 100644
--- a/app/benchmarks/benchmark_msg_send_test.go
+++ b/app/benchmarks/benchmark_msg_send_test.go
@@ -1,4 +1,4 @@
-//go:build bench_abci_methods
+//go:build benchmarks
 
 package benchmarks_test
 
@@ -20,17 +20,30 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const blockTime = time.Duration(6 * time.Second)
+
 func BenchmarkCheckTx_MsgSend_1(b *testing.B) {
 	testApp, rawTxs := generateMsgSendTransactions(b, 1)
-	testApp.Commit()
 
-	checkTxRequest := types.RequestCheckTx{
+	finalizeBlockResp, err := testApp.FinalizeBlock(&types.RequestFinalizeBlock{
+		Time:   testutil.GenesisTime.Add(blockTime),
+		Height: testApp.LastBlockHeight() + 1,
+		Hash:   testApp.LastCommitID().Hash,
+	})
+	require.NotNil(b, finalizeBlockResp)
+	require.NoError(b, err)
+
+	commitResp, err := testApp.Commit()
+	require.NotNil(b, commitResp)
+	require.NoError(b, err)
+
+	checkTxReq := types.RequestCheckTx{
 		Tx:   rawTxs[0],
 		Type: types.CheckTxType_New,
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.CheckTx(&checkTxRequest)
+	resp, err := testApp.CheckTx(&checkTxReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.Equal(b, uint32(0), resp.Code)
@@ -40,7 +53,18 @@ func BenchmarkCheckTx_MsgSend_1(b *testing.B) {
 
 func BenchmarkCheckTx_MsgSend_8MB(b *testing.B) {
 	testApp, rawTxs := generateMsgSendTransactions(b, 31645)
-	testApp.Commit()
+
+	finalizeBlockResp, err := testApp.FinalizeBlock(&types.RequestFinalizeBlock{
+		Time:   testutil.GenesisTime.Add(blockTime),
+		Height: testApp.LastBlockHeight() + 1,
+		Hash:   testApp.LastCommitID().Hash,
+	})
+	require.NotNil(b, finalizeBlockResp)
+	require.NoError(b, err)
+
+	commitResp, err := testApp.Commit()
+	require.NotNil(b, commitResp)
+	require.NoError(b, err)
 
 	var totalGas int64
 	b.ResetTimer()
@@ -62,52 +86,60 @@ func BenchmarkCheckTx_MsgSend_8MB(b *testing.B) {
 	b.ReportMetric(float64(totalGas), "total_gas_used")
 }
 
-func BenchmarkDeliverTx_MsgSend_1(b *testing.B) {
+func BenchmarkFinalizeBlock_MsgSend_1(b *testing.B) {
 	testApp, rawTxs := generateMsgSendTransactions(b, 1)
 
-	deliverTxRequest := types.RequestFinalizeBlock{
-		Txs: rawTxs,
+	finalizeBlockReq := types.RequestFinalizeBlock{
+		Time:   testutil.GenesisTime.Add(blockTime),
+		Height: testApp.LastBlockHeight() + 1,
+		Hash:   testApp.LastCommitID().Hash,
+		Txs:    rawTxs,
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.FinalizeBlock(&deliverTxRequest)
+	resp, err := testApp.FinalizeBlock(&finalizeBlockReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.Equal(b, uint32(0), resp.TxResults[0].Code)
 	b.ReportMetric(float64(resp.TxResults[0].GasUsed), "gas_used")
 }
 
-func BenchmarkDeliverTx_MsgSend_8MB(b *testing.B) {
+func BenchmarkFinalizeBlock_MsgSend_8MB(b *testing.B) {
+	b.ResetTimer()
 	testApp, rawTxs := generateMsgSendTransactions(b, 31645)
 
-	var totalGas int64
-	b.ResetTimer()
-	deliverTxRequest := types.RequestFinalizeBlock{
-		Txs: rawTxs,
+	finalizeBlockReq := types.RequestFinalizeBlock{
+		Time:   testutil.GenesisTime.Add(blockTime),
+		Height: testApp.LastBlockHeight() + 1,
+		Hash:   testApp.LastCommitID().Hash,
+		Txs:    rawTxs,
 	}
+
 	b.StartTimer()
-	resp, err := testApp.FinalizeBlock(&deliverTxRequest)
+	resp, err := testApp.FinalizeBlock(&finalizeBlockReq)
 	require.NoError(b, err)
+	b.StopTimer()
+
+	var totalGas int64
 	for i := range rawTxs {
-		b.StopTimer()
 		require.Equal(b, uint32(0), resp.TxResults[i].Code)
 		require.Equal(b, "", resp.TxResults[i].Codespace)
-		totalGas += resp.TxResults[0].GasUsed
+		totalGas += resp.TxResults[i].GasUsed
 	}
-	b.StopTimer()
+
 	b.ReportMetric(float64(totalGas), "total_gas_used")
 }
 
 func BenchmarkPrepareProposal_MsgSend_1(b *testing.B) {
 	testApp, rawTxs := generateMsgSendTransactions(b, 1)
 
-	prepareProposalRequest := types.RequestPrepareProposal{
+	prepareProposalReq := types.RequestPrepareProposal{
 		Txs:    rawTxs,
-		Height: 10,
+		Height: testApp.LastBlockHeight() + 1,
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.PrepareProposal(&prepareProposalRequest)
+	resp, err := testApp.PrepareProposal(&prepareProposalReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.GreaterOrEqual(b, len(resp.Txs), 1)
@@ -119,13 +151,13 @@ func BenchmarkPrepareProposal_MsgSend_8MB(b *testing.B) {
 	// using 31645 to let prepare proposal choose the maximum
 	testApp, rawTxs := generateMsgSendTransactions(b, 31645)
 
-	prepareProposalRequest := types.RequestPrepareProposal{
+	prepareProposalReq := types.RequestPrepareProposal{
 		Txs:    rawTxs,
-		Height: 10,
+		Height: testApp.LastBlockHeight() + 1,
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.PrepareProposal(&prepareProposalRequest)
+	resp, err := testApp.PrepareProposal(&prepareProposalReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.GreaterOrEqual(b, len(resp.Txs), 1)
@@ -137,27 +169,29 @@ func BenchmarkPrepareProposal_MsgSend_8MB(b *testing.B) {
 func BenchmarkProcessProposal_MsgSend_1(b *testing.B) {
 	testApp, rawTxs := generateMsgSendTransactions(b, 1)
 
-	prepareProposalRequest := types.RequestPrepareProposal{
+	prepareProposalReq := types.RequestPrepareProposal{
 		Txs:    rawTxs,
-		Height: 10,
+		Height: testApp.LastBlockHeight() + 1,
 	}
-	prepareProposalResponse, err := testApp.PrepareProposal(&prepareProposalRequest)
+
+	prepareProposalResp, err := testApp.PrepareProposal(&prepareProposalReq)
 	require.NoError(b, err)
-	require.GreaterOrEqual(b, len(prepareProposalResponse.Txs), 1)
+	require.Len(b, prepareProposalResp.Txs, 1)
 
-	processProposalRequest := types.RequestProcessProposal{
-		Txs:          prepareProposalResponse.Txs,
-		Height:       10,
-		DataRootHash: prepareProposalResponse.DataRootHash,
+	processProposalReq := types.RequestProcessProposal{
+		Txs:          prepareProposalResp.Txs,
+		Height:       testApp.LastBlockHeight() + 1,
+		DataRootHash: prepareProposalResp.DataRootHash,
+		SquareSize:   1,
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.ProcessProposal(&processProposalRequest)
+	resp, err := testApp.ProcessProposal(&processProposalReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.Equal(b, types.ResponseProcessProposal_ACCEPT, resp.Status)
 
-	b.ReportMetric(float64(calculateTotalGasUsed(testApp, prepareProposalResponse.Txs)), "total_gas_used")
+	b.ReportMetric(float64(calculateTotalGasUsed(testApp, prepareProposalResp.Txs)), "total_gas_used")
 }
 
 func BenchmarkProcessProposal_MsgSend_8MB(b *testing.B) {
@@ -165,31 +199,33 @@ func BenchmarkProcessProposal_MsgSend_8MB(b *testing.B) {
 	// using 31645 to let prepare proposal choose the maximum
 	testApp, rawTxs := generateMsgSendTransactions(b, 31645)
 
-	prepareProposalRequest := types.RequestPrepareProposal{
+	prepareProposalReq := types.RequestPrepareProposal{
 		Txs:    rawTxs,
-		Height: 10,
+		Height: testApp.LastBlockHeight() + 1,
 	}
-	prepareProposalResponse, err := testApp.PrepareProposal(&prepareProposalRequest)
+
+	prepareProposalResp, err := testApp.PrepareProposal(&prepareProposalReq)
 	require.NoError(b, err)
-	require.GreaterOrEqual(b, len(prepareProposalResponse.Txs), 1)
+	require.GreaterOrEqual(b, len(prepareProposalResp.Txs), 1)
 
-	b.ReportMetric(float64(len(prepareProposalResponse.Txs)), "number_of_transactions")
-	b.ReportMetric(calculateBlockSizeInMb(prepareProposalResponse.Txs), "block_size_(mb)")
-	b.ReportMetric(float64(calculateTotalGasUsed(testApp, prepareProposalResponse.Txs)), "total_gas_used")
+	b.ReportMetric(float64(len(prepareProposalResp.Txs)), "number_of_transactions")
+	b.ReportMetric(calculateBlockSizeInMb(prepareProposalResp.Txs), "block_size_(mb)")
+	b.ReportMetric(float64(calculateTotalGasUsed(testApp, prepareProposalResp.Txs)), "total_gas_used")
 
-	processProposalRequest := types.RequestProcessProposal{
-		Txs:          prepareProposalResponse.Txs,
-		Height:       10,
-		DataRootHash: prepareProposalResponse.DataRootHash,
+	processProposalReq := types.RequestProcessProposal{
+		Txs:          prepareProposalResp.Txs,
+		Height:       testApp.LastBlockHeight() + 1,
+		DataRootHash: prepareProposalResp.DataRootHash,
+		SquareSize:   128,
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.ProcessProposal(&processProposalRequest)
+	resp, err := testApp.ProcessProposal(&processProposalReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.Equal(b, types.ResponseProcessProposal_ACCEPT, resp.Status)
 
-	b.ReportMetric(float64(calculateTotalGasUsed(testApp, prepareProposalResponse.Txs)), "total_gas_used")
+	b.ReportMetric(float64(calculateTotalGasUsed(testApp, prepareProposalResp.Txs)), "total_gas_used")
 }
 
 func BenchmarkProcessProposal_MsgSend_8MB_Find_Half_Sec(b *testing.B) {
@@ -205,23 +241,24 @@ func BenchmarkProcessProposal_MsgSend_8MB_Find_Half_Sec(b *testing.B) {
 			break
 		}
 
-		prepareProposalRequest := types.RequestPrepareProposal{
+		prepareProposalReq := types.RequestPrepareProposal{
 			Txs:    rawTxs[start:end],
-			Height: 10,
+			Height: testApp.LastBlockHeight() + 1,
 		}
-		prepareProposalResponse, err := testApp.PrepareProposal(&prepareProposalRequest)
-		require.NoError(b, err)
-		require.GreaterOrEqual(b, len(prepareProposalResponse.Txs), 1)
 
-		processProposalRequest := types.RequestProcessProposal{
-			Txs: prepareProposalResponse.Txs,
+		prepareProposalResp, err := testApp.PrepareProposal(&prepareProposalReq)
+		require.NoError(b, err)
+		require.GreaterOrEqual(b, len(prepareProposalResp.Txs), 1)
 
-			Height:       10,
-			DataRootHash: prepareProposalResponse.DataRootHash,
+		processProposalReq := types.RequestProcessProposal{
+			Txs:          prepareProposalResp.Txs,
+			Height:       testApp.LastBlockHeight() + 1,
+			DataRootHash: prepareProposalResp.DataRootHash,
+			SquareSize:   64,
 		}
 
 		startTime := time.Now()
-		resp, err := testApp.ProcessProposal(&processProposalRequest)
+		resp, err := testApp.ProcessProposal(&processProposalReq)
 		require.NoError(b, err)
 		endTime := time.Now()
 		require.Equal(b, types.ResponseProcessProposal_ACCEPT, resp.Status)
diff --git a/app/benchmarks/benchmark_pfb_test.go b/app/benchmarks/benchmark_pfb_test.go
index ffee9f5a..4571b439 100644
--- a/app/benchmarks/benchmark_pfb_test.go
+++ b/app/benchmarks/benchmark_pfb_test.go
@@ -1,4 +1,4 @@
-//go:build bench_abci_methods
+//go:build benchmarks
 
 package benchmarks_test
 
@@ -8,18 +8,18 @@ import (
 	"time"
 
 	"cosmossdk.io/log"
+	"github.com/cometbft/cometbft/abci/types"
 	"github.com/cometbft/cometbft/crypto"
+	"github.com/stretchr/testify/require"
+
+	"github.com/celestiaorg/go-square/v2/share"
+	blobtx "github.com/celestiaorg/go-square/v2/tx"
 
 	"github.com/celestiaorg/celestia-app/v4/app"
 	"github.com/celestiaorg/celestia-app/v4/app/encoding"
-	"github.com/celestiaorg/celestia-app/v4/pkg/appconsts"
 	"github.com/celestiaorg/celestia-app/v4/pkg/user"
 	testutil "github.com/celestiaorg/celestia-app/v4/test/util"
 	"github.com/celestiaorg/celestia-app/v4/test/util/testfactory"
-	"github.com/celestiaorg/go-square/v2/share"
-	blobtx "github.com/celestiaorg/go-square/v2/tx"
-	"github.com/cometbft/cometbft/abci/types"
-	"github.com/stretchr/testify/require"
 )
 
 func init() {
@@ -42,11 +42,7 @@ func BenchmarkCheckTx_PFB_Multi(b *testing.B) {
 		{blobSize: 400_000},
 		{blobSize: 500_000},
 		{blobSize: 1_000_000},
-		{blobSize: 2_000_000},
-		{blobSize: 3_000_000},
-		{blobSize: 4_000_000},
-		{blobSize: 5_000_000},
-		{blobSize: 6_000_000},
+		{blobSize: 2_000_000}, // maxTxSize is capped at 2MiB in checkTx
 	}
 	for _, testCase := range testCases {
 		b.Run(fmt.Sprintf("%d bytes", testCase.blobSize), func(b *testing.B) {
@@ -57,7 +53,18 @@ func BenchmarkCheckTx_PFB_Multi(b *testing.B) {
 
 func benchmarkCheckTxPFB(b *testing.B, size int) {
 	testApp, rawTxs := generatePayForBlobTransactions(b, 1, size)
-	testApp.Commit()
+
+	finalizeBlockResp, err := testApp.FinalizeBlock(&types.RequestFinalizeBlock{
+		Time:   testutil.GenesisTime.Add(blockTime),
+		Height: testApp.LastBlockHeight() + 1,
+		Hash:   testApp.LastCommitID().Hash,
+	})
+	require.NotNil(b, finalizeBlockResp)
+	require.NoError(b, err)
+
+	commitResp, err := testApp.Commit()
+	require.NotNil(b, commitResp)
+	require.NoError(b, err)
 
 	checkTxRequest := types.RequestCheckTx{
 		Tx:   rawTxs[0],
@@ -74,7 +81,7 @@ func benchmarkCheckTxPFB(b *testing.B, size int) {
 	b.ReportMetric(float64(len(rawTxs[0])), "transaction_size(byte)")
 }
 
-func BenchmarkDeliverTx_PFB_Multi(b *testing.B) {
+func BenchmarkFinalizeBlock_PFB_Multi(b *testing.B) {
 	testCases := []struct {
 		blobSize int
 	}{
@@ -98,24 +105,27 @@ func BenchmarkDeliverTx_PFB_Multi(b *testing.B) {
 	}
 	for _, testCase := range testCases {
 		b.Run(fmt.Sprintf("%d bytes", testCase.blobSize), func(b *testing.B) {
-			benchmarkDeliverTxPFB(b, testCase.blobSize)
+			benchmarkFinalizeBlockPFB(b, testCase.blobSize)
 		})
 	}
 }
 
-func benchmarkDeliverTxPFB(b *testing.B, size int) {
+func benchmarkFinalizeBlockPFB(b *testing.B, size int) {
 	testApp, rawTxs := generatePayForBlobTransactions(b, 1, size)
 
 	blobTx, ok, err := blobtx.UnmarshalBlobTx(rawTxs[0])
 	require.NoError(b, err)
 	require.True(b, ok)
 
-	deliverTxRequest := types.RequestFinalizeBlock{
-		Txs: [][]byte{blobTx.Tx},
+	finalizeBlockReq := types.RequestFinalizeBlock{
+		Time:   testutil.GenesisTime.Add(blockTime),
+		Height: testApp.LastBlockHeight() + 1,
+		Hash:   testApp.LastCommitID().Hash,
+		Txs:    [][]byte{blobTx.Tx},
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.FinalizeBlock(&deliverTxRequest)
+	resp, err := testApp.FinalizeBlock(&finalizeBlockReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.Equal(b, uint32(0), resp.TxResults[0].Code)
@@ -156,20 +166,20 @@ func BenchmarkPrepareProposal_PFB_Multi(b *testing.B) {
 func benchmarkPrepareProposalPFB(b *testing.B, count, size int) {
 	testApp, rawTxs := generatePayForBlobTransactions(b, count, size)
 
-	prepareProposalRequest := types.RequestPrepareProposal{
+	prepareProposalReq := types.RequestPrepareProposal{
 		Txs:    rawTxs,
-		Height: 10,
+		Height: testApp.LastBlockHeight() + 1,
 	}
 
 	b.ResetTimer()
-	prepareProposalResponse, err := testApp.PrepareProposal(&prepareProposalRequest)
+	prepareProposalResp, err := testApp.PrepareProposal(&prepareProposalReq)
 	require.NoError(b, err)
 	b.StopTimer()
-	require.GreaterOrEqual(b, len(prepareProposalResponse.Txs), 1)
+	require.GreaterOrEqual(b, len(prepareProposalResp.Txs), 1)
 	b.ReportMetric(float64(b.Elapsed().Nanoseconds()), "prepare_proposal_time(ns)")
-	b.ReportMetric(float64(len(prepareProposalResponse.Txs)), "number_of_transactions")
+	b.ReportMetric(float64(len(prepareProposalResp.Txs)), "number_of_transactions")
 	b.ReportMetric(float64(len(rawTxs[0])), "transactions_size(byte)")
-	b.ReportMetric(calculateBlockSizeInMb(prepareProposalResponse.Txs), "block_size(mb)")
+	b.ReportMetric(calculateBlockSizeInMb(prepareProposalResp.Txs), "block_size(mb)")
 	b.ReportMetric(float64(calculateTotalGasUsed(testApp, rawTxs)), "total_gas_used")
 }
 
@@ -205,31 +215,32 @@ func BenchmarkProcessProposal_PFB_Multi(b *testing.B) {
 func benchmarkProcessProposalPFB(b *testing.B, count, size int) {
 	testApp, rawTxs := generatePayForBlobTransactions(b, count, size)
 
-	prepareProposalRequest := types.RequestPrepareProposal{
+	prepareProposalReq := types.RequestPrepareProposal{
 		Txs:    rawTxs,
-		Height: 10,
+		Height: testApp.LastBlockHeight() + 1,
 	}
 
-	prepareProposalResponse, err := testApp.PrepareProposal(&prepareProposalRequest)
+	prepareProposalResp, err := testApp.PrepareProposal(&prepareProposalReq)
 	require.NoError(b, err)
-	require.GreaterOrEqual(b, len(prepareProposalResponse.Txs), 1)
+	require.GreaterOrEqual(b, len(prepareProposalResp.Txs), 1)
 
-	processProposalRequest := types.RequestProcessProposal{
-		Txs:          prepareProposalResponse.Txs,
-		Height:       10,
-		DataRootHash: prepareProposalResponse.DataRootHash, // TODO: check if this is correct
+	processProposalReq := types.RequestProcessProposal{
+		Txs:          prepareProposalResp.Txs,
+		Height:       testApp.LastBlockHeight() + 1,
+		DataRootHash: prepareProposalResp.DataRootHash,
+		SquareSize:   prepareProposalResp.SquareSize,
 	}
 
 	b.ResetTimer()
-	resp, err := testApp.ProcessProposal(&processProposalRequest)
+	resp, err := testApp.ProcessProposal(&processProposalReq)
 	require.NoError(b, err)
 	b.StopTimer()
 	require.Equal(b, types.ResponseProcessProposal_ACCEPT, resp.Status)
 
 	b.ReportMetric(float64(b.Elapsed().Nanoseconds()), "process_proposal_time(ns)")
-	b.ReportMetric(float64(len(prepareProposalResponse.Txs)), "number_of_transactions")
+	b.ReportMetric(float64(len(prepareProposalResp.Txs)), "number_of_transactions")
 	b.ReportMetric(float64(len(rawTxs[0])), "transactions_size(byte)")
-	b.ReportMetric(calculateBlockSizeInMb(prepareProposalResponse.Txs), "block_size(mb)")
+	b.ReportMetric(calculateBlockSizeInMb(prepareProposalResp.Txs), "block_size(mb)")
 	b.ReportMetric(float64(calculateTotalGasUsed(testApp, rawTxs)), "total_gas_used")
 }
 
@@ -260,79 +271,61 @@ func BenchmarkProcessProposal_PFB_Half_Second(b *testing.B) {
 func benchmarkProcessProposalPFBHalfSecond(b *testing.B, count, size int) {
 	testApp, rawTxs := generatePayForBlobTransactions(b, count, size)
 
-	targetTimeLowerBound := 0.499
-	targetTimeUpperBound := 0.511
-
-	start := 0
-	end := count
-	segment := end - start
-	maxIterations := 100000
-	iterations := 0
-	for {
-		iterations++
-		if iterations >= maxIterations {
-			b.Errorf("Maximum iterations reached without achieving target processing time")
-			break
-		}
-		if segment == 1 {
-			break
-		}
+	targetTimeLowerBound := time.Millisecond * 499
+	targetTimeUpperBound := time.Millisecond * 511
+
+	start := 1
+	end := len(rawTxs)
+	var bestTime time.Duration
+	found := false
+
+	var processProposalReq types.RequestProcessProposal
 
-		prepareProposalRequest := types.RequestPrepareProposal{
-			Txs:    rawTxs[start:end],
-			Height: 10,
+	for start <= end {
+		mid := (start + end) / 2
+
+		prepareProposalReq := types.RequestPrepareProposal{
+			Txs:    rawTxs[:mid],
+			Height: testApp.LastBlockHeight() + 1,
 		}
-		prepareProposalResponse, err := testApp.PrepareProposal(&prepareProposalRequest)
+
+		prepareProposalResp, err := testApp.PrepareProposal(&prepareProposalReq)
 		require.NoError(b, err)
-		require.GreaterOrEqual(b, len(prepareProposalResponse.Txs), 1)
+		require.GreaterOrEqual(b, len(prepareProposalResp.Txs), 1)
 
-		processProposalRequest := types.RequestProcessProposal{
-			Txs:          prepareProposalResponse.Txs,
-			Height:       10,
-			DataRootHash: prepareProposalResponse.DataRootHash, // TODO: check if this is correct
+		processProposalReq = types.RequestProcessProposal{
+			Txs:          prepareProposalResp.Txs,
+			Height:       testApp.LastBlockHeight() + 1,
+			DataRootHash: prepareProposalResp.DataRootHash,
+			SquareSize:   prepareProposalResp.SquareSize,
 		}
 
 		startTime := time.Now()
-		resp, err := testApp.ProcessProposal(&processProposalRequest)
+		resp, err := testApp.ProcessProposal(&processProposalReq)
 		require.NoError(b, err)
-		endTime := time.Now()
 		require.Equal(b, types.ResponseProcessProposal_ACCEPT, resp.Status)
-
-		timeElapsed := float64(endTime.Sub(startTime).Nanoseconds()) / 1e9
-
-		switch {
-		case timeElapsed < targetTimeLowerBound:
-			newEnd := end + segment/2
-			if newEnd > len(rawTxs) {
-				newEnd = len(rawTxs)
-			}
-			end = newEnd
-			segment = end - start
-			if segment <= 1 {
-				break
-			}
-			continue
-		case timeElapsed > targetTimeUpperBound:
-			newEnd := end / 2
-			if newEnd <= start {
-				break
-			}
-			end = newEnd
-			segment = end - start
-			continue
-		default:
-			b.ReportMetric(
-				timeElapsed,
-				fmt.Sprintf(
-					"processProposalTime(s)_%d_%d_%f",
-					end-start,
-					size,
-					calculateBlockSizeInMb(prepareProposalResponse.Txs[start:end]),
-				),
-			)
+		timeElapsed := time.Since(startTime)
+
+		if timeElapsed < targetTimeLowerBound {
+			start = mid + 1
+		} else if timeElapsed > targetTimeUpperBound {
+			end = mid - 1
+		} else {
+			bestTime = timeElapsed
+			found = true
+			break
 		}
-		break
 	}
+
+	if !found {
+		b.Errorf("failed to find a tx count that falls within the target time window")
+		return
+	}
+
+	b.ReportMetric(bestTime.Seconds(), fmt.Sprintf("process_proposal_time(ms)"))
+	b.ReportMetric(float64(len(processProposalReq.Txs)), "num_txs")
+	b.ReportMetric(float64(size), "blob_size(bytes)")
+	b.ReportMetric(calculateBlockSizeInMb(processProposalReq.Txs), "block_size(mb)")
 }
 
 // generatePayForBlobTransactions creates a test app then generates a number
diff --git a/app/benchmarks/gas_estimator_test.go b/app/benchmarks/gas_estimator_test.go
index 18f49b14..25cdc252 100644
--- a/app/benchmarks/gas_estimator_test.go
+++ b/app/benchmarks/gas_estimator_test.go
@@ -1,4 +1,4 @@
-//go:build bench_gas_estimation
+//go:build benchmarks
 
 package benchmarks_test
 
@@ -6,31 +6,32 @@ import (
 	"context"
 	"testing"
 
+	"github.com/cometbft/cometbft/rpc/client"
+	rpctypes "github.com/cometbft/cometbft/rpc/core/types"
+	"github.com/cometbft/cometbft/types"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+
+	"github.com/celestiaorg/go-square/v2/share"
+
 	"github.com/celestiaorg/celestia-app/v4/app"
 	"github.com/celestiaorg/celestia-app/v4/app/encoding"
 	"github.com/celestiaorg/celestia-app/v4/app/grpc/gasestimation"
-	"github.com/celestiaorg/celestia-app/v4/pkg/appconsts"
 	"github.com/celestiaorg/celestia-app/v4/pkg/user"
 	testutil "github.com/celestiaorg/celestia-app/v4/test/util"
 	"github.com/celestiaorg/celestia-app/v4/test/util/blobfactory"
+	"github.com/celestiaorg/celestia-app/v4/test/util/random"
 	"github.com/celestiaorg/celestia-app/v4/test/util/testfactory"
 	blobtypes "github.com/celestiaorg/celestia-app/v4/x/blob/types"
-	"github.com/celestiaorg/go-square/v2/share"
-	"github.com/cosmos/cosmos-sdk/crypto/keyring"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/stretchr/testify/require"
-	tmrand "github.com/tendermint/tendermint/libs/rand"
-	"github.com/tendermint/tendermint/rpc/client"
-	rpctypes "github.com/tendermint/tendermint/rpc/core/types"
-	"github.com/tendermint/tendermint/types"
 )
 
 func BenchmarkGasPriceEstimation(b *testing.B) {
-	encfg := encoding.MakeConfig(app.ModuleEncodingRegisters...)
+	encfg := encoding.MakeTestConfig(app.ModuleEncodingRegisters...)
 	accounts := testfactory.GenerateAccounts(1)
 	testApp, kr := testutil.SetupTestAppWithGenesisValSet(app.DefaultConsensusParams(), accounts...)
 	infos := queryAccountInfo(testApp, accounts, kr)
-	signer, err := user.NewSigner(kr, encfg.TxConfig, testutil.ChainID, appconsts.LatestVersion, user.NewAccount(accounts[0], infos[0].AccountNum, infos[0].Sequence))
+	signer, err := user.NewSigner(kr, encfg.TxConfig, testutil.ChainID, user.NewAccount(accounts[0], infos[0].AccountNum, infos[0].Sequence))
 	require.NoError(b, err)
 
 	// 8 mb block
@@ -82,7 +83,7 @@ func BenchmarkGasPriceEstimation(b *testing.B) {
 }
 
 func generateRandomPFBs(b *testing.B, signer *user.Signer, account string, numberOfTransactions int, blobSize int) []types.Tx {
-	rand := tmrand.NewRand()
+	rand := random.New()
 	gasLimit := blobtypes.DefaultEstimateGas([]uint32{uint32(blobSize)})
 	blobs := blobfactory.ManyBlobs(rand, []share.Namespace{share.RandomBlobNamespace()}, []int{blobSize})
 	txs := make([]types.Tx, numberOfTransactions)
diff --git a/test/multiplexer/multiplexer_test.go b/test/multiplexer/multiplexer_test.go
index a7449391..feae0f4f 100644
--- a/test/multiplexer/multiplexer_test.go
+++ b/test/multiplexer/multiplexer_test.go
@@ -4,13 +4,14 @@ package nova
 
 import (
 	"bytes"
-	"github.com/stretchr/testify/require"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func TestMultiplexerSetup(t *testing.T) {
@@ -70,5 +71,5 @@ func copyFile(src, dst string) error {
 	if err != nil {
 		return err
 	}
-	return os.WriteFile(dst, input, 0777)
+	return os.WriteFile(dst, input, 0o777)
 }
diff --git a/test/util/common.go b/test/util/common.go
index 1325e862..4d72ae90 100644
--- a/test/util/common.go
+++ b/test/util/common.go
@@ -1,110 +1,21 @@
 package util
 
 import (
-	"bytes"
-	"testing"
-	"time"
-
-	"cosmossdk.io/log"
-	"cosmossdk.io/math"
-	"cosmossdk.io/store"
-	"cosmossdk.io/store/metrics"
-	storetypes "cosmossdk.io/store/types"
-	tmed "github.com/cometbft/cometbft/crypto/ed25519"
-	tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
-	tmversion "github.com/cometbft/cometbft/proto/tendermint/version"
-	dbm "github.com/cosmos/cosmos-db"
 	"github.com/cosmos/cosmos-sdk/codec"
 	ccodec "github.com/cosmos/cosmos-sdk/crypto/codec"
-	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	ccrypto "github.com/cosmos/cosmos-sdk/crypto/types"
-	"github.com/cosmos/cosmos-sdk/runtime"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
-	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
-	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	"github.com/cosmos/cosmos-sdk/x/bank"
-	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
-	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	"github.com/cosmos/cosmos-sdk/x/distribution"
-	distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper"
-	distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types"
 	"github.com/cosmos/cosmos-sdk/x/params"
-	paramstypes "github.com/cosmos/cosmos-sdk/x/params/types"
-	slashingkeeper "github.com/cosmos/cosmos-sdk/x/slashing/keeper"
-	slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types"
 	"github.com/cosmos/cosmos-sdk/x/staking"
-	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
-	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
-	gethcommon "github.com/ethereum/go-ethereum/common"
-	"github.com/stretchr/testify/require"
 
-	"github.com/celestiaorg/celestia-app/v4/app"
-	"github.com/celestiaorg/celestia-app/v4/app/encoding"
-	appparams "github.com/celestiaorg/celestia-app/v4/app/params"
 	"github.com/celestiaorg/celestia-app/v4/x/blob"
 )
 
-// TODO: This probably should be deleted.
-var blobstreamModuleName = "blobstream"
-
 var (
-	// TestingStakeParams is a set of staking params for testing
-	TestingStakeParams = stakingtypes.Params{
-		UnbondingTime:     100,
-		MaxValidators:     10,
-		MaxEntries:        10,
-		HistoricalEntries: 10000,
-		BondDenom:         "stake",
-		MinCommissionRate: math.LegacyNewDecWithPrec(0, 0),
-	}
-
-	// HardcodedConsensusPrivKeys
-	FixedConsensusPrivKeys = []tmed.PrivKey{
-		tmed.GenPrivKeyFromSecret([]byte("12345678901234567890123456389012")),
-		tmed.GenPrivKeyFromSecret([]byte("12345678901234567890123456389013")),
-		tmed.GenPrivKeyFromSecret([]byte("12345678901234567890123456389014")),
-		tmed.GenPrivKeyFromSecret([]byte("12345678901234567890123456389015")),
-		tmed.GenPrivKeyFromSecret([]byte("12345678901234567890123456389016")),
-	}
-
-	FixedNetworkPrivKeys = []tmed.PrivKey{
-		tmed.GenPrivKeyFromSecret([]byte("12345678901234567890123456786012")),
-		tmed.GenPrivKeyFromSecret([]byte("12345678901234567890123456786013")),
-		tmed.GenPrivKeyFromSecret([]byte("12345678901234567890123456786014")),
-		tmed.GenPrivKeyFromSecret([]byte("12345678901234567890123456786015")),
-		tmed.GenPrivKeyFromSecret([]byte("12345678901234567890123456786016")),
-	}
-
-	// FixedMnemonics is a set of fixed mnemonics for testing.
-	// Account names are: validator1, validator2, validator3, validator4, validator5
-	FixedMnemonics = []string{
-		"body world north giggle crop reduce height copper damp next verify orphan lens loan adjust inform utility theory now ranch motion opinion crowd fun",
-		"body champion street fat bone above office guess waste vivid gift around approve elevator depth fiber alarm usual skirt like organ space antique silk",
-		"cheap alpha render punch clap prize duty drive steel situate person radar smooth elegant over chronic wait danger thumb soft letter spatial acquire rough",
-		"outdoor ramp suspect office disagree world attend vanish small wish capable fall wall soon damp session emotion chest toss viable meat host clerk truth",
-		"ability evidence casino cram weasel chest brush bridge sister blur onion found glad own mansion amateur expect force fun dragon famous alien appear open",
-	}
-
-	// ConsPrivKeys generate ed25519 ConsPrivKeys to be used for validator operator keys
-	ConsPrivKeys = []ccrypto.PrivKey{
-		ed25519.GenPrivKey(),
-		ed25519.GenPrivKey(),
-		ed25519.GenPrivKey(),
-		ed25519.GenPrivKey(),
-		ed25519.GenPrivKey(),
-	}
-
-	// ConsPubKeys holds the consensus public keys to be used for validator operator keys
-	ConsPubKeys = []ccrypto.PubKey{
-		ConsPrivKeys[0].PubKey(),
-		ConsPrivKeys[1].PubKey(),
-		ConsPrivKeys[2].PubKey(),
-		ConsPrivKeys[3].PubKey(),
-		ConsPrivKeys[4].PubKey(),
-	}
-
 	// AccPrivKeys generate secp256k1 pubkeys to be used for account pub keys
 	AccPrivKeys = []ccrypto.PrivKey{
 		secp256k1.GenPrivKey(),
@@ -123,15 +34,6 @@ var (
 		AccPrivKeys[4].PubKey(),
 	}
 
-	// AccAddrs holds the sdk.AccAddresses
-	AccAddrs = []sdk.AccAddress{
-		sdk.AccAddress(AccPubKeys[0].Address()),
-		sdk.AccAddress(AccPubKeys[1].Address()),
-		sdk.AccAddress(AccPubKeys[2].Address()),
-		sdk.AccAddress(AccPubKeys[3].Address()),
-		sdk.AccAddress(AccPubKeys[4].Address()),
-	}
-
 	// ValAddrs holds the sdk.ValAddresses
 	ValAddrs = []sdk.ValAddress{
 		sdk.ValAddress(AccPubKeys[0].Address()),
@@ -140,220 +42,8 @@ var (
 		sdk.ValAddress(AccPubKeys[3].Address()),
 		sdk.ValAddress(AccPubKeys[4].Address()),
 	}
-
-	// EVMAddrs holds etheruem addresses
-	EVMAddrs = initEVMAddrs(100)
-
-	// InitTokens holds the number of tokens to initialize an account with
-	InitTokens = sdk.TokensFromConsensusPower(110, sdk.DefaultPowerReduction)
-
-	// InitCoins holds the number of coins to initialize an account with
-	InitCoins = sdk.NewCoins(sdk.NewCoin(TestingStakeParams.BondDenom, InitTokens))
-
-	// StakingAmount holds the staking power to start a validator with
-	StakingAmount = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
 )
 
-func initEVMAddrs(count int) []gethcommon.Address {
-	addresses := make([]gethcommon.Address, count)
-	for i := 0; i < count; i++ {
-		evmAddr := gethcommon.BytesToAddress(bytes.Repeat([]byte{byte(i + 1)}, gethcommon.AddressLength))
-		addresses[i] = evmAddr
-	}
-	return addresses
-}
-
-// TestInput stores the various keepers required to test Blobstream
-type TestInput struct {
-	AuthKeeper     authkeeper.AccountKeeper
-	StakingKeeper  *stakingkeeper.Keeper
-	SlashingKeeper slashingkeeper.Keeper
-	DistKeeper     distrkeeper.Keeper
-	BankKeeper     bankkeeper.BaseKeeper
-	Context        sdk.Context
-	Codec          codec.Codec
-	LegacyAmino    *codec.LegacyAmino
-}
-
-// CreateTestEnv creates the keeper testing environment
-func CreateTestEnv(t *testing.T) TestInput {
-	t.Helper()
-
-	// Initialize store keys
-	keyAuth := storetypes.NewKVStoreKey(authtypes.StoreKey)
-	keyStaking := storetypes.NewKVStoreKey(stakingtypes.StoreKey)
-	keyBank := storetypes.NewKVStoreKey(banktypes.StoreKey)
-	keyDistribution := storetypes.NewKVStoreKey(distrtypes.StoreKey)
-	keyParams := storetypes.NewKVStoreKey(paramstypes.StoreKey)
-	tkeyParams := storetypes.NewTransientStoreKey(paramstypes.TStoreKey)
-	keySlashing := storetypes.NewKVStoreKey(slashingtypes.StoreKey)
-
-	// Initialize memory database and mount stores on it
-	db := dbm.NewMemDB()
-	ms := store.NewCommitMultiStore(db, log.NewNopLogger(), metrics.NewNoOpMetrics())
-	ms.MountStoreWithDB(keyAuth, storetypes.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(keyParams, storetypes.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(keyStaking, storetypes.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(keyBank, storetypes.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(keyDistribution, storetypes.StoreTypeIAVL, db)
-	ms.MountStoreWithDB(tkeyParams, storetypes.StoreTypeTransient, db)
-	ms.MountStoreWithDB(keySlashing, storetypes.StoreTypeIAVL, db)
-	err := ms.LoadLatestVersion()
-	require.NoError(t, err)
-
-	header := tmproto.Header{
-		Version: tmversion.Consensus{
-			Block: 0,
-			App:   0,
-		},
-		ChainID: "",
-		Height:  1234567,
-		Time:    time.Date(2020, time.April, 22, 12, 0, 0, 0, time.UTC),
-		LastBlockId: tmproto.BlockID{
-			Hash: []byte{},
-			PartSetHeader: tmproto.PartSetHeader{
-				Total: 0,
-				Hash:  []byte{},
-			},
-		},
-		LastCommitHash:     []byte{},
-		DataHash:           []byte{},
-		ValidatorsHash:     []byte{},
-		NextValidatorsHash: []byte{},
-		ConsensusHash:      []byte{},
-		AppHash:            []byte{},
-		LastResultsHash:    []byte{},
-		EvidenceHash:       []byte{},
-		ProposerAddress:    []byte{},
-	}
-	ctx := sdk.NewContext(ms, header, false, log.NewTestLogger(t))
-
-	aminoCdc := MakeAminoCodec()
-	cdc := encoding.MakeTestConfig(app.ModuleEncodingRegisters...).Codec
-	authority := authtypes.NewModuleAddress("gov")
-
-	// this is also used to initialize module accounts for all the map keys
-	moduleAccountPermissions := map[string][]string{
-		authtypes.FeeCollectorName:     nil,
-		distrtypes.ModuleName:          nil,
-		stakingtypes.BondedPoolName:    {authtypes.Burner, authtypes.Staking},
-		stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking},
-	}
-
-	enc := encoding.MakeTestConfig(app.ModuleEncodingRegisters...)
-	authKeeper := authkeeper.NewAccountKeeper(
-		cdc,
-		runtime.NewKVStoreService(keyAuth),
-		authtypes.ProtoBaseAccount, // prototype
-		moduleAccountPermissions,
-		enc.AddressCodec,
-		appparams.Bech32PrefixAccAddr,
-		authority.String(),
-	)
-
-	blockedAddr := make(map[string]bool, len(moduleAccountPermissions))
-	for acc := range moduleAccountPermissions {
-		blockedAddr[authtypes.NewModuleAddress(acc).String()] = true
-	}
-	bankKeeper := bankkeeper.NewBaseKeeper(
-		cdc,
-		runtime.NewKVStoreService(keyBank),
-		authKeeper,
-		blockedAddr,
-		authority.String(),
-		log.NewNopLogger(),
-	)
-	if err := bankKeeper.SetParams(
-		ctx,
-		banktypes.Params{
-			SendEnabled:        []*banktypes.SendEnabled{},
-			DefaultSendEnabled: true,
-		},
-	); err != nil {
-		panic(err)
-	}
-
-	stakingKeeper := stakingkeeper.NewKeeper(
-		cdc,
-		runtime.NewKVStoreService(keyStaking),
-		authKeeper,
-		bankKeeper,
-		authority.String(),
-		enc.ValidatorAddressCodec,
-		enc.ConsensusAddressCodec,
-	)
-	if err := stakingKeeper.SetParams(ctx, TestingStakeParams); err != nil {
-		panic(err)
-	}
-
-	distKeeper := distrkeeper.NewKeeper(
-		cdc,
-		runtime.NewKVStoreService(keyDistribution),
-		authKeeper,
-		bankKeeper,
-		stakingKeeper,
-		authtypes.FeeCollectorName,
-		authority.String(),
-	)
-	if err := distKeeper.Params.Set(ctx, distrtypes.DefaultParams()); err != nil {
-		panic(err)
-	}
-	if err := distKeeper.FeePool.Set(ctx, distrtypes.InitialFeePool()); err != nil {
-		panic(err)
-	}
-
-	// set up initial accounts
-	for name, permissions := range moduleAccountPermissions {
-		moduleAccount := authtypes.NewEmptyModuleAccount(name, permissions...)
-		totalSupply := sdk.NewCoins(sdk.NewInt64Coin("stake", 100000000))
-		switch name {
-		case stakingtypes.NotBondedPoolName:
-			err = bankKeeper.MintCoins(ctx, blobstreamModuleName, totalSupply)
-			require.NoError(t, err)
-			err = bankKeeper.SendCoinsFromModuleToModule(ctx, blobstreamModuleName, moduleAccount.Name, totalSupply)
-			require.NoError(t, err)
-		case distrtypes.ModuleName:
-			// some big pot to pay out
-			amt := sdk.NewCoins(sdk.NewInt64Coin("stake", 500000))
-			err = bankKeeper.MintCoins(ctx, blobstreamModuleName, amt)
-			require.NoError(t, err)
-			err = bankKeeper.SendCoinsFromModuleToModule(ctx, blobstreamModuleName, moduleAccount.Name, amt)
-			require.NoError(t, err)
-		}
-		authKeeper.SetModuleAccount(ctx, moduleAccount)
-	}
-
-	stakeAddr := authtypes.NewModuleAddress(stakingtypes.BondedPoolName)
-	moduleAcct := authKeeper.GetAccount(ctx, stakeAddr)
-	require.NotNil(t, moduleAcct)
-
-	slashingKeeper := slashingkeeper.NewKeeper(
-		cdc,
-		aminoCdc,
-		runtime.NewKVStoreService(keySlashing),
-		stakingKeeper,
-		authority.String(),
-	)
-
-	stakingKeeper.SetHooks(
-		stakingtypes.NewMultiStakingHooks(
-			distKeeper.Hooks(),
-			slashingKeeper.Hooks(),
-		),
-	)
-
-	return TestInput{
-		AuthKeeper:     authKeeper,
-		BankKeeper:     bankKeeper,
-		StakingKeeper:  stakingKeeper,
-		SlashingKeeper: slashingKeeper,
-		DistKeeper:     distKeeper,
-		Context:        ctx,
-		Codec:          cdc,
-		LegacyAmino:    aminoCdc,
-	}
-}
-
 // MakeAminoCodec creates a legacy amino codec for testing
 func MakeAminoCodec() *codec.LegacyAmino {
 	cdc := codec.NewLegacyAmino()
@@ -367,142 +57,3 @@ func MakeAminoCodec() *codec.LegacyAmino {
 	blob.AppModule{}.RegisterLegacyAminoCodec(cdc)
 	return cdc
 }
-
-// SetupFiveValChain does all the initialization for a 5 Validator chain using the keys here
-func SetupFiveValChain(t *testing.T) (TestInput, sdk.Context) {
-	t.Helper()
-	input := CreateTestEnv(t)
-
-	// Set the params for our modules
-	if err := input.StakingKeeper.SetParams(input.Context, TestingStakeParams); err != nil {
-		panic(err)
-	}
-
-	// Initialize each of the validators
-	for i := range []int{0, 1, 2, 3, 4} {
-		CreateValidator(t, input, AccAddrs[i], AccPubKeys[i], uint64(i), ValAddrs[i], ConsPubKeys[i], StakingAmount)
-	}
-
-	// Run the staking endblocker to ensure valset is correct in state
-	_, err := input.StakingKeeper.EndBlocker(input.Context)
-	require.NoError(t, err)
-
-	// Return the test input
-	return input, input.Context
-}
-
-func CreateValidator(
-	t *testing.T,
-	input TestInput,
-	accAddr sdk.AccAddress,
-	accPubKey ccrypto.PubKey,
-	accountNumber uint64,
-	valAddr sdk.ValAddress,
-	consPubKey ccrypto.PubKey,
-	stakingAmount math.Int,
-) {
-	// Initialize the account for the key
-	acc := input.AuthKeeper.NewAccount(
-		input.Context,
-		authtypes.NewBaseAccount(accAddr, accPubKey, accountNumber, 0),
-	)
-
-	// Set the balance for the account
-	require.NoError(t, input.BankKeeper.MintCoins(input.Context, blobstreamModuleName, InitCoins))
-	err := input.BankKeeper.SendCoinsFromModuleToAccount(input.Context, blobstreamModuleName, acc.GetAddress(), InitCoins)
-	require.NoError(t, err)
-
-	// Set the account in state
-	input.AuthKeeper.SetAccount(input.Context, acc)
-
-	// Create a validator for that account using some tokens in the account
-	// and the staking handler
-	msgServer := stakingkeeper.NewMsgServerImpl(input.StakingKeeper)
-	_, err = msgServer.CreateValidator(input.Context, NewTestMsgCreateValidator(valAddr, consPubKey, stakingAmount))
-	require.NoError(t, err)
-}
-
-func NewTestMsgCreateValidator(
-	address sdk.ValAddress,
-	pubKey ccrypto.PubKey,
-	amt math.Int,
-) *stakingtypes.MsgCreateValidator {
-	commission := stakingtypes.NewCommissionRates(math.LegacyZeroDec(), math.LegacyZeroDec(), math.LegacyZeroDec())
-	out, err := stakingtypes.NewMsgCreateValidator(
-		address.String(), pubKey, sdk.NewCoin("stake", amt),
-		stakingtypes.Description{
-			Moniker:         "",
-			Identity:        "",
-			Website:         "",
-			SecurityContact: "",
-			Details:         "",
-		}, commission, math.OneInt(),
-	)
-	if err != nil {
-		panic(err)
-	}
-	return out
-}
-
-// SetupTestChain sets up a test environment with the provided validator voting weights
-func SetupTestChain(t *testing.T, weights []uint64) (TestInput, sdk.Context) {
-	t.Helper()
-	input := CreateTestEnv(t)
-
-	// Set the params for our modules
-	TestingStakeParams.MaxValidators = 100
-	if err := input.StakingKeeper.SetParams(input.Context, TestingStakeParams); err != nil {
-		panic(err)
-	}
-
-	// Initialize each of the validators
-	stakingMsgServer := stakingkeeper.NewMsgServerImpl(input.StakingKeeper)
-	for i, weight := range weights {
-		consPrivKey := ed25519.GenPrivKey()
-		consPubKey := consPrivKey.PubKey()
-		valPrivKey := secp256k1.GenPrivKey()
-		valPubKey := valPrivKey.PubKey()
-		valAddr := sdk.ValAddress(valPubKey.Address())
-		accAddr := sdk.AccAddress(valPubKey.Address())
-
-		// Initialize the account for the key
-		acc := input.AuthKeeper.NewAccount(
-			input.Context,
-			authtypes.NewBaseAccount(accAddr, valPubKey, uint64(i), 0),
-		)
-
-		// Set the balance for the account
-		weightCoins := sdk.NewCoins(sdk.NewInt64Coin(TestingStakeParams.BondDenom, int64(weight)))
-		require.NoError(t, input.BankKeeper.MintCoins(input.Context, blobstreamModuleName, weightCoins))
-		require.NoError(t, input.BankKeeper.SendCoinsFromModuleToAccount(input.Context, blobstreamModuleName, accAddr, weightCoins))
-
-		// Set the account in state
-		input.AuthKeeper.SetAccount(input.Context, acc)
-
-		// Create a validator for that account using some of the tokens in the account
-		// and the staking handler
-		_, err := stakingMsgServer.CreateValidator(
-			input.Context,
-			NewTestMsgCreateValidator(valAddr, consPubKey, math.NewIntFromUint64(weight)),
-		)
-		require.NoError(t, err)
-
-		// Run the staking endblocker to ensure valset is correct in state
-		_, err = input.StakingKeeper.EndBlocker(input.Context)
-		require.NoError(t, err)
-	}
-
-	// some inputs can cause the validator creation not to work, this checks that
-	// everything was successful
-	validators, err := input.StakingKeeper.GetBondedValidatorsByPower(input.Context)
-	require.NoError(t, err)
-	require.Equal(t, len(weights), len(validators))
-
-	// Return the test input
-	return input, input.Context
-}
-
-func NewTestMsgUnDelegateValidator(address sdk.ValAddress, amt math.Int) *stakingtypes.MsgUndelegate {
-	msg := stakingtypes.NewMsgUndelegate(sdk.AccAddress(address).String(), address.String(), sdk.NewCoin("stake", amt))
-	return msg
-}
diff --git a/test/util/test_app.go b/test/util/test_app.go
index bd4ebf20..b7230b32 100644
--- a/test/util/test_app.go
+++ b/test/util/test_app.go
@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 	"strings"
-	"testing"
 	"time"
 
 	"cosmossdk.io/log"
@@ -16,26 +15,20 @@ import (
 	tmtypes "github.com/cometbft/cometbft/types"
 	dbm "github.com/cosmos/cosmos-db"
 	"github.com/cosmos/cosmos-sdk/baseapp"
-	"github.com/cosmos/cosmos-sdk/codec"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
-	"github.com/cosmos/cosmos-sdk/crypto/hd"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
-	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	simulationcli "github.com/cosmos/cosmos-sdk/x/simulation/client/cli"
-	slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 	"github.com/rs/zerolog"
-	"github.com/stretchr/testify/require"
 
 	"github.com/celestiaorg/celestia-app/v4/app"
 	"github.com/celestiaorg/celestia-app/v4/app/params"
 	"github.com/celestiaorg/celestia-app/v4/pkg/appconsts"
-	"github.com/celestiaorg/celestia-app/v4/test/util/genesis"
 	"github.com/celestiaorg/celestia-app/v4/test/util/testfactory"
 	"github.com/celestiaorg/celestia-app/v4/test/util/testnode"
 )
@@ -112,91 +105,6 @@ func NewTestApp() *app.App {
 	)
 }
 
-// SetupDeterministicGenesisState sets genesis on initialized testApp with the provided arguments.
-func SetupDeterministicGenesisState(testApp *app.App, pubKeys []cryptotypes.PubKey, balance int64, cparams *tmproto.ConsensusParams) (keyring.Keyring, []genesis.Account, error) {
-	slashingParams := slashingtypes.NewParams(2, math.LegacyOneDec(), time.Minute, math.LegacyOneDec(), math.LegacyOneDec())
-
-	// Create genesis
-	gen := genesis.NewDefaultGenesis().
-		WithChainID(ChainID).
-		WithConsensusParams(cparams).
-		WithModifiers(genesis.SetSlashingParams(testApp.AppCodec(), slashingParams)).
-		WithGenesisTime(GenesisTime)
-
-	// Add accounts to genesis
-	for i, pk := range pubKeys {
-		err := gen.AddAccount(genesis.Account{
-			PubKey:  pk,
-			Balance: balance,
-			Name:    fmt.Sprintf("%v", i),
-		})
-		if err != nil {
-			return nil, nil, err
-		}
-	}
-
-	// Add validators to genesis
-	err := AddDeterministicValidatorsToGenesis(gen)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to add validator: %w", err)
-	}
-
-	genDoc, err := gen.Export()
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to export genesis doc: %w", err)
-	}
-
-	// Initialise test app against genesis
-	_, err = testApp.Info(&abci.RequestInfo{})
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to get app info: %w", err)
-	}
-
-	abciParams := &tmproto.ConsensusParams{
-		Block: &tmproto.BlockParams{
-			// Choose some value large enough to not bottleneck the max square
-			// size
-			MaxBytes: int64(appconsts.DefaultUpperBoundMaxBytes),
-			MaxGas:   cparams.Block.MaxGas,
-		},
-		Evidence:  cparams.Evidence,
-		Validator: cparams.Validator,
-		Version:   cparams.Version,
-	}
-
-	// Init chain will set the validator set and initialize the genesis accounts
-	_, err = testApp.InitChain(
-		&abci.RequestInitChain{
-			Time:            gen.GenesisTime,
-			Validators:      []abci.ValidatorUpdate{},
-			ConsensusParams: abciParams,
-			AppStateBytes:   genDoc.AppState,
-			ChainId:         genDoc.ChainID,
-		},
-	)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to init chain: %w", err)
-	}
-
-	// Commit genesis changes
-	_, err = testApp.FinalizeBlock(&abci.RequestFinalizeBlock{
-		Height:             testApp.LastBlockHeight() + 1,
-		Hash:               testApp.LastCommitID().Hash,
-		NextValidatorsHash: genDoc.ValidatorHash(),
-		Time:               gen.GenesisTime,
-	})
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to finalize block: %w", err)
-	}
-
-	_, err = testApp.Commit()
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to commit: %w", err)
-	}
-
-	return gen.Keyring(), gen.Accounts(), nil
-}
-
 // NewTestAppWithGenesisSet initializes a new app with genesis accounts and returns the testApp, validator set and keyring.
 func NewTestAppWithGenesisSet(cparams *tmproto.ConsensusParams, genAccounts ...string) (*app.App, *tmtypes.ValidatorSet, keyring.Keyring) {
 	testApp := NewTestApp()
@@ -250,112 +158,6 @@ func InitialiseTestAppWithGenesis(testApp *app.App, cparams *tmproto.ConsensusPa
 	return testApp
 }
 
-// AddDeterministicValidatorsToGenesis adds a set of five validators to the genesis.
-func AddDeterministicValidatorsToGenesis(g *genesis.Genesis) error {
-	for i := range FixedMnemonics {
-		val := genesis.Validator{
-			KeyringAccount: genesis.KeyringAccount{
-				Name:          "validator" + fmt.Sprint(i),
-				InitialTokens: 5_000_000_000,
-			},
-			Stake:        1_000_000_000,
-			ConsensusKey: FixedConsensusPrivKeys[i],
-			NetworkKey:   FixedNetworkPrivKeys[i],
-		}
-
-		// Initialize the validator's genesis account in the keyring
-		rec, err := g.Keyring().NewAccount(val.Name, FixedMnemonics[i], "", "", hd.Secp256k1)
-		if err != nil {
-			return fmt.Errorf("failed to create account: %w", err)
-		}
-
-		validatorPubKey, err := rec.GetPubKey()
-		if err != nil {
-			return fmt.Errorf("failed to get pubkey: %w", err)
-		}
-
-		// Construct account from keyring account
-		account := genesis.Account{
-			PubKey:  validatorPubKey,
-			Balance: val.InitialTokens,
-			Name:    val.Name,
-		}
-
-		// Add the validator's account to the genesis
-		if err := g.AddAccount(account); err != nil {
-			return fmt.Errorf("failed to add account: %w", err)
-		}
-		if err := g.AddValidator(val); err != nil {
-			return fmt.Errorf("failed to add validator: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// AddAccount mimics the cli addAccount command, providing an
-// account with an allocation of to "token" and "tia" tokens in the genesis
-// state
-func AddAccount(addr sdk.AccAddress, appState app.GenesisState, cdc codec.Codec) (map[string]json.RawMessage, error) {
-	// create concrete account type based on input parameters
-	var genAccount authtypes.GenesisAccount
-
-	coins := sdk.Coins{
-		sdk.NewCoin("token", math.NewInt(1000000)),
-		sdk.NewCoin(params.BondDenom, math.NewInt(1000000)),
-	}
-
-	balances := banktypes.Balance{Address: addr.String(), Coins: coins.Sort()}
-	baseAccount := authtypes.NewBaseAccount(addr, nil, 0, 0)
-
-	genAccount = baseAccount
-
-	if err := genAccount.Validate(); err != nil {
-		return appState, fmt.Errorf("failed to validate new genesis account: %w", err)
-	}
-
-	authGenState := authtypes.GetGenesisStateFromAppState(cdc, appState)
-
-	accs, err := authtypes.UnpackAccounts(authGenState.Accounts)
-	if err != nil {
-		return appState, fmt.Errorf("failed to get accounts from any: %w", err)
-	}
-
-	if accs.Contains(addr) {
-		return appState, fmt.Errorf("cannot add account at existing address %s", addr)
-	}
-
-	// Add the new account to the set of genesis accounts and sanitize the
-	// accounts afterwards.
-	accs = append(accs, genAccount)
-	accs = authtypes.SanitizeGenesisAccounts(accs)
-
-	genAccs, err := authtypes.PackAccounts(accs)
-	if err != nil {
-		return appState, fmt.Errorf("failed to convert accounts into any's: %w", err)
-	}
-	authGenState.Accounts = genAccs
-
-	authGenStateBz, err := cdc.MarshalJSON(&authGenState)
-	if err != nil {
-		return appState, fmt.Errorf("failed to marshal auth genesis state: %w", err)
-	}
-
-	appState[authtypes.ModuleName] = authGenStateBz
-
-	bankGenState := banktypes.GetGenesisStateFromAppState(cdc, appState)
-	bankGenState.Balances = append(bankGenState.Balances, balances)
-	bankGenState.Balances = banktypes.SanitizeGenesisBalances(bankGenState.Balances)
-
-	bankGenStateBz, err := cdc.MarshalJSON(bankGenState)
-	if err != nil {
-		return appState, fmt.Errorf("failed to marshal bank genesis state: %w", err)
-	}
-
-	appState[banktypes.ModuleName] = bankGenStateBz
-	return appState, nil
-}
-
 // GenesisStateWithSingleValidator initializes GenesisState with a single
 // validator and genesis accounts that also act as delegators.
 func GenesisStateWithSingleValidator(testApp *app.App, genAccounts ...string) (app.GenesisState, *tmtypes.ValidatorSet, keyring.Keyring) {
@@ -471,52 +273,3 @@ func genesisStateWithValSet(
 
 	return genesisState
 }
-
-func SetupTestApp(t *testing.T) (*app.App, keyring.Keyring) {
-	t.Helper()
-
-	db := dbm.NewMemDB()
-	chainID := "test_chain"
-	testApp := app.New(log.NewNopLogger(), db, nil, 0, EmptyAppOptions{}, baseapp.SetChainID(chainID))
-	genesisState, _, kr := GenesisStateWithSingleValidator(testApp, "account")
-	stateBytes, err := json.MarshalIndent(genesisState, "", " ")
-	require.NoError(t, err)
-	infoResp, err := testApp.Info(&abci.RequestInfo{})
-	require.NoError(t, err)
-
-	require.EqualValues(t, 0, infoResp.AppVersion)
-	cp := app.DefaultInitialConsensusParams()
-	abciParams := &tmproto.ConsensusParams{
-		Block: &tmproto.BlockParams{
-			MaxBytes: cp.Block.MaxBytes,
-			MaxGas:   cp.Block.MaxGas,
-		},
-		Evidence:  cp.Evidence,
-		Validator: cp.Validator,
-		Version:   cp.Version,
-	}
-
-	_, err = testApp.InitChain(
-		&abci.RequestInitChain{
-			Time:            GenesisTime,
-			Validators:      []abci.ValidatorUpdate{},
-			ConsensusParams: abciParams,
-			AppStateBytes:   stateBytes,
-			ChainId:         chainID,
-		},
-	)
-	require.NoError(t, err)
-
-	// assert that the chain starts with version provided in genesis
-	// because Info only fetch store if height > 0 (where the version is set from the consensus keeper)
-	// we just override the default baseapp height
-	baseapp.InitialAppVersion = app.DefaultInitialConsensusParams().Version.App
-
-	infoResp, err = testApp.Info(&abci.RequestInfo{})
-	require.NoError(t, err)
-	require.EqualValues(t, app.DefaultInitialConsensusParams().Version.App, infoResp.AppVersion, infoResp.String())
-
-	_, err = testApp.Commit()
-	require.NoError(t, err)
-	return testApp, kr
-}
diff --git a/test/util/testfactory/common.go b/test/util/testfactory/common.go
index b6f9f736..b8c137e4 100644
--- a/test/util/testfactory/common.go
+++ b/test/util/testfactory/common.go
@@ -8,7 +8,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/crypto/hd"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	gethcommon "github.com/ethereum/go-ethereum/common"
 
 	"github.com/celestiaorg/go-square/v2/share"
 
@@ -106,10 +105,6 @@ func GetAddress(keys keyring.Keyring, account string) sdk.AccAddress {
 	return addr
 }
 
-func RandomEVMAddress() gethcommon.Address {
-	return gethcommon.BytesToAddress(random.Bytes(gethcommon.AddressLength))
-}
-
 func TestKeyring(cdc codec.Codec, accounts ...string) keyring.Keyring {
 	kb := keyring.NewInMemory(cdc)