feat: add multi-account support

Makefile

@@ -145,7 +145,7 @@ test-race:
 # TODO: Remove the -skip flag once the following tests no longer contain data races.
 # https://github.com/celestiaorg/celestia-app/issues/1369
 	@echo "--> Running tests in race mode"
-	@go test ./... -v -race -skip "TestPrepareProposalConsistency|TestIntegrationTestSuite|TestBlobstreamRPCQueries|TestSquareSizeIntegrationTest|TestStandardSDKIntegrationTestSuite|TestTxsimCommandFlags|TestTxsimCommandEnvVar|TestMintIntegrationTestSuite|TestBlobstreamCLI|TestUpgrade|TestMaliciousTestNode|TestBigBlobSuite|TestQGBIntegrationSuite|TestSignerTestSuite|TestPriorityTestSuite|TestTimeInPrepareProposalContext|TestBlobstream|TestCLITestSuite|TestLegacyUpgrade|TestSignerTwins|TestConcurrentTxSubmission"
+	@go test ./... -v -race -skip "TestPrepareProposalConsistency|TestIntegrationTestSuite|TestBlobstreamRPCQueries|TestSquareSizeIntegrationTest|TestStandardSDKIntegrationTestSuite|TestTxsimCommandFlags|TestTxsimCommandEnvVar|TestMintIntegrationTestSuite|TestBlobstreamCLI|TestUpgrade|TestMaliciousTestNode|TestBigBlobSuite|TestQGBIntegrationSuite|TestSignerTestSuite|TestPriorityTestSuite|TestTimeInPrepareProposalContext|TestBlobstream|TestCLITestSuite|TestLegacyUpgrade|TestSignerTwins|TestConcurrentTxSubmission|TestTxClientTestSuite"
 .PHONY: test-race
 
 ## test-bench: Run unit tests in bench mode.

app/errors/insufficient_gas_price_test.go

@@ -37,22 +37,25 @@ func TestInsufficientMinGasPriceIntegration(t *testing.T) {
 	addr := testfactory.GetAddress(kr, account)
 	enc := encoding.MakeConfig(app.ModuleEncodingRegisters...)
 	acc := testutil.DirectQueryAccount(testApp, addr)
-	signer, err := user.NewSigner(kr, nil, addr, enc.TxConfig, testutil.ChainID, acc.GetAccountNumber(), acc.GetSequence(), appconsts.LatestVersion)
+	signer, err := user.NewSigner(kr, enc.TxConfig, testutil.ChainID, appconsts.LatestVersion, user.NewAccount(account, acc.GetAccountNumber(), acc.GetSequence()))
 	require.NoError(t, err)
 
 	fee := sdk.NewCoins(sdk.NewCoin(app.BondDenom, sdk.NewInt(feeAmount)))
 	b, err := blob.NewBlob(namespace.RandomNamespace(), []byte("hello world"), 0)
 	require.NoError(t, err)
 
-	msg, err := blob.NewMsgPayForBlobs(signer.Address().String(), appconsts.LatestVersion, b)
+	msg, err := blob.NewMsgPayForBlobs(signer.Account(account).Address().String(), appconsts.LatestVersion, b)
 	require.NoError(t, err)
 
-	sdkTx, err := signer.CreateTx([]sdk.Msg{msg}, user.SetGasLimit(gasLimit), user.SetFeeAmount(fee))
+	rawTx, err := signer.CreateTx([]sdk.Msg{msg}, user.SetGasLimit(gasLimit), user.SetFeeAmount(fee))
 	require.NoError(t, err)
 
 	decorator := ante.NewDeductFeeDecorator(testApp.AccountKeeper, testApp.BankKeeper, testApp.FeeGrantKeeper, nil)
 	anteHandler := sdk.ChainAnteDecorators(decorator)
 
+	sdkTx, err := signer.DecodeTx(rawTx)
+	require.NoError(t, err)
+
 	_, err = anteHandler(ctx, sdkTx, false)
 	require.True(t, apperr.IsInsufficientMinGasPrice(err))
 	actualGasPrice, err := apperr.ParseInsufficientMinGasPrice(err, gasPrice, gasLimit)

app/errors/nonce_mismatch_test.go

@@ -32,21 +32,24 @@ func TestNonceMismatchIntegration(t *testing.T) {
 	enc := encoding.MakeConfig(app.ModuleEncodingRegisters...)
 	acc := testutil.DirectQueryAccount(testApp, addr)
 	// set the sequence to an incorrect value
-	signer, err := user.NewSigner(kr, nil, addr, enc.TxConfig, testutil.ChainID, acc.GetAccountNumber(), 2, appconsts.LatestVersion)
+	signer, err := user.NewSigner(kr, enc.TxConfig, testutil.ChainID, appconsts.LatestVersion, user.NewAccount(account, acc.GetAccountNumber(), acc.GetSequence()+1))
 	require.NoError(t, err)
 
 	b, err := blob.NewBlob(namespace.RandomNamespace(), []byte("hello world"), 0)
 	require.NoError(t, err)
 
-	msg, err := blob.NewMsgPayForBlobs(signer.Address().String(), appconsts.LatestVersion, b)
+	msg, err := blob.NewMsgPayForBlobs(signer.Account(account).Address().String(), appconsts.LatestVersion, b)
 	require.NoError(t, err)
 
-	sdkTx, err := signer.CreateTx([]sdk.Msg{msg})
+	rawTx, err := signer.CreateTx([]sdk.Msg{msg})
 	require.NoError(t, err)
 
 	decorator := ante.NewSigVerificationDecorator(testApp.AccountKeeper, encCfg.TxConfig.SignModeHandler())
 	anteHandler := sdk.ChainAnteDecorators(decorator)
 
+	sdkTx, err := signer.DecodeTx(rawTx)
+	require.NoError(t, err)
+
 	// We set simulate to true here to bypass having to initialize the
 	// accounts public key.
 	_, err = anteHandler(ctx, sdkTx, true)

app/test/big_blob_test.go

@@ -73,14 +73,14 @@ func (s *BigBlobSuite) TestErrBlobsTooLarge() {
 		},
 	}
 
-	signer, err := testnode.NewSignerFromContext(s.cctx, s.accounts[0])
+	txClient, err := testnode.NewTxClientFromContext(s.cctx)
 	require.NoError(t, err)
 
 	for _, tc := range testCases {
 		s.Run(tc.name, func() {
 			subCtx, cancel := context.WithTimeout(s.cctx.GoContext(), 30*time.Second)
 			defer cancel()
-			res, err := signer.SubmitPayForBlob(subCtx, []*blob.Blob{tc.blob}, user.SetGasLimitAndFee(1e9, appconsts.DefaultMinGasPrice))
+			res, err := txClient.SubmitPayForBlob(subCtx, []*blob.Blob{tc.blob}, user.SetGasLimitAndFee(1e9, appconsts.DefaultMinGasPrice))
 			require.Error(t, err)
 			require.NotNil(t, res)
 			require.Equal(t, tc.want, res.Code, res.Logs)

app/test/check_tx_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/celestiaorg/celestia-app/v2/pkg/user"
 	testutil "github.com/celestiaorg/celestia-app/v2/test/util"
 	"github.com/celestiaorg/celestia-app/v2/test/util/blobfactory"
-	"github.com/celestiaorg/celestia-app/v2/test/util/testfactory"
 	blobtypes "github.com/celestiaorg/celestia-app/v2/x/blob/types"
 	"github.com/celestiaorg/go-square/blob"
 	appns "github.com/celestiaorg/go-square/namespace"
@@ -112,8 +111,8 @@ func TestCheckTx(t *testing.T) {
 			checkType: abci.CheckTxType_New,
 			getTx: func() []byte {
 				signer := createSigner(t, kr, accs[4], encCfg.TxConfig, 5)
-				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Address().String(), 10_000, 10)
-				tx, err := signer.CreatePayForBlob(blobs, opts...)
+				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Account(accs[4]).Address().String(), 10_000, 10)
+				tx, _, err := signer.CreatePayForBlobs(accs[4], blobs, opts...)
 				require.NoError(t, err)
 				return tx
 			},
@@ -124,8 +123,8 @@ func TestCheckTx(t *testing.T) {
 			checkType: abci.CheckTxType_New,
 			getTx: func() []byte {
 				signer := createSigner(t, kr, accs[5], encCfg.TxConfig, 6)
-				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Address().String(), 1_000, 1)
-				tx, err := signer.CreatePayForBlob(blobs, opts...)
+				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Account(accs[5]).Address().String(), 1_000, 1)
+				tx, _, err := signer.CreatePayForBlobs(accs[5], blobs, opts...)
 				require.NoError(t, err)
 				return tx
 			},
@@ -136,8 +135,8 @@ func TestCheckTx(t *testing.T) {
 			checkType: abci.CheckTxType_New,
 			getTx: func() []byte {
 				signer := createSigner(t, kr, accs[6], encCfg.TxConfig, 7)
-				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Address().String(), 10_000, 1)
-				tx, err := signer.CreatePayForBlob(blobs, opts...)
+				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Account(accs[6]).Address().String(), 10_000, 1)
+				tx, _, err := signer.CreatePayForBlobs(accs[6], blobs, opts...)
 				require.NoError(t, err)
 				return tx
 			},
@@ -148,8 +147,8 @@ func TestCheckTx(t *testing.T) {
 			checkType: abci.CheckTxType_New,
 			getTx: func() []byte {
 				signer := createSigner(t, kr, accs[7], encCfg.TxConfig, 8)
-				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Address().String(), 100_000, 1)
-				tx, err := signer.CreatePayForBlob(blobs, opts...)
+				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Account(accs[7]).Address().String(), 100_000, 1)
+				tx, _, err := signer.CreatePayForBlobs(accs[7], blobs, opts...)
 				require.NoError(t, err)
 				return tx
 			},
@@ -160,8 +159,8 @@ func TestCheckTx(t *testing.T) {
 			checkType: abci.CheckTxType_New,
 			getTx: func() []byte {
 				signer := createSigner(t, kr, accs[8], encCfg.TxConfig, 9)
-				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Address().String(), 1_000_000, 1)
-				tx, err := signer.CreatePayForBlob(blobs, opts...)
+				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Account(accs[8]).Address().String(), 1_000_000, 1)
+				tx, _, err := signer.CreatePayForBlobs(accs[8], blobs, opts...)
 				require.NoError(t, err)
 				return tx
 			},
@@ -172,8 +171,8 @@ func TestCheckTx(t *testing.T) {
 			checkType: abci.CheckTxType_New,
 			getTx: func() []byte {
 				signer := createSigner(t, kr, accs[9], encCfg.TxConfig, 10)
-				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Address().String(), 10_000_000, 1)
-				tx, err := signer.CreatePayForBlob(blobs, opts...)
+				_, blobs := blobfactory.RandMsgPayForBlobsWithSigner(tmrand.NewRand(), signer.Account(accs[9]).Address().String(), 10_000_000, 1)
+				tx, _, err := signer.CreatePayForBlobs(accs[9], blobs, opts...)
 				require.NoError(t, err)
 				return tx
 			},
@@ -190,8 +189,7 @@ func TestCheckTx(t *testing.T) {
 }
 
 func createSigner(t *testing.T, kr keyring.Keyring, accountName string, enc client.TxConfig, accNum uint64) *user.Signer {
-	addr := testfactory.GetAddress(kr, accountName)
-	signer, err := user.NewSigner(kr, nil, addr, enc, testutil.ChainID, accNum, 0, appconsts.LatestVersion)
+	signer, err := user.NewSigner(kr, enc, testutil.ChainID, appconsts.LatestVersion, user.NewAccount(accountName, accNum, 0))
 	require.NoError(t, err)
 	return signer
 }

app/test/integration_test.go

@@ -63,7 +63,7 @@ func (s *IntegrationTestSuite) SetupSuite() {
 
 	for _, acc := range s.accounts {
 		addr := testfactory.GetAddress(s.cctx.Keyring, acc)
-		_, _, err := user.QueryAccount(s.cctx.GoContext(), s.cctx.GRPCClient, s.ecfg, addr.String())
+		_, _, err := user.QueryAccount(s.cctx.GoContext(), s.cctx.GRPCClient, s.cctx.InterfaceRegistry, addr)
 		require.NoError(t, err)
 	}
 }

app/test/prepare_proposal_context_test.go

@@ -17,7 +17,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	abci "github.com/tendermint/tendermint/abci/types"
-	tmrand "github.com/tendermint/tendermint/libs/rand"
 )
 
 // TestTimeInPrepareProposalContext checks for an edge case where the block time
@@ -29,27 +28,23 @@ func TestTimeInPrepareProposalContext(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping TestTimeInPrepareProposalContext test in short mode.")
 	}
-	accounts := make([]string, 35)
-	for i := 0; i < len(accounts); i++ {
-		accounts[i] = tmrand.Str(9)
-	}
-	cfg := testnode.DefaultConfig().WithFundedAccounts(accounts...)
+	sendAccName := "sending"
+	vestAccName := "vesting"
+	cfg := testnode.DefaultConfig().WithFundedAccounts(sendAccName)
 	cctx, _, _ := testnode.NewNetwork(t, cfg)
 	ecfg := encoding.MakeConfig(app.ModuleEncodingRegisters...)
-	vestAccName := "vesting"
+
 	type test struct {
-		name         string
-		msgFunc      func() (msgs []sdk.Msg, signer string)
-		expectedCode uint32
+		name    string
+		msgFunc func() (msgs []sdk.Msg, signer string)
 	}
 	tests := []test{
 		{
 			name: "create continuous vesting account with a start time in the future",
 			msgFunc: func() (msgs []sdk.Msg, signer string) {
 				_, _, err := cctx.Keyring.NewMnemonic(vestAccName, keyring.English, "", "", hd.Secp256k1)
 				require.NoError(t, err)
-				sendAcc := accounts[0]
-				sendingAccAddr := testfactory.GetAddress(cctx.Keyring, sendAcc)
+				sendingAccAddr := testfactory.GetAddress(cctx.Keyring, sendAccName)
 				vestAccAddr := testfactory.GetAddress(cctx.Keyring, vestAccName)
 				msg := vestingtypes.NewMsgCreateVestingAccount(
 					sendingAccAddr,
@@ -59,15 +54,13 @@ func TestTimeInPrepareProposalContext(t *testing.T) {
 					time.Now().Add(time.Second*100).Unix(),
 					false,
 				)
-				return []sdk.Msg{msg}, sendAcc
+				return []sdk.Msg{msg}, sendAccName
 			},
-			expectedCode: abci.CodeTypeOK,
 		},
 		{
 			name: "send funds from the vesting account after it has been created",
 			msgFunc: func() (msgs []sdk.Msg, signer string) {
-				sendAcc := accounts[1]
-				sendingAccAddr := testfactory.GetAddress(cctx.Keyring, sendAcc)
+				sendingAccAddr := testfactory.GetAddress(cctx.Keyring, sendAccName)
 				vestAccAddr := testfactory.GetAddress(cctx.Keyring, vestAccName)
 				msg := banktypes.NewMsgSend(
 					vestAccAddr,
@@ -76,25 +69,19 @@ func TestTimeInPrepareProposalContext(t *testing.T) {
 				)
 				return []sdk.Msg{msg}, vestAccName
 			},
-			expectedCode: abci.CodeTypeOK,
 		},
 	}
 
 	// sign and submit the transactions
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			msgs, account := tt.msgFunc()
-			addr := testfactory.GetAddress(cctx.Keyring, account)
-			signer, err := user.SetupSigner(cctx.GoContext(), cctx.Keyring, cctx.GRPCClient, addr, ecfg)
+			txClient, err := user.SetupTxClient(cctx.GoContext(), cctx.Keyring, cctx.GRPCClient, ecfg)
+			require.NoError(t, err)
+			msgs, _ := tt.msgFunc()
+			res, err := txClient.SubmitTx(cctx.GoContext(), msgs, user.SetGasLimit(1000000), user.SetFee(2000))
 			require.NoError(t, err)
-			res, err := signer.SubmitTx(cctx.GoContext(), msgs, user.SetGasLimit(1000000), user.SetFee(2000))
-			if tt.expectedCode != abci.CodeTypeOK {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-			}
 			require.NotNil(t, res)
-			assert.Equal(t, tt.expectedCode, res.Code, res.RawLog)
+			assert.Equal(t, abci.CodeTypeOK, res.Code, res.RawLog)
 		})
 	}
 }

app/test/priority_test.go

@@ -9,16 +9,19 @@ import (
 
 	"github.com/celestiaorg/celestia-app/v2/app"
 	"github.com/celestiaorg/celestia-app/v2/app/encoding"
+	"github.com/celestiaorg/go-square/namespace"
+
 	"github.com/celestiaorg/celestia-app/v2/pkg/appconsts"
 	"github.com/celestiaorg/celestia-app/v2/pkg/user"
 	"github.com/celestiaorg/celestia-app/v2/test/util/blobfactory"
 	"github.com/celestiaorg/celestia-app/v2/test/util/testfactory"
 	"github.com/celestiaorg/celestia-app/v2/test/util/testnode"
+
 	blobtypes "github.com/celestiaorg/celestia-app/v2/x/blob/types"
-	"github.com/celestiaorg/go-square/namespace"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
+
 	abci "github.com/tendermint/tendermint/abci/types"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	rpctypes "github.com/tendermint/tendermint/rpc/core/types"
@@ -34,18 +37,20 @@ func TestPriorityTestSuite(t *testing.T) {
 type PriorityTestSuite struct {
 	suite.Suite
 
-	ecfg    encoding.Config
-	signers []*user.Signer
-	cctx    testnode.Context
+	ecfg         encoding.Config
+	accountNames []string
+	txClient     *user.TxClient
+	cctx         testnode.Context
 
 	rand *tmrand.Rand
 }
 
 func (s *PriorityTestSuite) SetupSuite() {
 	t := s.T()
 
+	s.accountNames = testfactory.GenerateAccounts(10)
 	cfg := testnode.DefaultConfig().
-		WithFundedAccounts(testfactory.GenerateAccounts(10)...).
+		WithFundedAccounts(s.accountNames...).
 		// use a long block time to guarantee that some transactions are included in the same block
 		WithTimeoutCommit(time.Second)
 
@@ -56,13 +61,9 @@ func (s *PriorityTestSuite) SetupSuite() {
 
 	require.NoError(t, cctx.WaitForNextBlock())
 
-	for _, acc := range cfg.Genesis.Accounts() {
-		addr := sdk.AccAddress(acc.PubKey.Address())
-		signer, err := user.SetupSigner(s.cctx.GoContext(), s.cctx.Keyring, s.cctx.GRPCClient, addr, s.ecfg)
-		signer.SetPollTime(time.Millisecond * 300)
-		require.NoError(t, err)
-		s.signers = append(s.signers, signer)
-	}
+	var err error
+	s.txClient, err = user.SetupTxClient(s.cctx.GoContext(), s.cctx.Keyring, s.cctx.GRPCClient, s.ecfg)
+	require.NoError(t, err)
 }
 
 // TestPriorityByGasPrice tests that transactions are sorted by gas price when
@@ -73,24 +74,22 @@ func (s *PriorityTestSuite) TestPriorityByGasPrice() {
 	t := s.T()
 
 	// quickly submit blobs with a random fee
-
-	hashes := make(chan string, len(s.signers))
+	hashes := make(chan string, len(s.accountNames))
 	blobSize := uint32(100)
 	gasLimit := blobtypes.DefaultEstimateGas([]uint32{blobSize})
 	wg := &sync.WaitGroup{}
-	for _, signer := range s.signers {
+	for _, accName := range s.accountNames {
 		wg.Add(1)
-		signer := signer // new variable per iteration
+		accName := accName // new variable per iteration
 		go func() {
 			defer wg.Done()
 			// ensure that it is greater than the min gas price
 			gasPrice := float64(s.rand.Intn(1000)+1) * appconsts.DefaultMinGasPrice
-			resp, err := signer.SubmitPayForBlob(
+			blobs := blobfactory.ManyBlobs(s.rand, []namespace.Namespace{namespace.RandomBlobNamespace()}, []int{100})
+			resp, err := s.txClient.BroadcastPayForBlobWithAccount(
 				s.cctx.GoContext(),
-				blobfactory.ManyBlobs(
-					s.rand,
-					[]namespace.Namespace{namespace.RandomBlobNamespace()},
-					[]int{100}),
+				accName,
+				blobs,
 				user.SetGasLimitAndFee(gasLimit, gasPrice),
 			)
 			require.NoError(t, err)

app/test/process_proposal_test.go

@@ -35,8 +35,7 @@ func TestProcessProposal(t *testing.T) {
 	accounts := testfactory.GenerateAccounts(6)
 	testApp, kr := testutil.SetupTestAppWithGenesisValSet(app.DefaultConsensusParams(), accounts...)
 	infos := queryAccountInfo(testApp, accounts, kr)
-	addr := testfactory.GetAddress(kr, accounts[0])
-	signer, err := user.NewSigner(kr, nil, addr, enc, testutil.ChainID, infos[0].AccountNum, infos[0].Sequence, appconsts.LatestVersion)
+	signer, err := user.NewSigner(kr, enc, testutil.ChainID, appconsts.LatestVersion, user.NewAccount(accounts[0], infos[0].AccountNum, infos[0].Sequence))
 	require.NoError(t, err)
 
 	// create 4 single blob blobTxs that are signed with valid account numbers