test: consistent appHash between commits

app/test/non_determinism_test.go

@@ -0,0 +1,132 @@
+package app_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/celestiaorg/celestia-app/v2/app"
+	"github.com/celestiaorg/celestia-app/v2/app/encoding"
+	"github.com/celestiaorg/celestia-app/v2/pkg/appconsts"
+	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"
+	"github.com/celestiaorg/go-square/blob"
+	appns "github.com/celestiaorg/go-square/namespace"
+	"github.com/cosmos/cosmos-sdk/codec"
+	hd "github.com/cosmos/cosmos-sdk/crypto/hd"
+	keyring "github.com/cosmos/cosmos-sdk/crypto/keyring"
+	"github.com/cosmos/cosmos-sdk/crypto/types"
+	"github.com/stretchr/testify/require"
+	abci "github.com/tendermint/tendermint/abci/types"
+)
+
+// TestNonDeterminismBetweenMainAndV1 executes a set of different transactions,
+// produces an app hash and compares it with the app hash produced by v1.x
+func TestNonDeterminismBetweenMainAndV1(t *testing.T) {
+	const (
+		numBlobTxs, numNormalTxs = 5, 5
+	)
+
+	expectedAppHash := []byte{100, 237, 125, 126, 116, 10, 189, 82, 156, 116, 176, 136, 169, 92, 185, 12, 72, 134, 254, 175, 234, 13, 159, 90, 139, 192, 190, 248, 67, 9, 32, 217}
+
+	// Initialize testApp
+	testApp := testutil.NewTestApp()
+
+	enc := encoding.MakeConfig(app.ModuleEncodingRegisters...)
+	// Create deterministic keys
+	kr, pubKeys := DeterministicKeyRing(enc.Codec)
+
+	recs, err := kr.List()
+	require.NoError(t, err)
+	addresses := make([]string, 0, len(recs))
+
+	// Get the name of the records
+	for _, rec := range recs {
+		addresses = append(addresses, rec.Name)
+	}
+
+	// Apply genesis state to the app
+	_, _, err = testutil.ApplyGenesisState(testApp, pubKeys, 1_000_000_000, app.DefaultInitialConsensusParams())
+	require.NoError(t, err)
+
+	accinfos := queryAccountInfo(testApp, addresses, kr)
+
+	// Create a set of 10 deterministic sdk transactions
+	normalTxs := testutil.SendTxsWithAccounts(
+		t,
+		testApp,
+		enc.TxConfig,
+		kr,
+		1000,
+		addresses[0],
+		addresses[:numNormalTxs],
+		testutil.ChainID,
+	)
+
+	// Create a set of 5 deterministic blob transactions
+	blobTxs := blobfactory.ManyMultiBlobTx(t, enc.TxConfig, kr, testutil.ChainID, addresses[numBlobTxs+1:], accinfos[numBlobTxs+1:], testfactory.Repeat([]*blob.Blob{
+		blob.New(DeterministicNamespace(), []byte{1}, appconsts.DefaultShareVersion),
+	}, numBlobTxs), app.DefaultInitialConsensusParams().Version.AppVersion)
+
+	// Deliver sdk txs
+	for _, tx := range normalTxs {
+		resp := testApp.DeliverTx(abci.RequestDeliverTx{Tx: tx})
+		require.EqualValues(t, 0, resp.Code, resp.Log)
+	}
+
+	// Deliver blob txs
+	for _, tx := range blobTxs {
+		blobTx, ok := blob.UnmarshalBlobTx(tx)
+		require.True(t, ok)
+		resp := testApp.DeliverTx(abci.RequestDeliverTx{Tx: blobTx.Tx})
+		require.EqualValues(t, 0, resp.Code, resp.Log)
+	}
+
+	// Commit the state
+	testApp.Commit()
+
+	// Get the app hash
+	appHash := testApp.LastCommitID().Hash
+
+	// Assert that the app hash is equal to the app hash produced by v1.x
+	require.Equal(t, expectedAppHash, appHash)
+}
+
+// DeterministicNamespace returns a deterministic namespace
+func DeterministicNamespace() appns.Namespace {
+	return appns.Namespace{
+		Version: 0,
+		ID:      []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 67, 154, 200, 228, 130, 74, 147, 162, 11},
+	}
+}
+
+// DeterministicKeyRing returns a deterministic keyring and a list of deterministic public keys
+func DeterministicKeyRing(cdc codec.Codec) (keyring.Keyring, []types.PubKey) {
+	mnemonics := []string{
+		"great myself congress genuine scale muscle view uncover pipe miracle sausage broccoli lonely swap table foam brand turtle comic gorilla firm mad grunt hazard",
+		"cheap job month trigger flush cactus chest juice dolphin people limit crunch curious secret object beach shield snake hunt group sketch cousin puppy fox",
+		"oil suffer bamboo one better attack exist dolphin relief enforce cat asset raccoon lava regret found love certain plunge grocery accuse goat together kiss",
+		"giraffe busy subject doll jump drama sea daring again club spend toe mind organ real liar permit refuse change opinion donkey job cricket speed",
+		"fee vapor thing fish fan memory negative raven cram win quantum ozone job mirror shoot sting quiz black apart funny sort cancel friend curtain",
+		"skin beef review pilot tooth act any alarm there only kick uniform ticket material cereal radar ethics list unlock method coral smooth street frequent",
+		"ecology scout core guard load oil school effort near alcohol fancy save cereal owner enforce impact sand husband trophy solve amount fish festival sell",
+		"used describe angle twin amateur pyramid bitter pool fluid wing erode rival wife federal curious drink battle put elbow mandate another token reveal tone",
+		"reason fork target chimney lift typical fine divorce mixture web robot kiwi traffic stove miss crane welcome camp bless fuel october riot pluck ordinary",
+		"undo logic mobile modify master force donor rose crumble forget plate job canal waste turn damp sure point deposit hazard quantum car annual churn",
+		"charge subway treat loop donate place loan want grief leg message siren joy road exclude match empty enforce vote meadow enlist vintage wool involve",
+	}
+	kb := keyring.NewInMemory(cdc)
+	pubKeys := make([]types.PubKey, len(mnemonics))
+	for idx, mnemonic := range mnemonics {
+		rec, err := kb.NewAccount(fmt.Sprintf("account-%d", idx), mnemonic, "", "", hd.Secp256k1)
+		if err != nil {
+			panic(err)
+		}
+		pubKey, err := rec.GetPubKey()
+		if err != nil {
+			panic(err)
+		}
+		pubKeys[idx] = pubKey
+	}
+	return kb, pubKeys
+}

app/test/prepare_proposal_test.go

@@ -40,6 +40,7 @@ func TestPrepareProposalPutsPFBsAtEnd(t *testing.T) {
 		testfactory.Repeat([]*blob.Blob{
 			blob.New(appns.RandomBlobNamespace(), []byte{1}, appconsts.DefaultShareVersion),
 		}, numBlobTxs),
+		app.DefaultConsensusParams().Version.AppVersion,
 	)
 
 	normalTxs := testutil.SendTxsWithAccounts(
@@ -97,6 +98,7 @@ func TestPrepareProposalFiltering(t *testing.T) {
 			testfactory.RandomBlobNamespaces(tmrand.NewRand(), 3),
 			[][]int{{100}, {1000}, {420}},
 		),
+		app.DefaultConsensusParams().Version.AppVersion,
 	)
 
 	// create 3 MsgSend transactions that are signed with valid account numbers
@@ -136,7 +138,7 @@ func TestPrepareProposalFiltering(t *testing.T) {
 	nilAccount := "carmon san diego"
 	_, _, err := kr.NewMnemonic(nilAccount, keyring.English, "", "", hd.Secp256k1)
 	require.NoError(t, err)
-	noAccountTx := []byte(testutil.SendTxWithManualSequence(t, encConf.TxConfig, kr, nilAccount, accounts[0], 1000, "", 0, 6))
+	noAccountTx := []byte(testutil.SendTxWithManualSequence(t, encConf.TxConfig, kr, nilAccount, accounts[0], 1000, "", 0, app.DefaultConsensusParams().Version.AppVersion, 6))
 
 	type test struct {
 		name      string

app/test/process_proposal_test.go

@@ -47,6 +47,7 @@ func TestProcessProposal(t *testing.T) {
 			testfactory.RandomBlobNamespaces(tmrand.NewRand(), 4),
 			[][]int{{100}, {1000}, {420}, {300}},
 		),
+		app.DefaultConsensusParams().Version.AppVersion,
 	)
 
 	// create 3 MsgSend transactions that are signed with valid account numbers

test/e2e/testnet/testnet.go

@@ -73,7 +73,7 @@ func (t *Testnet) CreateGenesisNode(version string, selfDelegation, upgradeHeigh
 	if err != nil {
 		return err
 	}
-	if err := t.genesis.AddValidator(node.GenesisValidator()); err != nil {
+	if err := t.genesis.NewValidator(node.GenesisValidator()); err != nil {
 		return err
 	}
 	t.nodes = append(t.nodes, node)

test/util/blobfactory/payforblob_factory.go

@@ -222,12 +222,13 @@ func ManyMultiBlobTx(
 	accounts []string,
 	accInfos []AccountInfo,
 	blobs [][]*blob.Blob,
+	appVersion uint64,
 ) [][]byte {
 	t.Helper()
 	txs := make([][]byte, len(accounts))
 	opts := DefaultTxOpts()
 	for i, acc := range accounts {
-		signer, err := user.NewSigner(kr, enc, chainid, appconsts.LatestVersion, user.NewAccount(acc, accInfos[i].AccountNum, accInfos[i].Sequence))
+		signer, err := user.NewSigner(kr, enc, chainid, appVersion, user.NewAccount(acc, accInfos[i].AccountNum, accInfos[i].Sequence))
 		require.NoError(t, err)
 		txs[i], _, err = signer.CreatePayForBlobs(acc, blobs[i], opts...)
 		require.NoError(t, err)

test/util/direct_tx_gen.go

@@ -192,6 +192,7 @@ func SendTxsWithAccounts(
 			chainid,
 			acc.GetSequence(),
 			acc.GetAccountNumber(),
+			appconsts.LatestVersion,
 			opts...,
 		)
 	}
@@ -209,10 +210,11 @@ func SendTxWithManualSequence(
 	amount uint64,
 	chainid string,
 	sequence, accountNum uint64,
+	appVersion uint64,
 	opts ...user.TxOption,
 ) coretypes.Tx {
 	fromAddr, toAddr := getAddress(fromAcc, kr), getAddress(toAcc, kr)
-	signer, err := user.NewSigner(kr, cfg, chainid, appconsts.LatestVersion, user.NewAccount(fromAcc, accountNum, sequence))
+	signer, err := user.NewSigner(kr, cfg, chainid, appVersion, user.NewAccount(fromAcc, accountNum, sequence))
 	require.NoError(t, err)
 
 	msg := banktypes.NewMsgSend(fromAddr, toAddr, sdk.NewCoins(sdk.NewCoin(app.BondDenom, sdk.NewIntFromUint64(amount))))

test/util/genesis/genesis.go

@@ -44,6 +44,21 @@ type Genesis struct {
 	genOps []Modifier
 }
 
+// Accounts getter
+func (g *Genesis) Accounts() []Account {
+	return g.accounts
+}
+
+// Keyring getter
+func (g *Genesis) Keyring() keyring.Keyring {
+	return g.kr
+}
+
+// Validators getter
+func (g *Genesis) Validators() []Validator {
+	return g.validators
+}
+
 // NewDefaultGenesis creates a new default genesis with no accounts or validators.
 func NewDefaultGenesis() *Genesis {
 	ecfg := encoding.MakeConfig(app.ModuleBasics)
@@ -58,29 +73,34 @@ func NewDefaultGenesis() *Genesis {
 	return g
 }
 
+// WithModifier adds a genesis modifier to the genesis.
 func (g *Genesis) WithModifiers(ops ...Modifier) *Genesis {
 	g.genOps = append(g.genOps, ops...)
 	return g
 }
 
+// WithConsensusParams sets the consensus parameters of the genesis.
 func (g *Genesis) WithConsensusParams(params *tmproto.ConsensusParams) *Genesis {
 	g.ConsensusParams = params
 	return g
 }
 
+// WithChainID sets the chain ID of the genesis.
 func (g *Genesis) WithChainID(chainID string) *Genesis {
 	g.ChainID = chainID
 	return g
 }
 
+// WithGenesisTime sets the genesis time of the genesis.
 func (g *Genesis) WithGenesisTime(genesisTime time.Time) *Genesis {
 	g.GenesisTime = genesisTime
 	return g
 }
 
+// WithAccounts adds the given validators to the genesis.
 func (g *Genesis) WithValidators(vals ...Validator) *Genesis {
 	for _, val := range vals {
-		err := g.AddValidator(val)
+		err := g.NewValidator(val)
 		if err != nil {
 			panic(err)
 		}
@@ -100,6 +120,7 @@ func (g *Genesis) WithKeyringAccounts(accs ...KeyringAccount) *Genesis {
 	return g
 }
 
+// AddAccount adds an existing account to the genesis.
 func (g *Genesis) AddAccount(account Account) error {
 	for _, acc := range g.accounts {
 		if bytes.Equal(acc.PubKey.Bytes(), account.PubKey.Bytes()) {
@@ -110,6 +131,7 @@ func (g *Genesis) AddAccount(account Account) error {
 	return nil
 }
 
+// NewAccount creates a new account and adds it to the genesis.
 func (g *Genesis) NewAccount(acc KeyringAccount) error {
 	if err := acc.ValidateBasic(); err != nil {
 		return err
@@ -139,16 +161,12 @@ func (g *Genesis) NewAccount(acc KeyringAccount) error {
 	return nil
 }
 
+// AddValidator verifies and adds a given validator to the genesis.
 func (g *Genesis) AddValidator(val Validator) error {
 	if err := val.ValidateBasic(); err != nil {
 		return err
 	}
 
-	// Add the validator's genesis account
-	if err := g.NewAccount(val.KeyringAccount); err != nil {
-		return err
-	}
-
 	// Add the validator's genesis transaction
 	gentx, err := val.GenTx(g.ecfg, g.kr, g.ChainID)
 	if err != nil {
@@ -161,10 +179,17 @@ func (g *Genesis) AddValidator(val Validator) error {
 	return nil
 }
 
-func (g *Genesis) Accounts() []Account {
-	return g.accounts
+// Creates a new validator account and adds it to the genesis.
+func (g *Genesis) NewValidator(val Validator) error {
+	// Add the validator's genesis account
+	if err := g.NewAccount(val.KeyringAccount); err != nil {
+		return err
+	}
+
+	return g.AddValidator(val)
 }
 
+// Export returns the genesis document of the network.
 func (g *Genesis) Export() (*coretypes.GenesisDoc, error) {
 	gentxs := make([]json.RawMessage, 0, len(g.genTxs))
 	for _, genTx := range g.genTxs {
@@ -186,14 +211,6 @@ func (g *Genesis) Export() (*coretypes.GenesisDoc, error) {
 	)
 }
 
-func (g *Genesis) Keyring() keyring.Keyring {
-	return g.kr
-}
-
-func (g *Genesis) Validators() []Validator {
-	return g.validators
-}
-
 // Validator returns the validator at the given index. False is returned if the
 // index is out of bounds.
 func (g *Genesis) Validator(i int) (Validator, bool) {